设计模式-代理模式

大家好我是佩奇

发布于 2022-8-5 17:41

浏览

0收藏

为另一个对象提供代表，以便控制客户对对象的访问。其定义为：为另一个对象提供替身或占位符以访问这个对象。具体地吗可以浏览 https://github.com/UniqueDong/zero-design-patterns

什么是代理
官话上讲是一种设计模式，目的是希望代码重用。跟我们以往访问对象的方式不同，代理模式不是直接通过目标对象，而是通过代理访问我们的目标对象以及方法。因为有的时候我们无法直接与目标对象建立联系或者，我们要控制客户端访问。所以便通过代理来访问我们的真实对象。

就好比「客户」-> 「明星经纪人」-> 「明星」。我们不是直接与明星联系，明星很忙的，要唱歌跳舞烫头拍电影，给的价格足够好，经纪人才告知明星接下这个任务。

主要角色 设计模式-代理模式-鸿蒙开发者社区

代理模式

● Subject：被代理类与代理类都要实现的主题接口。
● ConcreteSubject：被代理类，也叫委托类，也就是真实对象，真正干活的。
● Proxy：代理类，扮演者中介的角色，控制客户端对真实对象的访问、生成代理对象让客户端透明调用，通过代理我们可以屏蔽或者加工针对真实对象。

使用场景
● 通常更多出现在我们常用的开源框架里面，比如 Mybatis 中我们通过Mapper 接口就能调用到真正执行 SQL 的逻辑，其本质就是利用了动态代理，定位到真实的Statement执行。
● Spring AOP 也是利用了动态代理，比如 Spring 事务，当调用的方法是被 Spring 事务管理的时候，其实他会生成一个代理类，封装我们的事务处理逻辑从而实现了事务增强，代码复用。解放我们开启事务、执行逻辑、提交事务或者回滚事务的模板代码，我们只要安心的编写路基代码即可。在这里一共用到了「模版方法模式」、动态代理模式。关于「模版方法」模式可以参考历史文章。
● 还有 Dubbo RPC 框架，也是有使用动态代理。对于消费者我们只是通过接口就能调用提供者所实现的功能，就像本地调用一样。它为我们封装了网络传输、序列化、解码编码的繁琐细节。就是生成了一个代理类为屏蔽了底层细节。使得我们可以透明调用。
我们根据加载被代理类的时机不同，将代理分为静态代理和动态代理。如果我们在代码编译时就确定了被代理的类是哪一个，那么就可以直接使用静态代理；如果不能确定，那么可以使用类的动态加载机制，在代码运行期间加载被代理的类这就是动态代理，比如RPC框架和Spring AOP机制。

静态代理代码示例
我们按照 UML 类图来实现一个简单的静态代理模式，首先先创建一个 Subject 接口。

我们按照 UML 类图来实现一个简单的静态代理模式，首先先创建一个 Subject 接口。

publicinterface Subject {

    public void request();
}

创建一个真实对象去实现该接口

publicclass RealSubjbect implements Subject {

    @Override
    public void request() {
        System.out.println("this is RealSubjbect.request()");
    }
}

创建我们的代理类，持有真实对象的引用，同时实现了 Subject 接口。

publicclass ProxySubject implements Subject {

    private Subject realSubjbect = null;

    /**
     * 除了代理真实角色做该做的事，代理角色提供附加操作
     * 如
     */
    @Override
    public void request() {
        preRequest(); //真实角色操作前的附加操作

        if (realSubjbect == null) {
            realSubjbect = new RealSubjbect();
        }
        realSubjbect.request();

        postRequest();//真实角色操作后的附加操作
    }
    /**
     *	真实角色操作前的附加操作
     */
    private void postRequest() {
        System.out.println("真实角色操作后的附加操作");

    }

    /**
     *	真实角色操作后的附加操作
     */
    private void preRequest() {
        System.out.println("真实角色操作前的附加操作");

    }
}

编写我们的客户端接口，通过代理类调用。

publicclass Client {

    public static void main(String[] args) {
        Subject subject = new ProxySubject();
        subject.request(); //代理者代替真实者做事情
    }
}

打印的结果如下所示，我们实现了对真实对象的控制，并且新增一些操作。就像Spring的AOP实现的功能一样。

真实角色操作前的附加操作
this is RealSubjbect.request()
真实角色操作后的附加操作

缺点

代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。
如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。
另外，如果要按照上述的方法使用代理模式，那么真实角色(委托类)必须是事先已经存在的，并将其作为代理对象的内部属性。但是实际使用时，一个真实角色必须对应一个代理角色，如果大量使用会导致类的急剧膨胀；此外，如果事先并不知道真实角色（委托类），该如何使用代理呢？这个问题可以通过Java的动态代理类来解决。

动态代理
概念

动态代理类的源码是在程序运行期间 JVM 根据反射机制动态生成的，所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。

实现方式
主要有两种实现方式：

使用 JDK 实现。委托类逆序有接口。
使用 CGLIB 实现。不能是final修饰的类，只能修饰 public 方法。

JDK 动态代理
UML 类图如下所示

JDK动态代理
● 创建一个自己Handler 实现 InvocationHandler，同时持有真实对象的引用，会依赖我们的业务类。
● 代理对象通过 Proxy.newProxyInstance()生成,而该方法以来于 Handler对象和真实对象。
通过类图其实我们也可以知道，当通过动态代理生成的代理字节码调用的时候就会委托到 Handler 的 invoke 方法。同时 Handler 又持有真正的业务对象。所以能在执行调用真实的对象之前控制其行为以及访问。主要优点：

● 隐藏委托类的实现，调用者只需要和代理类进行交互。
● 解耦合，在不改变委托类代码情况下做额外处理。比如添加 Dubbo 客户端调用时的序列化、网络传输细节。

代码实现
通过类图，创建 JDK 动态代理我们可以分为三步。

定义被代理的业务接口以及实现类。
新建自定义的 InvocationHandler 实现 InvocationHandler接口，并依赖被代理类（真实对象的引用）。
通过 Proxy.newProxyInstance() 方法创建具体代理对象。
现在我们有一个需求，为我们的业务逻辑统一记录调用日志，或者事务控制，在这里我们那就编写一个日志记录为我们的被代理类记录日志。模拟类似 Spring AOP功能，一个简化版的例子让大家明白其使用场景以及原理。

第一步：我们定义自己的业务接口 OrderService 跟 ProductService

publicinterface OrderService {
    String createOder(String no);
}

publicinterface ProductService {
    String getProduct(String no);
}

业务逻辑的实现类

publicclass OrderServiceImpl implements OrderService {
    @Override
    public String createOder(String no) {
        return"生成订单" + no + "成功";
    }
}

publicclass ProductServiceImpl implements ProductService {
    @Override
    public String getProduct(String no) {
        return"获取商品" + no + "成功";
    }
}

第二步：定义我们的 Handler 实现 JDK 的 Invocationhandler,将持有的委托引用定义 Object 类型，这样可以代理所有需要日志记录的委托类，同时我们有一个 bind()方法，用于设置 target 同时返回对应的代理类让客户端调用。第三步的 Proxy.newProxyInstance() 我们放在 bind 方法里。代码更加简洁。

publicclass LoggerInterceptor implements InvocationHandler {

    /**
     * 持有委托类的引用
     */
    private Object target;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long start = System.currentTimeMillis();
        System.out.println(proxy.getClass().getInterfaces()[0]);
        //通过反射调用
        System.out.println("Entered " + target.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
        //调用目标对象的方法
        Object result = method.invoke(target, args);
        long end = System.currentTimeMillis();
        System.out.println("执行结果：" + result.toString());
        System.out.println("共耗时：" + (end - start));
        return result;
    }

    /**
     * 获取代理类：并将 target 委托类绑定到 我们定义的Targe中
     * @param target 真实的委托类
     * @return
     */
    public synchronized Object bind(Object target) {
        this.target = target;
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

最后我们新建启动类看效果,分别有两个业务逻辑类需要日志记录。具体可看代码注释

publicclass BootStrap {
    public static void main(String[] args) {
      // 新建业务逻辑
        OrderService orderService = new OrderServiceImpl();
        ProductService productService = new ProductServiceImpl();
			// 新建我们的 日志 Handler
        LoggerInterceptor loggerInterceptor = new LoggerInterceptor();

      //绑定 委托类同时生产代理类调用 。
        OrderService orderServiceProxy = (OrderService) loggerInterceptor.bind(orderService);
        orderServiceProxy.createOder("12927381");

        ProductService productServiceProxy = (ProductService) loggerInterceptor.bind(productService);
        productServiceProxy.getProduct("34010234");
    }
}

结果打印如下所示：我们可以看到，每个我们所代理的接口执行方法前后都打印了日志以及返回结果。其实 Spring AOP 就是通过动态代理实现。

nterface com.zero.headfirst.proxy.service.OrderService
Entered com.zero.headfirst.proxy.service.OrderServiceImpl-createOder,with arguments{12927381}
执行结果：生成订单12927381成功
共耗时：2
interface com.zero.headfirst.proxy.service.ProductService
Entered com.zero.headfirst.proxy.service.ProductServiceImpl-getProduct,with arguments{34010234}
执行结果：获取商品34010234成功
共耗时：1

CGLIB 动态代理
CGLIB是一个强大的高性能的代码生成包。它广泛的被许多AOP的框架使用，例如Spring AOP为他们提供方法的interception（拦截）。CGLIB包的底层是通过使用一个小而快的字节码处理框架ASM，来转换字节码并生成新的类。

不能是 final 修饰的类，以及final方法，可以不定义接口。

使用方式很简单：我们要先添加cglib 依赖，新建一个类实现 MethodInterceptor 。

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

publicclass LoggerProxy implements MethodInterceptor {


    /**
     * 创建代理类
     * @param targetClass 委托类
     * @return
     */
    public Object bind(Class targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        //设置回调方，当客户端通过代理调用方法的时候会会调用我们重写的 intercept() 方法
        enhancer.setCallback(this);
        //创建代理类
        return enhancer.create();
    }


    @Override
    public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        long start = System.currentTimeMillis();
        //通过反射调用
        System.out.println("Entered " + o.getClass().getName() + "-" + method.getName() + ",with arguments{" + args[0] + "}");
        Object result = methodProxy.invokeSuper(o, args);
        long end = System.currentTimeMillis();
        System.out.println("执行结果：" + result.toString());
        System.out.println("共耗时：" + (end - start));
        return result;
    }
}

是不是很简单？新建 Enhancer ，只要设置好委托类以及回调类。在这里我们可以利用工厂模式创建不同的代理类对应的回调。这里简单实例就不写了。

接下来看我们的测试类以及结果

publicclass CglibBootStrap {
    public static void main(String[] args) {

        LoggerProxy loggerProxy = new LoggerProxy();

        OrderService orderService = (OrderService) loggerProxy.bind(OrderServiceImpl.class);
        orderService.createOder("12873051209g");


        ProductService productProxy = (ProductService) loggerProxy.bind(ProductServiceImpl.class);
        productProxy.getProduct("2780935782309");


    }
}

打印结果如下所示

Entered com.zero.headfirst.proxy.service.OrderServiceImpl$$EnhancerByCGLIB$$54d983a1-createOder,with arguments{12873051209g}
执行结果：生成订单12873051209g成功
共耗时：14
Entered com.zero.headfirst.proxy.service.ProductServiceImpl$$EnhancerByCGLIB$$4e2c7c36-getProduct,with arguments{2780935782309}
执行结果：获取商品2780935782309成功
共耗时：5

文章转载自公众号：码哥字节

分类

标签

已于2022-8-5 17:41:31修改

51CTO

51CTO博客

51CTO学堂

设计模式-代理模式

目录

订阅鸿蒙技术特刊，精选内容抢先看