java的反射机制

动态代理

【案例】首先来看看如何获得类加载器：

 

 

?

1 2 3 4 5 6 7 8 9

classtest{        } classhello{     publicstaticvoidmain(String[] args) {         test t=newtest();         System.out.println("类加载器  "+t.getClass().getClassLoader().getClass().getName());     } }

 

【程序输出】：

类加载器  sun.misc.Launcher$AppClassLoader

其实在java中有三种类类加载器。

1）Bootstrap ClassLoader此加载器采用c++编写，一般开发中很少见。

2）Extension ClassLoader用来进行扩展类的加载，一般对应的是jre\lib\ext目录中的类

3）AppClassLoader加载classpath指定的类，是最常用的加载器。同时也是java中默认的加载器。

如果想要完成动态代理，首先需要定义一个InvocationHandler接口的子类，已完成代理的具体操作。

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

packageReflect; importjava.lang.reflect.*;    //定义项目接口 interfaceSubject {     publicString say(String name,intage); }    // 定义真实项目 classRealSubjectimplementsSubject {     @Override     publicString say(String name,intage) {         returnname +"  "+ age;     } }    classMyInvocationHandlerimplementsInvocationHandler {     privateObject obj =null;        publicObject bind(Object obj) {         this.obj = obj;         returnProxy.newProxyInstance(obj.getClass().getClassLoader(), obj                 .getClass().getInterfaces(),this);     }        @Override     publicObject invoke(Object proxy, Method method, Object[] args)             throwsThrowable {         Object temp = method.invoke(this.obj, args);         returntemp;     } }    classhello {     publicstaticvoidmain(String[] args) {         MyInvocationHandler demo =newMyInvocationHandler();         Subject sub = (Subject) demo.bind(newRealSubject());         String info = sub.say("Rollen",20);         System.out.println(info);     } }

【运行结果】：

Rollen  20

类的生命周期

在一个类编译完成之后，下一步就需要开始使用类，如果要使用一个类，肯定离不开JVM。在程序执行中JVM通过装载，链接，初始化这3个步骤完成。

类的装载是通过类加载器完成的，加载器将.class文件的二进制文件装入JVM的方法区，并且在堆区创建描述这个类的java.lang.Class对象。用来封装数据。但是同一个类只会被类装载器装载以前

链接就是把二进制数据组装为可以运行的状态。

 

链接分为校验，准备，解析这3个阶段

校验一般用来确认此二进制文件是否适合当前的JVM（版本），

准备就是为静态成员分配内存空间，。并设置默认值

解析指的是转换常量池中的代码作为直接引用的过程，直到所有的符号引用都可以被运行程序使用（建立完整的对应关系）

完成之后，类型也就完成了初始化，初始化之后类的对象就可以正常使用了，直到一个对象不再使用之后，将被垃圾回收。释放空间。

当没有任何引用指向Class对象时就会被卸载，结束类的生命周期

将反射用于工厂模式

先来看看，如果不用反射的时候，的工厂模式吧：

http://www.cnblogs.com/rollenholt/archive/2011/08/18/2144851.html

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41

/**  * @author Rollen-Holt 设计模式之 工厂模式  */    interfacefruit{     publicabstractvoideat(); }    classAppleimplementsfruit{     publicvoideat(){         System.out.println("Apple");     } }    classOrangeimplementsfruit{     publicvoideat(){         System.out.println("Orange");     } }    // 构造工厂类 // 也就是说以后如果我们在添加其他的实例的时候只需要修改工厂类就行了 classFactory{     publicstaticfruit getInstance(String fruitName){         fruit f=null;         if("Apple".equals(fruitName)){             f=newApple();         }         if("Orange".equals(fruitName)){             f=newOrange();         }         returnf;     } } classhello{     publicstaticvoidmain(String[] a){         fruit f=Factory.getInstance("Orange");         f.eat();     }    }

这样，当我们在添加一个子类的时候，就需要修改工厂类了。如果我们添加太多的子类的时候，改的就会很多。

现在我们看看利用反射机制：

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

packageReflect;    interfacefruit{     publicabstractvoideat(); }    classAppleimplementsfruit{     publicvoideat(){         System.out.println("Apple");     } }    classOrangeimplementsfruit{     publicvoideat(){         System.out.println("Orange");     } }    classFactory{     publicstaticfruit getInstance(String ClassName){         fruit f=null;         try{             f=(fruit)Class.forName(ClassName).newInstance();         }catch(Exception e) {             e.printStackTrace();         }         returnf;     } } classhello{     publicstaticvoidmain(String[] a){         fruit f=Factory.getInstance("Reflect.Apple");         if(f!=null){             f.eat();         }     } }

现在就算我们添加任意多个子类的时候，工厂类就不需要修改。

 

上面的爱吗虽然可以通过反射取得接口的实例，但是需要传入完整的包和类名。而且用户也无法知道一个接口有多少个可以使用的子类，所以我们通过属性文件的形式配置所需要的子类。

下面我们来看看： 结合属性文件的工厂模式

首先创建一个fruit.properties的资源文件，

内容为：

?

1 2	apple=Reflect.Apple orange=Reflect.Orange

然后编写主类代码：

 

 

?

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57

packageReflect;    importjava.io.*; importjava.util.*;    interfacefruit{     publicabstractvoideat(); }    classAppleimplementsfruit{     publicvoideat(){         System.out.println("Apple");     } }    classOrangeimplementsfruit{     publicvoideat(){         System.out.println("Orange");     } }    //操作属性文件类 classinit{     publicstaticProperties getPro()throwsFileNotFoundException, IOException{         Properties pro=newProperties();         File f=newFile("fruit.properties");         if(f.exists()){             pro.load(newFileInputStream(f));         }else{             pro.setProperty("apple","Reflect.Apple");             pro.setProperty("orange","Reflect.Orange");             pro.store(newFileOutputStream(f),"FRUIT CLASS");         }         returnpro;     } }    classFactory{     publicstaticfruit getInstance(String ClassName){         fruit f=null;         try{             f=(fruit)Class.forName(ClassName).newInstance();         }catch(Exception e) {             e.printStackTrace();         }         returnf;     } } classhello{     publicstaticvoidmain(String[] a)throwsFileNotFoundException, IOException{         Properties pro=init.getPro();         fruit f=Factory.getInstance(pro.getProperty("apple"));         if(f!=null){             f.eat();         }     } }

 

【运行结果】：Apple

 

本教程由尚硅谷教育大数据研究院出品，如需转载请注明来源。