【23设计模式】代理模式及其应用

通过操作代理对象来调用目标类,这样就可以实现调用者和目标对象的解耦合

应用场景:AOP 的实现、RPC 远程调用、Java 注解对象获取、日志框架、全局性异常处理、事务处理等。

代理的类型

静态代理

public interface Subject {
    void request();
}

// 真实类
public class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("访问真实主题方法...");
    }
}

// 代理类
public class SubProxy implements Subject {

    /**
     * 真实对象 (将真实对象委托给代理对象)
     */
    private RealSubject realSubject;

    @Override
    public void request() {
        if(realSubject == null){
            realSubject = new RealSubject();
        }
        preRequest();
        realSubject.request();
        postRequest();
    }

    // 方法增强
    public void preRequest() {
        System.out.println("访问真实主题之前的预处理。");
    }
    public void postRequest() {
        System.out.println("访问真实主题之后的后续处理。");
    }
}
public static void main(String[] args) {
    SubProxy proxy = new SubProxy();
    proxy.request();
}

动态代理(JDK)

public interface AbstractSubject {
    void request();
}

public class RealSubA implements AbstractSubject {
    @Override
    public void request() {
        System.out.println("A对象被代理");
    }
}

public class RealSubB implements AbstractSubject {
    @Override
    public void request() {
        System.out.println("B对象被代理");
    }
}

// 代理类
public class DynamicProxy implements InvocationHandler {

    private Object obj;

    public DynamicProxy(Object obj){
        this.obj = obj;
    }

    @Override
    public Object invoke(Object o, Method m, Object[] args) throws InvocationTargetException, IllegalAccessException {
        m.invoke(obj, args);
        return null;
    }
}

实现InvocationHandler接口,即可被定义为代理类,核心方法invoke()有三个参数

  • Object proxy: 动态代理对象
  • Method method: 表示最终要执行的方法,真正的目标方法
  • Object[] args:向目标方法传递的参数
public static void main(String[] args) {

    InvocationHandler handler = new DynamicProxy(new RealSubA());

    //        ClassLoader classLoader = AbstractSubject.class.getClassLoader();
    //        System.out.println(classLoader);
    //
    //        Class<?>[] interfaces = AbstractSubject.class.getInterfaces();
    //        System.out.println(Arrays.toString(interfaces));

    AbstractSubject subject = (AbstractSubject) Proxy.newProxyInstance(
        AbstractSubject.class.getClassLoader(),
        new Class[]{AbstractSubject.class},
        handler);
    
    subject.request();
}

要用 JDK 动态代理的话,就需要知道目标对象的类加载器目标对象的接口目标对象是谁

Proxy.newProxyInstance()方法就是将目标对象绑定到代理类上去

简单解析

动态代理的优势在于能够很方便的对代理类中方法进行集中处理,而不用修改每个被代理的方法。因为所有被代理的方法(真正执行的方法)都是通过在 InvocationHandler 中的 invoke 方法调用的。所以我们只需要对 invoke 方法进行集中处理。

基础补充:反射

在运行状态中,对于任意一个,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法和属性;

Class类对象的实例化
Class.forname("com.xxx.xxx.xx") // 完整的包路径名
对象.getClass();
类.class
Class<?> aClass = Class.forName("com.algebra.common.login.LoginPerson");
Class<LoginPerson> loginPersonClass = LoginPerson.class;
LoginPerson p = new LoginPerson();
Class<? extends LoginPerson> pClass = p.getClass();
Class类
Construct类
Annotation类
Method类
Field类

代理实现方式

JDK

JDK代理是不需要依赖第三方的库,只要JDK环境就可以进行代理,需要满足以下要求:

  • 实现InvocationHandler接口,重写invoke()

  • 使用Proxy.newProxyInstance()产生代理对象

  • 被代理的对象必须要实现接口

实现方式见上述《动态代理(JDK)》

CJLIB

CGLib 必须依赖于CGLib的类库,需要满足以下要求:

  • 实现MethodInterceptor接口,重写intercept()

  • 使用Enhancer对象.create()产生代理对象

import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

public class CjDynamicProxy implements MethodInterceptor {

    private Object obj;

    public CjDynamicProxy(Object obj){
        this.obj = obj;
    }

    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        return method.invoke(obj, args);
    }
}
import org.springframework.cglib.proxy.Enhancer;

public static void main(String[] args) {
    
    // 代理类class文件存入本地磁盘方便我们反编译查看源码
    System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./code");
    
    CjDynamicProxy proxy = new CjDynamicProxy(new RealSubA());
    Enhancer enhancer = new Enhancer();
    enhancer.setCallback(proxy);
    enhancer.setSuperclass(AbstractSubject.class);
    AbstractSubject realA = (AbstractSubject) enhancer.create();
    realA.request();
}

区分

  • 如果目标对象实现了接口,默认情况下会采用JDK的动态代理实现AOP,可以强制使用CGLIB实现AOP
  • 如果目标对象没有实现了接口,必须采用CGLIB库,spring会自动在JDK动态代理和CGLIB之间转换

Mybatis中的动态代理

public class MapperProxy<T> implements InvocationHandler, Serializable {
	// ...
public class MapperProxyFactory<T> {
	// ...
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AlgebraFly

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值