Spring6 代理模式-动态代理

?需求：

生产代理对象的工厂类：

package aop.proxy;

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;
    }

    //返回代理对象
    public Object getProxy(){
        /*
        Proxy.newProxyInstance()三个参数
        classLoader类加载器：加载动态生成代理类的类加载器
        interface：目标对象实现的所有接口的class类型数组
        invocationHandler:设置代理对象实现目标对象方法的过程,即代理类中如何重写接口中的抽象方法
         */

        //ClassLoader
        ClassLoader classLoader = target.getClass().getClassLoader();
        //interface：目标对象实现的所有接口的class类型数组
        Class<?>[] interfaces = target.getClass().getInterfaces();
        //InvocationHandler
        InvocationHandler invocationHandler = new InvocationHandler(){

            /**
             * proxy：代理对象
             * method：代理对象需要实现的方法，即其中需要重写的方法
             * args：method所对应方法的参数
             */
            @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;
            }
        };
        return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);
    }
}

Caculator.java 接口

package aop.proxy;

public interface Caculator {
    int add(int i, int j);

    int sub(int i, int j);

    int mul(int i, int j);

    int div(int i, int j);
}

CaculatorImpl.java

package aop.proxy;

public class CaculatorImpl implements Caculator {
    @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) {
        return i-j;
    }

    @Override
    public int mul(int i, int j) {
        return i*j;
    }

    @Override
    public int div(int i, int j) {
        return i/j;
    }
}

.TestCal.java

package aop.proxy;

public class TestCal {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CaculatorImpl());
        Caculator proxy = (Caculator) proxyFactory.getProxy();
        proxy.add(1,2);
    }
}

输出?

总结：

将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理类来实现。这就需要使用动态代理技术了。

?