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" );