第二篇 java中的反射

java中的反射

一、反射的概述

     JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；

这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。要想解剖一个类,必须先要获取到该类的字节码文件对象。

而解剖使用的就是Class类中的方法.所以先要获取到每一个字节码文件对应的Class类型的对象.

1、创建实体类

public class User {
    private int id;
    private int age;
    private String uname;
    
    public User(int id, int age, String uname) {
        super();
        this.id = id;
        this.age = age;
        this.uname = uname;
    }
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getUname() {
        return uname;
    }
    public void setUname(String uname) {
        this.uname = uname;
    }
    
    @Override
    public String toString() {
        return "User [id=" + id + ", age=" + age + ", uname=" + uname + "]";
    }
    
}

2、测试java.lang.Class对象的获取方式

/**
 * 各种不同的类型的class对象的获取
 * 测试java.lang.Class对象的获取方式
 * @author Zhang XiaoDao
 *
 */
public class Demo01 {
    public static void main(String[] args) {
        String path = "com.zzp.bean.User";    
        try {
            //加载javaBean
            Class clazz = Class.forName(path);
            
            //对象是表示或封装一些数据，一个类被加载后（只能加载一次），jvm会创建一个对应该类的class对象，
            //类的整个结构信息会放到对应的class对象中,这个class对象就像是一面镜子
            //通过这面镜子，我们能看见对应类的全部信息
            System.out.println(clazz);
            //一个类只对应一个class对象，只被加载一次
            Class clazz2 = Class.forName(path);
            
            //通过.class和getClass()获取对象
            Class clazz3 =User.class;
            Class clazz4 = path.getClass();
            
            //通过.class也能获取基本数据类型
            Class int1 = int.class;
            
            //也能获取数组对象，一维数组arr01和arr02都是一样的，二维数组arr03与前面两个不同,
            //数组的类型不一样，获取到的对象也不一样d与前面三个都不相同
            int[] arr01 = new int[10];
            int[] arr02 = new int[30];
            int[][] arr03 = new int[10][20];
            double[] d = new double[10];
                    
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 3、应用反射的API，获取类的信息（类的名字，属性，方法，构造器等）

 

/**
 * 
 * 应用反射的API，获取类的信息（类的名字，属性，方法，构造器等）
 * @author Zhang XiaoDao
 *
 */
public class Demo02 {
    public static void main(String[] args) {
        String path = "com.zzp.bean.User";    
        try {
            //加载javaBean
            Class clazz = Class.forName(path);
            
            //获取类的全路径
            System.out.println(clazz.getName());
            
            //只获取类名
            System.out.println(clazz.getSimpleName());
            
            //获取属性信息
            //Field[] fields = clazz.getFields();//只能获取public修饰的属性
            Field[] fields = clazz.getDeclaredFields();//获取所有的属性
            System.out.println(fields.length);
            
            Field field = clazz.getDeclaredField("uname");//获取单个的属性
            System.out.println(field);
            
            //获取方法信息
            Method[] method = clazz.getDeclaredMethods();//获得所有的方法
            Method m01 = clazz.getDeclaredMethod("getUname", null);//根据指定的方法名获取，无参传null
            Method m02 = clazz.getDeclaredMethod("setUname", String.class);//有参的传参数
            
            //获取构造器
            Constructor[] constructor = clazz.getDeclaredConstructors();//获取所有的构造器
            //获取无参构造
            Constructor a = clazz.getDeclaredConstructor(null);
            //获取有参构造
            Constructor c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
            
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }    
}

 4、通过反射API动态的操作：构造器、方法、属性

/**
 * 
 * 通过反射API动态的操作：构造器、方法、属性
 * @author Zhang XiaoDao
 *
 */
public class Demo03 {
    public static void main(String[] args) {
        String path = "com.zzp.bean.User";
        //加载javaBean
        try {
            Class<User> clazz = (Class<User>) Class.forName(path);
            
            //通过反射API动态调用构造方法，构造对象
            //其实是调用无参的构造器，javabean必须要有无参构造方法
            User user = clazz.newInstance();
            System.out.println(user);
            
            //调用指定的构造器
             Constructor<User> c = clazz.getDeclaredConstructor(int.class,int.class,String.class);
             User user2 = c.newInstance(1024,18,"张小刀1");
             System.out.println(user2.getUname());
             
             //通过反射API调用普通的方法
             User user3 = clazz.newInstance();
             Method m = clazz.getDeclaredMethod("setUname", String.class);
             m.invoke(user3, "张小刀2");//以上的两步相当于u3.setUname("张小刀")
             System.out.println(user3.getUname());
             
             //通过反射API操作属性
             User user4 = clazz.newInstance();
             Field f = clazz.getDeclaredField("uname");
             f.setAccessible(true);//这个属性不需要做安全检查了，可以直接访问
             f.set(user4, "张小刀3");//通过反射直接写属性
             System.out.println(user4.getUname());//通过反射直接读属性
             System.out.println(f.get(user4));
             
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

 

反射机制的性能问题

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

/**
 * 测试反射调用对象方法时，跳过安全检查与不跳过安全检查之间的性能差别
 * @author Zhang XiaoDao
 *
 */
public class Demo06 {
    public static void test01(){
        User u = new User();
        long startTime = System.currentTimeMillis();
        
        for(int i=0;i<1000000000L;i++){
            u.getUname();
        }
        
        long endTime = System.currentTimeMillis();
        System.out.println("普通方法调用执行10亿次耗时："+(endTime-startTime)+"ms");
    }
    
    public static void test02(){
        User u = new User();
        Class clazz = u.getClass();
        try {
            Method m = clazz.getDeclaredMethod("getUname", null);
            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");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
    
    public static void test03(){
        User u = new User();
        Class clazz = u.getClass();
        try {
            Method m = clazz.getDeclaredMethod("getUname", 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");
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
    
    public static void main(String[] args) {
        test01();
        test02();
        test03();
    }
}

 普通方法调用执行10亿次耗时：745ms 2 反射动态方法调用,不跳过安全检查，执行10亿次耗时：4527ms 3 反射动态方法调用,跳过安全检查，执行10亿次耗时：3469ms 

 

反射操作泛型

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

① ParameterizedType:表示一种参数化的类型，比如：Collection<String>

②GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型

③TypeVariable:是各种类型变量的公共父接口

④WildcardType:代表一种通配符类型表达式，比如：？，？extends Number,? super Integer

wildcard是一个单词：通配符的意思

/**
 * 
 * 通过反射获取泛型信息
 * 参数信息
 * 返回信息
 * @author Zhang XiaoDao
 *
 */
public class Demo04 {
    public void test01(Map<String,User> map,List<User> list){
        System.out.println("Demo04.test01()");
    }
    
    public Map<Integer,User> test02(){
        System.out.println("Demo04.test02()");
        return null;
    }
    
    public static void main(String[] args) throws Exception{
        Method m = Demo04.class.getMethod("test01", Map.class,List.class);
        Type[] T = m.getGenericParameterTypes();
        for (Type t : T) {
            System.out.println("t:"+t);
            if(t instanceof ParameterizedType){
                Type[] genericTypes = ((ParameterizedType) t).getActualTypeArguments();
                for (Type type : genericTypes) {
                    System.out.println("泛型类型："+ type);
                }
            }
        }
        
        Method m2 = Demo04.class.getMethod("test02", null);
        Type genericReturnType = m2.getGenericReturnType();
        if(genericReturnType instanceof ParameterizedType){
            Type[] actualTypeArguments = ((ParameterizedType) genericReturnType).getActualTypeArguments();
            for (Type type : actualTypeArguments) {
                System.out.println("返回值泛型类型："+type);
            }
        }
    }
}

 

反射操作注解

/**
 * 
 *使用反射读取注解的信息，模拟处理注解的流程
 *@author Zhang XiaoDao 
 */
public class Demo03 {

    public static void main(String[] args) throws NoSuchFieldException, SecurityException{        
        try {
            //通过反射加载需要处理的类
            Class clazz = Class.forName("com.zzp.annotation.ZzpStudent");
            
            //获得类的所有有效的注解
            Annotation[] Annotations = clazz.getAnnotations();
            for (Annotation at : Annotations) {
                System.out.println(at);
            }
            
            //获取类的指定的注解
            Table t = (Table) clazz.getAnnotation(Table.class);
            //输出t的值
            System.out.println(t.value());
            
            //获取类的属性的注解
            Field f = clazz.getDeclaredField("sname");
            ZzpFiled t1 = f.getAnnotation(ZzpFiled.class);
            System.out.println(t1.columnName()+"---"+t1.type()+"---"+t1.length());
            
            //可以根据获得的表名，属性等，拼出DDL语句，使用JDBC执行这个sql,在数据库中生成相关的表
            
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }

}