静态代理和动态代理的理解-蒲公英云

生活中的代理：

广告商找大明星拍广告需要经过经纪人。

租房时候去找二手房东租房，二手房东就是原房东的一个代理。

什么是代理模式：

一个对象为其他对象提供代理，并去操作其他对象。不再是直接对目标方法进行调用，而是通过代理类间接调用。将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。

那为什么要使用代理模式呢？

为了实现代码中的解耦，可以将重复使用的代码封装起来。比如日志功能，如果每个方法都需要写上日志，那将会产生达大量的代码。如果使用了代码模式，进行一个统一的管理，既能将代码优雅度提升，也不会对主逻辑业务产生干扰。

实现静态代理

package com.cj.spring6.example;
/**
 * 这是一台计算器的功能接口
 */
public interface Calculator {
    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
}
package com.cj.spring6.example;
/**
 * 在这里将计算器的功能继承并且实现他
 */
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        return result;
    }
}

静态代理类：

package com.cj.spring6.example;
/**
 * 对于那台计算器的静态代理
 */
public class CalculatorStaticProxy implements Calculator {
    // 将被代理的目标对象声明为成员变量
    private Calculator target;
    public CalculatorStaticProxy(Calculator target) {
        this.target = target;
    }
    @Override
    public int add(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        // 通过目标对象来实现核心业务逻辑
        int addResult = target.add(i, j);
        System.out.println("[日志] add 方法结束了，结果是：" + addResult);
        return addResult;
    }
    @Override
    public int sub(int i, int j) {
        return 0;
    }
    @Override
    public int mul(int i, int j) {
        return 0;
    }
    @Override
    public int div(int i, int j) {
        return 0;
    }
}

总结：静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代码，日志功能还是分散的，没有统一管理。

那么有没有一种办法可以将日志功能集中到一个代理类中呢。对于任何的日志需求，都通过这一个代理类来实现呢。这就要想到我们的动态代理啦。

动态代理

在程序执行过程中，使用jdk的反射机制，创建代理类对象，并动态的指定要代理目标类（静态代理中，代理目标是固定，写死的）。而不用你创建类文件，不用写Java文件。

动态代理其实就是jdk运行期间，动态创建class字节码并加载到JVM。

使用Java反射包中的类和接口实现动态代理的功能。

package com.cj.spring6.example;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ProxyFactory {
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    /**
     * 返回代理对象
     *
     * @return
     */
    public Object getProxy() {
        /**
         * newProxyInstance()：创建一个代理实例
         * 其中有三个参数：
         * 1、classLoader：加载动态生成的代理类的类加载器
         * 2、interfaces：目标对象实现的所有接口的class对象所组成的数组
         * 3、invocationHandler：设置代理对象实现目标对象方法的过程，即代理类中如何重写接口中的抽象方法
         */
        // 加载动态生成的代理类的类加载器
        ClassLoader classLoader = target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler invocationHandler = new InvocationHandler() {
            /**
             *
             * @param proxy 调用该方法的代理实例(代理对象)
             * @param method 在代理实例上调用的接口方法(需要重写目标对象的方法)
             *               反射，Method类，表示方法。类中的方法，通过Method可以执行某个方法。
             * @param args method 方法里面的参数
             *
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    System.out.println("[动态代理][日志] " + method.getName() + "，参数：" + Arrays.toString(args));
                    result = method.invoke(target, args);
                    System.out.println("[动态代理][日志] " + method.getName() + "，结果：" + result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("[动态代理][日志] " + method.getName() + "，异常：" + e.getMessage());
                } finally {
                    System.out.println("[动态代理][日志] " + method.getName() + "，方法执行完毕");
                }
                return result;
            }
        };
        /**
         Proxy类：核心的对象，创建代理对象，之前创建对象都是new 类的构造方法（）现在我们使用Proxy类的方法，代理new的使用。
         方法： 静态方法：newProxyInstance（）
         作用：创建代理对象，User user = new User();
         */
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

最后测试

package com.cj.spring6.example;
import org.junit.jupiter.api.Test;
public class testDynamicProxy {
    @Test
    public void testDynamicProxy() {
        // 创建代理对象
        ProxyFactory factory = new ProxyFactory(new CalculatorLogImpl());
        Calculator proxy = (Calculator) factory.getProxy();
        proxy.div(1, 1);
    }
}