Java反射复习

Java反射概念

　　类是由成员变量、方法、构造器组成，反射是把这些组成通过类的Class对象进行分别封装操作的过程。

　　反射的操作是通过类的Class对象完成。

　　注：下面代码示例基于jdk1.8，使用的是阿里开源的龙井jdk，dragonwell1.8.4

Java反射的优点

　　直接操作Class，有统一的方法和步骤操作类的变量、方法、构造器，现在的反射代码，可以操作后期声明的类。

　　为很多的设计思想提供了途径。

Java反射的缺点

　　写代码更麻烦，性能下降，突破了权限带来安全问题

获取Class的3个方式

　　1.Class.forName("包名.类名")，这个方式经常用于配置文件中。

Class.forName("com.mysql.cj.jdbc.Driver")

 　　2.类名.class，该方法经常用于方法参数

User user = BeanUtils.copyProperties(u,User.class);

　　3.对象.getClass(),该方法经常用于获取对象字节码

Logger log = LoggerFactory.getLogger(this.getClass());

 Class对象的使用

　　Class在Java程序中只会加载一份到内存，上面三个方法获取的Class对象都是同一个内存地址，多次获取也是同一个对象。

　　Class源码中可以看到，Class对象是由Java虚拟机加载

   如下BaseEntity和User类来测试使用Class

import java.util.Date;

public class BaseEntity {
    public Date time;
    private int status;

    public Date getTime() {
        return time;
    }

    public void setTime(Date time) {
        this.time = time;
    }

    public int getStatus() {
        return status;
    }

    public void setStatus(int status) {
        this.status = status;
    }
}

public class User extends BaseEntity {
    long id;
    private String name;
    public String email;
    protected int age;

    public String read(){
        return "我在看书";
    }

    private String watch(){
        return "我在看电视";
    }

    public User() {
    }

    public User(long id, String name, String email, int age) {
        this.id = id;
        this.name = name;
        this.email = email;
        this.age = age;
    }

    public long getId() {
        return id;
    }

    public void setId(long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

Class的Field

org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(this.getClass());
    Class cls = User.class;

    @Test
    public void testClassGetField() throws Exception {
        /**
         * 结论：
         *   1. getField("xxx")/ getFields()
         *    只能获取 public修饰的成员变量，包括父类的public成员变量
         *   2. getDeclaredField("xxx")/getDeclaredFields()
         *     能获取当前类声明的成员变量，无视修饰符，但不包括父类的成员变量
         */
        //× default修饰 抛出异常,java.lang.NoSuchFieldException: name
        Field idField = cls.getField("id");
        //× private修饰 抛出异常,java.lang.NoSuchFieldException: name
        Field nameField = cls.getField("name");
        //√ public修饰 正常执行，可以获取public成员变量
        Field emailField = cls.getField("email");
        //× protected修饰 抛出异常 ，java.lang.NoSuchFieldException: age
        Field ageField = cls.getField("age");
        //√ public修饰 正常执行，可以获取 父类 public成员变量
        Field timeField = cls.getField("time");
        //× private修饰 抛出异常 ，java.lang.NoSuchFieldException: status
        Field statusField = cls.getField("status");

        // 只能获取public修饰的成员变量列表
        Field[] fields = cls.getFields();
        for (Field field : fields) {
            log.info("array--field = {}", field);
        }

        // cls.getDeclaredField("xxx") 都能获取xxx对应的成员变量
        Field idDeclaredField = cls.getDeclaredField("id");
        Field nameDeclaredField = cls.getDeclaredField("name");
        Field emailDeclaredField = cls.getDeclaredField("email");
        Field ageDeclaredField = cls.getDeclaredField("age");
        //父类的不能 抛出异常,java.lang.NoSuchFieldException: time
        Field timeDeclaredField = cls.getDeclaredField("time");
        //父类的不能 抛出异常,java.lang.NoSuchFieldException: status
        Field statusDeclaredField = cls.getDeclaredField("status");

        // 都能获取所有成员变量
        Field[] declaredFields = cls.getDeclaredFields();
        for (Field field : declaredFields) {
            log.info("array--declared field = {}", field);
        }

    }

   @Test
    public void testClassOperateFields() throws Exception {
        /**
         * 结论：
         *  1.Field对象可以获取和修改成员变量的值
         *  2.非public修饰的成员变量，获取和修改前需要获取权限
         */
        // cls反射创建User对象，需要有public的无参构造方法
        User user = (User) cls.newInstance();
        Field emailField = cls.getField("email");
        log.info("email1 = {}",emailField.get(user));
        emailField.set(user,"1@qq.com");
        // field获取成员变量的值，传参是对应对象
        log.info("email2 = {}",emailField.get(user));
        log.info("email2 = {}",user.getEmail());

        Field emailDeclaredField = cls.getDeclaredField("email");
        emailDeclaredField.set(user,"2@qq.com");
        log.info("email3 = {}",user.getEmail());

        Field idDeclaredField = cls.getDeclaredField("id");
        log.info("id1 = {}",user.getId());
        //异常 java.lang.IllegalAccessException
        log.info("id1 = {}",idDeclaredField.get(user));
        //异常 java.lang.IllegalAccessException
        idDeclaredField.set(user,9);
        // 非public修饰的成员变量需要设置权限
        idDeclaredField.setAccessible(true);
        idDeclaredField.set(user,10);
        log.info("id2 = {}",user.getId());
        log.info("id2 = {}",idDeclaredField.get(user));

    }

Class的Method　

@Test
    public void testGetClassMethods() throws Exception {
        /**
         * 结论：
         * 1.获取单个方法，需要方法名+参数列表类型按顺序排列
         *      getMethod("xxx",xx.class,xx.class..)
         * 2.有Declared修饰的方法可以获取当前类所有方法，无视修饰符
         *       仅限当前类，不包括父类
         * 3.没有Declared修饰的只能获取public修饰的方法
         *        父类，都可以获得
         */
        Method setIdMethod = cls.getMethod("setId", long.class);
        log.info("setIdMethod = {}",setIdMethod);
        //异常 java.lang.NoSuchMethodException
        Method watchMethod = cls.getMethod("watch");
        Method[] methods = cls.getMethods();
        for (Method method : methods){
            log.info("methods = {}",method);
        }

        Method setIdDeclaredMethod = cls.getDeclaredMethod("setId", long.class);
        log.info("setIdDeclaredMethod = {}",setIdDeclaredMethod);
        Method watchDeclaredMethod = cls.getDeclaredMethod("watch");
        log.info("watchDeclaredMethod = {}",watchDeclaredMethod);

        Method[] declaredMethods = cls.getDeclaredMethods();
        for (Method method : declaredMethods){
            log.info("declared = {}",method);
        }
        
    }

 @Test
    public void testUseClassMethod() throws Exception {
        /**
         * 和Field使用相似，明显区别是确定方法需要方法名+参数列表
         * 执行非public方法需要授权
         * invoke执行方法和对象.方法的结果一样
         */
        User user = (User) cls.newInstance();
        Method setIdMethod = cls.getMethod("setId", long.class);
        log.info("id1 = {}",user.getId());
        // 执行方法，对象+参数列表
        setIdMethod.invoke(user,121);
        log.info("id2 = {}",user.getId());

        Method readMethod = cls.getMethod("read");
        Object readResult = readMethod.invoke(user);
        log.info("readResult = {}",readResult);

        Method watchMethod = cls.getDeclaredMethod("watch");
        //private修饰 执行异常 java.lang.IllegalAccessException
        watchMethod.invoke(user);
        // 需要授权
        watchMethod.setAccessible(true);
        Object watchResult = watchMethod.invoke(user);
        log.info("watchResult = {}",watchResult);

    }

Class的Constructor

　   结论：不需要方法名以外，和Method相似，newInstance返回值是类的对象

Class类还有很多内容，有用到再去了解了，有兴趣的可以去看java.lang.Class源码