Spring6 代理模式-动态代理

2023-12-18 16:17:10

?需求:

生产代理对象的工厂类:

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

输出?

总结:

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

?

文章来源:https://blog.csdn.net/qq_64005599/article/details/135063146
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。