Java动态性之--反射机制

1. 动态语言

程序运行时，可以改变结构或变量类型。典型的语言：

• Python、ruby、javascript等
• 如下javascript代码

function test(){

var s = "var a=3;var b=5;alert(a+b);";

eval(s);

}

• C,C++,java不是动态语言，java可以称之为“准动态语言”。但是java有一定的动态性，我们可以利用反射机制、字节码操作获得类似动态语言的特性
• java的动态性让编程的时候更加灵活！

2. 反射机制reflection

• 指的是可以于运行时加载、探知、使用编译其完全未知的类。
• 程序在运行状态中，可以动态加载一个只有名称的类，对于任意一个已加载的类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；

　　　　Class c = Class.forName(cn.stu.test.User);

• 加载完类之后，在堆内存中，就产生了一个Class类型的对象（一个类只有一个Class对象），这个对象就包含了完整的类的结构信息，我们可以通过这个对象看到类的结构。这个对象就像一面镜子，透过这个镜子看到类的结构，所有，我们形象的称之为：反射

 例1：

 public class Demo01 {
     public static void main(String[] args) {
         String path = "cn.stu.ref.bean.User";

         try {
             //方法一
             Class clazz = Class.forName(path);
             //
             /**
              * ==================================
              * 对象时表示或封装一些数据。一个类被加载后，
              * JVM会创建一个对应该类的Class对象
              * 类的整个结构信息会会放到对应的Class对象中。
              * 这个Class对象就是一面镜子一样，
              * 通过这面镜子我们可以看到对应类的全部信息
              * ===================================
              */
             System.out.println(clazz.hashCode());
             //一个类只对应一个Class对象
             Class clazz2 = Class.forName(path);
             System.out.println(clazz2.hashCode());

             //方法二
             Class strClass = String.class;
             Class strClass2 = path.getClass();
             System.out.println(strClass==strClass2);

         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         }
     }
 }

3. Class类介绍

当一个class被加载，或当加载器（class loader）的defineClass（）被JVM调用，JVM便自动产生一个Class对象

Class类似Reflection的根源

针对任何你想动态加载、运行的类，唯有先获得相应的Class对象

Class类的对象如何获取？

• 运用getClass()
• 运用Class.forName()  --常用
• 运用.class语法

例2：

 public class Demo02 {

     public static void main(String[] args) {
         String path = "cn.stu.ref.bean.User";
         try {
             Class clazz = Class.forName(path);

             //获取类的名称
             System.out.println(clazz.getName());//类名+包名
             System.out.println(clazz.getSimpleName());//类名

             //获取属性名
             Field[] fields = clazz.getFields(); //只能获得public的属性
             Field[] fields2 = clazz.getDeclaredFields();//获得所有属性
             Field field = clazz.getDeclaredField("name");//获取指定name属性

             //获取方法名称
             Method[] method = clazz.getDeclaredMethods();
             Method m1 = clazz.getDeclaredMethod("getName", null);
             //如果方法有参，则必须传递参数类型对应的class对象
             Method m2 = clazz.getDeclaredMethod("setName", String.class);

             //获取构造器
             Constructor[] constructors = clazz.getDeclaredConstructors();
             Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);

         } catch (Exception e) {
             // TODO Auto-generated catch block
             e.printStackTrace();
         }
     }
 }

 例3：

 public class Demo03 {
     public static void main(String[] args) {
         String path = "cn.stu.ref.bean.User";

         try {
             Class clazz = Class.forName(path);

             //通过反射API调用构造方法，构造对象
             User u = (User) clazz.newInstance();//其实是调用了User的无参构造方法

             Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
             User u2 = (User) c.newInstance(1001,18,"张三");

             //通过反射API调用普通方法
             User u3 = (User) clazz.newInstance();
             Method method = clazz.getDeclaredMethod("setName", String.class);
             method.invoke(u3,"李四"); //u3.setName("李四")

             //通过反射API操作属性
             User u4 = (User) clazz.newInstance();
             Field f = clazz.getDeclaredField("name");
             f.setAccessible(true);//不做安全检查，直接访问
             f.set(u4, "二麻子"); //通过反射直接写属性
             String name = u4.getName();
             String name2 = (String) f.get(u4); //通过反射直接读属性的值
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

4. 反射机制性能问题

• setAccessible
• 启动和金庸访问安全检查的开关，值为true 则指示反射的对象在使用时应该取消java语言访问检查，值为false 则指示反射的对象应该实施java语言访问检查。并不是true就能访问，false就不能访问。
• 禁止安全检查，可以提高反射的运行速度
• 可以考虑使用： cglib/javaassist字节码操作

 例4：

 /**
  * 通过跳过安全检查，提高反射效率
  * 三种执行方法的效率差异比较
  */
 public class Demo04 {

     public static void test01(){
         User u = new User();

         long startTime = System.currentTimeMillis();

         for (int i = 0; i < 1000000000L; i++) {
             u.getName();
         }

         long endTime = System.currentTimeMillis();
         System.out.println("普通方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
     }

     public static void test02() throws Exception{
         User u = new User();
         Class clazz = u.getClass();
         Method m = clazz.getDeclaredMethod("getName", null);
 //        m.setAccessible(true);

         long startTime = System.currentTimeMillis();

         for (int i = 0; i < 1000000000L; i++) {
             m.invoke(u, null);
         }

         long endTime = System.currentTimeMillis();
         System.out.println("反射动态方法调用，执行10亿次，耗时："+(endTime-startTime)+"ms");
     }

     public static void test03() throws Exception{
         User u = new User();
         Class clazz = u.getClass();
         Method m = clazz.getDeclaredMethod("getName", null);
         m.setAccessible(true);    //不需要执行访问安全检查

         long startTime = System.currentTimeMillis();

         for (int i = 0; i < 1000000000L; i++) {
             m.invoke(u, null);
         }

         long endTime = System.currentTimeMillis();
         System.out.println("反射动态方法调用，跳过安全检查，执行10亿次，耗时："+(endTime-startTime)+"ms");
     }

     public static void main(String[] args) throws Exception {
         test01();
         test02();
         test03();
     }
 }

输出结果：

　　　　普通方法调用，执行10亿次，耗时：6665ms
　　　　反射动态方法调用，执行10亿次，耗时：62947ms
　　　　反射动态方法调用，跳过安全检查，执行10亿次，耗时：11864ms

　

5. 反射操作泛型

• java采用泛型擦除的机制来引入泛型。java中的泛型仅仅是给编译器javac使用的，确保数据的安全性和免去强制类型转换的麻烦，但是，一旦编译完成，所有的和泛型有关的类型全部擦除。
• 为了通过反射操操作这些类型以迎合实际开发的需要，java就新增了ParameterzedType，GenericArrayType，TypeVariable和WildcardType几种类型来代表不能被诡异到Class类中的类型但是又和原始类型齐名的类型。

• ParmterizedType: 表示一种参数化的类型，比如Collection<String>
• GenericArrayType: 表示一种元素类型是参数化类型或者类型变量的数组类型
• TypeVariable：是各种类型变量的公共父接口
• WildcardType：代表一种通配符类型表达式