Java反射机制

Java反射机制

1反射机制是什么

反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，
都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。

2反射机制能做什么

反射机制主要提供了以下功能： 

在运行时判断任意一个对象所属的类；

在运行时构造任意一个类的对象；

在运行时判断任意一个类所具有的成员变量和方法；

在运行时调用任意一个对象的方法；

生成动态代理。

当通过反射与另一个未知类型的对象打交道时，JVM只是简单地检查这个对象，看它属于哪个特定的类（就像RTTI那样）。在用它做其他事情之前
必须先加载那个类的Class对象。因此，那个类的.class文件对于JVM来说是必须是可获取的：要么在本地机器上，要么可以通过网络获取。所以RTTI
与反射之间真正的区别只在于，对RTTI来说，编译器在编译时打开和检查.class文件(普通方法)，而对于反射机制来说，.class文件在编译时是不可
获取的，所以是在运行时打开和检查.class文件。

例子：利用反射机制调用其他类的某些特定方法
Class<?> class1 = null;//声明一个类；
class1 =Class.forName("javaDemo.TestReflect");//获取目标类对象；
Method method1 = class1.getMethod("a");//获取目标类的特定方法对象a();
Method method2= class1.getMethod("b",int.class);//获取目标类的特定方法对象b();int.class参数对应invoke的11，即为传给b()方法的参数
Object obj1 method1.invoke(class1.newInstance());//调用目标类的特定方法a();
Object obj2 method2.invoke(class1.newInstance(),11);//获取目标类的特定方法b();


package javaDemo;
public void a(){
System.out.println("调用A方法");
}
public void b(int i){
System.out.print("调用B方法 : " + i);
}


反射机制的动态代理


/**
 * 在java中有三种类类加载器。
 * 
 * 1）Bootstrap ClassLoader 此加载器采用c++编写，一般开发中很少见。
 * 
 * 2）Extension ClassLoader 用来进行扩展类的加载，一般对应的是jrelibext目录中的类
 * 
 * 3）AppClassLoader 加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。
 * 
 * 如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。
 */
 
package javaDemo;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;


//定义项目接口
interface Subject {
public String say(String name, int age);
}


// 定义真实项目
class RealSubject implements Subject {
public String say(String name, int age) {
System.out.println("Real Subject");
return name + "  " + age;
}
}


class MyInvocationHandler implements InvocationHandler {
private Object obj = null;


public Object bind(Object obj) {
System.out.println("MyInvocationHandler ..bind");
this.obj = obj;
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
}


public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object temp = method.invoke(this.obj, args);
return temp;
}
}


public class TestReflect {
public static void main(String[] args) throws Exception {
TestReflect testReflect = new TestReflect();
System.out.println("类加载器  "
+ testReflect.getClass().getClassLoader().getClass().getName());
MyInvocationHandler demo = new MyInvocationHandler();
Subject sub = (Subject) demo.bind(new RealSubject());
String info = sub.say("Rollen", 20);
System.out.println(info);
}
}
/*输出：
 * *类加载器  sun.misc.Launcher$AppClassLoader
 *MyInvocationHandler ..bind
 *Real Subject
 *Rollen  20

 */

Android执行另外一个包里面的某个类的方法

 

Android中有Context的概念，想必大家都知道。 Context可以做很多事情，打开activity、发送广播、打开本包下文件夹和数据库、获取classLoader、获取资源等等。如果我们得到了 一个包的Context对象，那我们基本上可以做这个包自己能做的大部分事情。

          那我们能得到吗？很高兴的告诉你，能！

      Context有个createPackageContext方法，可以创建另外一个包的上下文，这个实例不同于它本身的Context实例，但是功能是一样的。

 

      这个方法有两个参数：

1。packageName  包名，要得到Context的包名

2。 flags  标志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY两个选项。 CONTEXT_INCLUDE_CODE的意思是包括代码，也就是说可以执行这个包里面的代码。CONTEXT_IGNORE_SECURITY的意思 是忽略安全警告，如果不加这个标志的话，有些功能是用不了的，会出现安全警告。

 

      下面给个小例子，执行另外一个包里面的某个类的方法。

      另外一个包的包名是chroya.demo,类名Main，方法名print，代码如下：

package  chroya.demo;  

  

import  android.app.Activity;  

import  android.os.Bundle;  

import  android.util.Log;  

  

class  Main  extends  Activity {  

      

    @Override   

    public   void  onCreate(Bundle savedInstanceState) {  

        super .onCreate(savedInstanceState);  

    }  

      

    public   void  print(String msg) {  

        Log.d("Main" ,  "msg:" + msg);  

    }  

}  

 

Context c = createPackageContext( "chroya.demo" , Context.CONTEXT_INCLUDE_CODE |Context.CONTEXT_IGNORE_SECURITY);  

//载入这个类   

Class clazz = c.getClassLoader().loadClass("chroya.demo.Main" );  

//新建一个实例   

Object owner = clazz.newInstance();  

//获取print方法，传入参数并执行   

Object obj = clazz.getMethod

("print" , String. class ).invoke(owner,  "Hello" );