Java反射和动态代理

什么是Java反射机制

Java反射机制，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；也就是说，Java可以加载一个运行时才得知名称的class，获得其完整结构。

JAVA反射机制提供了什么功能

• 获取类的Class对象
• 获取类的Fields
• 获取类的Method
• 获取类的Constructor
• 新建类的实例
  Class<T>的函数newInstance
  通过Constructor对象的方法newInstance

举个例子

public class User {
    private int id;
    private String userName;

    public int getId() {
        return id;
    }

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

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }
    
}

public class Test {

    public static void main(String[] args) throws Exception {

        Class<?> classType = User.class;
        //获取属性
        Field[] fields = classType.getFields();
        for (Field field : fields){
            System.out.println(field.getName());
        }
       
        Field[] declaredFields = classType.getDeclaredFields();
        for (Field declaredField : declaredFields){
            System.out.println(declaredField.getName());
        }
        
        Field field = classType.getDeclaredField("id");
        User user = new User();
        user.setId(1);
        //暴力访问
        field.setAccessible(true);
        System.out.println(field.get(user));
        
        Method method1 = classType.getDeclaredMethod("setUserName",String.class);
        method1.invoke(user,"kobe");
        Method method = classType.getDeclaredMethod("getUserName",null);
        System.out.println(method.invoke(user));
    }

}

运行结果如下：
id
userName
1
kobe

Java动态代理详解

代理模式：给某一个对象提供一个代理，并由代理对象来控制对真实对象的访问
先来理解一下Java静态代理，声明一个接口UserService

public interface UserService {
    public void select();   
    public void update();
}

public class UserServiceImpl implements UserService {  
    public void select() {  
        System.out.println("查询 selectById");
    }
    public void update() {
        System.out.println("更新 update");
    }
}

代理类：UserServiceProxy

public class UserServiceProxy implements UserService {
    private UserService target; // 被代理的对象

    public UserServiceProxy(UserService target) {
        this.target = target;
    }
    public void select() {
        before();
        target.select();    // 这里才实际调用真实主题角色的方法
        after();
    }
    public void update() {
        before();
        target.update();    // 这里才实际调用真实主题角色的方法
        after();
    }

    private void before() {     // 在执行方法之前执行
        System.out.println(String.format("log start time [%s] ", new Date()));
    }
    private void after() {      // 在执行方法之后执行
        System.out.println(String.format("log end time [%s] ", new Date()));
    }
}

测试

public class Test {
    public static void main(String[] args) {
        UserService userServiceImpl = new UserServiceImpl();
        UserService proxy = new UserServiceProxy(userServiceImpl);
        proxy.select();
        proxy.update();
    }
}

输出:

log start time [Thu Dec 21 18:13:25 CST 2020] 
查询 selectById
log end time [Thu Dec 21 18:13:25 CST 2020] 
log start time [Thu Dec 21 18:13:25 CST 2020] 
更新 update
log end time [Thu Dec 21 18:13:25 CST 2020] 

可以看出，当业务场景复杂时静态代理有明显的缺点，涉及目标对象与代理类同时修改，不易维护
接下来，我们来看下JDK动态代理
主要涉及两个类：java.lang.reflect.Proxy 和 java.lang.reflect.InvocationHandler
新增逻辑处理器 LogHandler 类

public class LogHandler implements InvocationHandler {
    Object target;  // 被代理的对象，实际的方法执行者

    public LogHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        before();
        Object result = method.invoke(target, args);  // 调用 target 的 method 方法、利用反射调用类里面的实际方法
        after();
        return result;  // 返回方法的执行结果
    }
    // 调用invoke方法之前执行
    private void before() {
        System.out.println(String.format("log start time [%s] ", new Date()));
    }
    // 调用invoke方法之后执行
    private void after() {
        System.out.println(String.format("log end time [%s] ", new Date()));
    }
}

测试，通过代理类对象调用代理方法

public class Test {

    public static void main(String[] args) throws Exception {
        // 1. 创建被代理的对象
        UserServiceImpl userServiceImpl = new UserServiceImpl();
        // 2. 获取对应的 ClassLoader
        ClassLoader classLoader = userServiceImpl.getClass().getClassLoader();
        // 3. 获取所有接口的Class，这里的UserServiceImpl只实现了一个接口UserService，
        Class[] interfaces = userServiceImpl.getClass().getInterfaces();
        // 4. 创建一个将传给代理类的调用请求处理器，处理所有的代理对象上的方法调用
        //     这里创建的是一个自定义的日志处理器，须传入实际的执行对象 userServiceImpl
        InvocationHandler logHandler = new LogHandler(userServiceImpl);
        /*
           5.根据上面提供的信息，创建代理对象 在这个过程中，
               a.JDK会通过根据传入的参数信息动态地在内存中创建和.class 文件等同的字节码
               b.然后根据相应的字节码转换成对应的class，
               c.然后调用newInstance()创建代理实例
         */
        UserService proxy = (UserService) Proxy.newProxyInstance(classLoader, interfaces, logHandler);
        // 调用代理的方法
        proxy.select();
        System.out.println();
        proxy.update();

    }
}

输出结果

log start time [Fri Feb 19 17:25:57 CST 2021] 
查询 select
log end time [Fri Feb 19 17:25:57 CST 2021] 

log start time [Fri Feb 19 17:25:57 CST 2021] 
更新 update
log end time [Fri Feb 19 17:25:57 CST 2021]