代理模式及实现探究

最新推荐文章于 2022-03-28 16:13:13 发布

kplxq

最新推荐文章于 2022-03-28 16:13:13 发布

阅读量155

点赞数

分类专栏：互联网技术

互联网技术专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

使用过Spring并经常Debug或者熟悉Spring实现原理的开发应该知道动态代理是Spring框架实现的一大重要技术工具。

先看下图：

这里写图片描述

使用Spring依赖注入的bean通常都能看到CGLIB的标识。而我们自定义的类对象查看到对象信息基本和类定义无差。

究其原由是因为Spring依赖注入的bean并非原始的类对象，而是使用CGLIB的代理对象。

借由此本文旨在对代理模式及实现方式一探究竟。

代理模式介绍

概述

因为某个对象消耗太多资源,而且你的代码并不是每个逻辑路径都需要此对象, 你曾有过延迟创建对象的想法吗?

你有想过限制访问某个对象,也就是说,提供一组方法给普通用户,特别方法给管理员用户?

以上两种需求都非常类似，并且都需要解决一个更大的问题:
如何提供一致的接口给某个对象让它可以改变其内部功能,或者是从来不存在的功能?

可以通过引入一个新的对象，来实现对真实对象的操作或者将新的对象作为真实对象的一个替身。即代理对象。它可以在客户端和目标对象之间起到中介的作用，并且可以通过代理对象去掉客户不能看到的内容和服务或者添加客户需要的额外服务。

用书面术语来描述：

代理模式是常用的java设计模式。
它的特征是代理类与委托类有同样的接口。
代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类，以及事后处理消息等。
代理类与委托类之间通常会存在关联关系，一个代理类的对象与一个委托类的对象关联，代理类的对象本身并不真正实现服务，而是通过调用委托类的对象的相关方法，来提供特定的服务。

UML图示

这里写图片描述

跟着Demo深入探究

接下来我们自己动手用demo来实践一下代理模式的实现，并比较不同实现方式的区别。

公共接口及类定义：

public interface TestService {

    /** 打印入参字符串 */
    void saySomething(String str);

    /** 返回自增+1 */
    int countInt(int num);
}

public class TestServiceImpl implements TestService {
    @Override
    public void saySomething(String str) {
        System.out.println(str);
    }

    public int countInt(int num) {
        return (num++);
    }
}

静态代理实现demo

我们先看静态代理如何完成上述接口实现的代理：


public class ProxySubject implements TestService {

    // 代理类持有一个委托类的对象引用
    private TestService testService;

    public ProxySubject(TestService testService) {
        this.testService = testService;
    }

    /**
     * 将请求分派给委托类执行，记录任务执行前后的时间，时间差即为任务的处理时间
     * 
     * @param taskName
     */
    @Override
    public void saySomething(String something) {

        Date startDate = new Date();
        System.out.println("开始调用目标类时时间点：" + startDate);

        // 将请求分派给委托类处理
        testService.saySomething(something);

        Date endDate = new Date();
        System.out.println("结束调用目标类时时间点：" + endDate);
    }

    @Override
    public int countInt(int num) {
        return testService.countInt(num);
    }
}


public class Client {
    public static void main(String[] args) {
        TestService proxy = new ProxySubject(new TestServiceImpl());
        proxy.saySomething("Hello buddy");
    }
}

下面是上述代理执行结果：

开始调用目标类时时间点：Mon Oct 17 11:01:04 CST 2016
Hello buddy
结束调用目标类时时间点：Mon Oct 17 11:01:04 CST 2016

静态代理实现总结：

上述例子，静态代理类做的事情即是

在真实调用目标接口实现时打印接口调用的请求时间
调用目标接口
目标接口调用结束后打印请求完成时间

我们发现：

使用了静态代理。我们不需要入侵真实的目标类即可在目标对象调用时封装一套额外的逻辑。当然这是代理模式的有点，不局限于静态代理
为了实现接口的代理，我们必须要定义一个代理类实现同一个接口，在实现中显示的调用目标接口来完成代理的实现
- 基于这点，这也反应了静态代理实现的一大缺点：
  - 一个代理对象服务于同一类的对象。业务类的所有方法都需要进行代理；业务类每新增一个接口，所有的代理类也要实现这个接口，增加代码维护的复杂度

JDK动态代理Demo

上述静态代理的缺陷，而动态代理的特性正好可以解决。

而动态代理也有很多种实现技术手段。这一节讲讲java提供的原生动态代理：


/**
 * JDK动态代理类
 */
public class ProxyHandler {
    public static Object getPoxyObject(final Object c) {
        return Proxy.newProxyInstance(c.getClass().getClassLoader(), c.getClass().getInterfaces(), // JDK实现动态代理，但JDK实现必须需要接口
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object reObj = null;
                        reObj = method.invoke(c, args);
                        if (method.getName().equals("saySomething")) {
                            System.out.println("at [" + Calendar.getInstance().get(Calendar.HOUR) + ":"
                                    + Calendar.getInstance().get(Calendar.MINUTE) + ":"
                                    + Calendar.getInstance().get(Calendar.SECOND) + "]\n");
                        }
                        return reObj;
                    }
                });
    }
}

/**
 * 测试客户端
 */

public class JDKServiceMain {
    public static void main(String[] args) {

        TestService service = new TestServiceImpl();
        TestService poxyService = (TestService) ProxyHandler.getPoxyObject(service);

        System.out.println("\n\nexcute info:\n");
        poxyService.saySomething("Manager Zhou: Hello, GentleSong.");
        poxyService.saySomething("Manager Zhou: you are KXF's dream guy.");
        poxyService.saySomething("Manager Zhou: Are you willing to sacrifice for the happniess of KXF's buddy?");
        poxyService.saySomething("GentleSong: Yes, I am.");

    }
}

下面是上述代理执行结果：

excute info:

Manager Zhou: Hello, GentleSong.
at [11:35:10]

Manager Zhou: you are KXF's dream guy.
at [11:35:10]

Manager Zhou: Are you willing to sacrifice for the happniess of KXF's buddy?
at [11:35:10]

GentleSong: Yes, I am.
at [11:35:10]

JDK动态代理实现总结：

上述例子，动态代理类做的事情即是

调用目标接口
调用结束时打印请求调用完成时间

我们发现：

从JDK的实现方式看，它可以实现一类接口的的代理。
- 我们不需要每新增一个接口即新增一个代理类实现
- 我们不需要接口定义新增或删减时同时要修改代理类
但是，JDK的动态代理依靠接口实现，如果有些类并没有实现接口，则不能使用JDK代理。

`CGLIB`动态代理Demo

JDK的动态代理是基于接口实现的。那没有接口定义的类实现如何代理嘞？ CGLIB能够解决这个问题。


/**
 * CGLIB动态代理类
 */
public class ProxyHandler {
    public static Object getPoxyObject(Object c) {

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(c.getClass());

        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy proxy) throws Throwable {

                proxy.invokeSuper(arg0, arg2);

                if (arg1.getName().equals("saySomething")) {
                    System.out.println("at [" + Calendar.getInstance().get(Calendar.HOUR) + ":"
                            + Calendar.getInstance().get(Calendar.MINUTE) + ":"
                            + Calendar.getInstance().get(Calendar.SECOND) + "]\n");
                }

                return null;
            }
        });

        return enhancer.create();
    }
}


public class ProxyHandler {
    public static Object getPoxyObject(Object c) {

        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(c.getClass());

        enhancer.setCallback(new MethodInterceptor() {
            public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy proxy) throws Throwable {

                proxy.invokeSuper(arg0, arg2);

                if (arg1.getName().equals("saySomething")) {
                    System.out.println("at [" + Calendar.getInstance().get(Calendar.HOUR) + ":"
                            + Calendar.getInstance().get(Calendar.MINUTE) + ":"
                            + Calendar.getInstance().get(Calendar.SECOND) + "]\n");
                }

                return null;
            }
        });

        return enhancer.create();
    }
}