关于静态代理和动态代理的实现流程（个人笔记）

一、静态代理

1.声明计算器接口Calculator，包含加减乘除的抽象方法

package com.example.test01;

/**
 * @author Cavan
 * @date 2023-03-17
 * @qq 2069543852
 */
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);

}

2.创建实现类 

package com.example.test01;

/**
 * @author Cavan
 * @date 2023-03-17
 * @qq 2069543852
 */
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;
    }
}

 3.创建静态代理对象

package com.example.test01;

/**
 * @author Cavan
 * @date 2023-03-17
 * @qq 2069543852
 */
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) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);

        // 通过目标对象来实现核心业务逻辑
        int addResult = target.sub(i,j);

        System.out.println("[日志] sub 方法结束了，结果是：" + addResult);

        return addResult;
    }

    @Override
    public int mul(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);

        // 通过目标对象来实现核心业务逻辑
        int addResult = target.mul(i,j);

        System.out.println("[日志] mul 方法结束了，结果是：" + addResult);

        return addResult;
    }

    @Override
    public int div(int i, int j) {
        // 附加功能由代理类中的代理方法来实现
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);

        // 通过目标对象来实现核心业务逻辑
        int addResult = target.div(i,j);

        System.out.println("[日志] div 方法结束了，结果是：" + addResult);

        return addResult;
    }
}

4.测试代理对象

package com.example.test01;

import org.junit.jupiter.api.Test;

/**
 * @author Cavan
 * @date 2023-03-17
 * @qq 2069543852
 */
public class TestCalculatorStaticProxy {

    @Test
    public void test() {

        Calculator calculator = new CalculatorStaticProxy(new CalculatorImpl());

        calculator.add(1, 2);
        

    }

}

 5.总结

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

二、动态代理

1.创建代理类

package com.example.test01;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

/**
 * @author Cavan
 * @date 2023-03-18
 * @qq 2069543852
 */
public class ProxyFactory {
    //1.传递目标对象
    private Object target;
    public ProxyFactory(Object target) {
        this.target = target;
    }
    //2.创建一个方法，用来返回代理对象
    public Object getProxy(){
        /*
        * newProxyInstance()：有三个参数
        * 1. ClassLoader loader：类加载器是负责加载类的对象，用来加载动态生成代理类的类加载器
        * 2. 类<?>[] interfaces：目标对象实现的所有接口的数组
        * 3. InvocationHandler h：设置代理对象实现目标对象方法的过程
        * */
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //方法调用之前
                System.out.println("[动态代理][日志] "+method.getName()+"，参数："+ Arrays.toString(args));
                //调用目标方法
                Object result = method.invoke(target, args);
                //方法调用之后
                System.out.println("[动态代理][日志] "+method.getName()+"，结果："+ result);
                return result;
            }
        });
    }
}

2.测试

package com.example.test01;

/**
 * @author Cavan
 * @date 2023-03-18
 * @qq 2069543852
 */
public class TestCalculator {

    public static void main(String[] args) {
        //创建代理对象，传入目标的对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        Calculator proxy = (Calculator)proxyFactory.getProxy();
        proxy.add(1,2);
    }

}

3.结果