SSM框架中十分常用的设计模式：动态代理

博文视点Broadview

发布于 2023-05-06 19:12:38

1660

发布于 2023-05-06 19:12:38

文章被收录于专栏：博文视点Broadview博文视点Broadview

👆点击“博文视点Broadview”，获取更多书讯

本文介绍的是SSM框架中十分常用的设计模式，所以开发者掌握它十分必要。

动态代理和责任链无论在Spring还是MyBatis中都有重要的应用，只要随着本书的例子多写代码，反复体验，就能掌握。在分析Spring AOP和MyBatis技术原理时，我们还会不断提及它们，它们适用范围广，值得读者认真研究。

代理模式的意义在于生成一个占位（又称代理对象），来代理真实对象（又称目标对象），从而控制真实对象的访问。

先来谈谈什么是代理模式。

假设这样一个场景，你的公司是一家软件公司，你是一位软件工程师。客户带着需求去找公司显然不会直接和你谈，而是去找商务谈，此时客户会认为商务就代表公司。

让我们用一张图来表示代理模式的含义，如图1所示。

图1 代理模式示意图

显然客户是通过商务去访问软件工程师的，那么商务（代理对象）的意义是什么呢？

商务可以进行谈判，比如项目启动前的商务谈判，软件的价格、交付、进度的时间节点等，或者项目完成后的商务追讨应收账款等。商务也有可能在开发软件之前谈判失败，此时商务就会根据公司规则去结束和客户的合作关系，这些都不用软件工程师来处理。

因此，代理的作用就是，在真实对象访问之前或者之后加入对应的逻辑，或者根据其他规则控制是否使用真实对象，显然在这个例子里商务控制了客户对软件工程师的访问。

经过上面的论述，我们知道商务和软件工程师是代理和被代理的关系，客户是通过商务去访问软件工程师的。此时客户就是程序中的调用者，商务就是代理对象，软件工程师就是真实对象。

我们需要在调用者调用对象之前产生一个代理对象，而这个代理对象需要和真实对象建立代理关系，所以代理必须包括两个步骤。

建立代理对象和真实对象之间的代理关系。
实现代理对象的代理逻辑方法。

在Java中有多种动态代理技术，比如JDK、CGLIB、Javassist、ASM，其中最常用的动态代理技术有两种：

一种是JDK动态代理，这是JDK自带的功能；
另一种是CGLIB，这是第三方提供的技术。

目前，Spring常用JDK和CGLIB，而MyBatis还使用了Javassist，无论哪种代理技术，它们的理念都是相似的。

这里会谈论两种最常用的动态代理技术：JDK和CGLIB。

在JDK动态代理中，必须使用接口，而CGLIB不需要，所以使用CGLIB会更简单一些。下面依次讨论这两种最常用的动态代理。

JDK动态代理

JDK动态代理是java.lang.reflect.*包提供的方式，它必须借助一个接口才能产生代理对象，所以先定义接口，代码如下。

package com.learn.ssm.chapter3.proxy;
public interface HelloWorld {    public void sayHelloWorld();}

然后提供实现类HelloWordImpl来实现接口，代码如下。

package com.learn.ssm.chapter3.proxy.impl;import com.learn.ssm.chapter3.proxy.HelloWorld;public class HelloWorldImpl  implements HelloWorld {    @Override    public void sayHelloWorld() {        System.out.println("Hello World");    }}

这是最简单的Java接口和实现类的关系，此时可以开始编写动态代理的代码了。按照我们之前的分析，先要建立起代理对象和真实服务对象的关系，然后实现代理逻辑，所以一共包括两个步骤。

在JDK动态代理中，要实现代理逻辑类必须实现java.lang.reflect.InvocationHandler接口，它定义了一个invoke方法，并提供接口数组用于下挂代理对象，代码如下。

package com.learn.ssm.chapter3.proxy;/**** imports ****/public class JdkProxyExample implements InvocationHandler {
    // 真实对象    private Object target = null;
    /**     * 建立代理对象和真实对象的代理关系，并返回代理对象     * @param target 真实对象     * @return  代理对象     */    public Object bind(Object target) {        this.target = target;        return Proxy.newProxyInstance(                target.getClass().getClassLoader(), // 类的加载器                target.getClass().getInterfaces(), // 声明接口                this); // 使用当前对象来实现代理逻辑    }
    /**     * 代理方法逻辑     * @param proxy 代理对象     * @param method 当前调度方法     * @param args 当前方法参数     * @return 代理结果返回     * @throws Throwable 异常     */    @Override    public Object invoke(Object proxy, Method method, Object[] args)            throws Throwable {        System.out.println("进入代理逻辑方法");        System.out.println("在调度真实对象之前的服务");        // 相当于调用sayHelloWorld方法        Object obj = method.invoke(target, args);        System.out.println("在调度真实对象之后的服务");        return obj;    }}

正如我们上述所谈到的，这里也分为两步。

第1步，建立代理对象和真实对象的关系。这里是使用bind方法去完成的，方法里面首先用类的属性target保存了真实对象，然后通过如下代码建立并生成代理对象。

Proxy.newProxyInstance(    target.getClass().getClassLoader(), // 类的加载器    target.getClass().getInterfaces(), // 声明接口    this); // 使用当前对象来实现代理逻辑

其中newProxyInstance方法包含3个参数。

第1个是类加载器，我们采用了target本身的类加载器。
第2个是把生成的动态代理对象下挂在哪些接口下，它放在target实现的接口下。HelloWorldImpl对象的接口显然就是HelloWorld，代理对象可以这样声明：HelloWorld proxy = xxxx;。
第3个是定义实现方法逻辑的代理类，this表示当前对象，它必须实现InvocationHandler接口的invoke方法，该方法就是代理逻辑的实现方法。

第2步，实现代理逻辑方法。invoke方法可以实现代理逻辑，invoke方法的3个参数的含义如下所示。

proxy，代理对象，就是bind方法生成的对象。
method，当前调度的方法。
args，调度方法的参数。

当我们使用了代理对象调度方法后，它就会进入invoke方法。

// 相当于调用sayHelloWorld方法Object obj = method.invoke(target, args);

这行代码相当于调度目标对象的方法，只是通过反射实现而已。

类比前面的例子，proxy相当于商务对象，target相当于软件工程师对象，bind方法就是建立商务和软件工程师代理关系的方法。而invoke方法就是商务逻辑，它将控制软件师的访问。

测试JDK动态代理，代码如下。

public static void testJdkProxy() {    JdkProxyExample jdk = new JdkProxyExample();    // 绑定关系，因为挂在接口HelloWorld下，所以声明代理对象HelloWorld proxy    HelloWorld proxy = (HelloWorld)jdk.bind(new HelloWorldImpl());    // 注意，此时HelloWorld对象已经是一个代理对象，它会进入代理的逻辑方法invoke    proxy.sayHelloWorld();}

首先通过bind方法绑定代理关系，然后在代理对象调度sayHelloWorld方法时进入代理的逻辑，测试结果如下：

进入代理逻辑方法

在调度真实对象之前的服务

Hello World

在调度真实对象之后的服务

此时，在调度打印Hello World之前和之后都可以加入相关的逻辑，甚至可以不调度Hello World的打印。

这就是JDK动态代理，它是一种最常用的动态代理，十分重要，后面会以JDK动态代理为主讨论框架的实现。代理模式要掌握不容易，读者可以通过打断点，一步步验证执行的步骤，就一定能够掌握好它。

CGLIB动态代理

JDK动态代理必须提供接口才能使用，在一些不能提供接口的环境中，只能采用第三方技术，比如CGLIB动态代理。它的优势在于不需要提供接口，只要一个非抽象类就能实现动态代理。为了使用CGLIB，我们通过Maven来引入它，如下：

<dependency>    <groupId>cglib</groupId>    <artifactId>cglib</artifactId>    <version>3.3.0</version></dependency>

选取代之前编写过的ReflectServiceImpl类作为例子，它不存在任何接口，所以没办法使用JDK动态代理，这里采用CBLIB动态代理技术，代码如下。

package com.learn.ssm.chapter3.proxy;/**** imports ****/public class CglibProxyExample implements MethodInterceptor {    /**     * 生成CGLIB代理对象     * @param cls —— Class类     * @return Class类的CGLIB代理对象     */    public Object getProxy(Class cls) {        // CGLIB enhancer增强类对象        Enhancer enhancer = new Enhancer();        // 设置增强类型        enhancer.setSuperclass(cls);        // 定义代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor方法        enhancer.setCallback(this);        // 生成并返回代理对象        return enhancer.create();    }
    /**     * 代理逻辑方法     * @param proxy 代理对象     * @param method 方法     * @param args 方法参数     * @param methodProxy 方法代理     * @return 代理逻辑返回     * @throws Throwable 异常     */    @Override    public Object intercept(Object proxy, Method method,                Object[] args, MethodProxy methodProxy)            throws Throwable {        System.err.println("调用真实对象前");        // CGLIB反射调用真实对象方法        Object result = methodProxy.invokeSuper(proxy, args);        System.err.println("调用真实对象后");        return result;    }}

这里用了CGLIB的加强者Enhancer，通过设置超类的方法（setSuperclass），然后通过setCallback方法设置哪个类为它的代理类。其中，参数为this就意味着是当前对象，要求用这个对象实现接口MethodInterceptor的方法——intercept，然后返回代理对象。

那么此时当前类的intercept方法就是其代理逻辑方法，其参数内容见代码注解，我们在反射真实对象方法前后进行了打印，CGLIB是通过如下代码完成的。

Object result = methodProxy.invokeSuper(proxy, args);

测试一下CGLIB动态代理，代码如下。

public static void tesCGLIBProxy() {    CglibProxyExample cpe = new CglibProxyExample();    ReflectServiceImpl obj        = (ReflectServiceImpl)cpe.getProxy (ReflectServiceImpl.class);    obj.sayHello("张三");}

运行这段代码，就可以打印出这样的结果：

调用真实对象前

Hello 张三

调用真实对象后

掌握了JDK动态代理就很容易掌握CGLIB动态代理，因为二者是相似的。它们都是用getProxy方法生成代理对象，制定代理的逻辑类。而代理逻辑类要实现一个接口的一个方法，那么这个接口定义的方法就是代理对象的逻辑方法，它可以控制真实对象的方法。

拦截器

由于动态代理一般都比较难理解和应用，程序设计者会设计一个拦截器接口供开发者使用，开发者只要知道拦截器接口的方法、含义和作用即可，无须知道动态代理的实现过程。

下面将使用JDK动态代理来展示一个拦截器的本质，为此先定义拦截器接口Interceptor，代码如下。

package com.learn.ssm.chapter3.proxy.intercept;
import java.lang.reflect.Method;
public interface Interceptor {    public boolean before(            Object proxy, Object target, Method method, Object[] args);
    public void around(            Object proxy, Object target, Method method, Object[] args);

    public void after(            Object proxy, Object target, Method method, Object[] args);}

这里定义了3个方法，before、around、after方法，分别给予这些方法如下逻辑定义。

3个方法的参数为：proxy代理对象、target真实对象、method方法、args运行方法参数。
before方法返回boolean值，它在真实方法前调用。当返回为true时，则反射真实对象的方法；当返回为false时，则调用around方法。
在before方法返回为false的情况下，调用around方法。
在反射真实对象方法或者around方法执行之后，调用after方法。

实现这个Interceptor的实现类——MyInterceptor，代码如下。

package com.learn.ssm.chapter3.proxy.intercept.impl;
import com.learn.ssm.chapter3.proxy.intercept.Interceptor;import java.lang.reflect.Method;
public class MyInterceptor implements Interceptor {    @Override    public boolean before(            Object proxy, Object target, Method method, Object[] args) {        System.err.println("反射方法前逻辑");        return false;//不反射被代理对象原有方法    }    @Override    public void after(            Object proxy, Object target, Method method, Object[] args) {        System.err.println("反射方法后逻辑");    }    @Override    public void around(            Object proxy, Object target, Method method, Object[] args) {        System.err.println("取代了被代理对象的方法");    }}

它实现了所有的Interceptor 接口方法。如果使用JDK动态代理，就可以将这些方法织入对应的逻辑了。以接口HelloWorld 和其实现类HelloWorldImpl为例，在JDK动态代理中使用拦截器，代码如下。

package com.learn.ssm.chapter3.proxy.intercept;

/**** imports ****/public class InterceptorJdkProxy implements InvocationHandler {

    private Object target; //真实对象    private String interceptorClass = null;//拦截器全限定名

    public InterceptorJdkProxy(Object target, String interceptorClass) {        this.target = target;        this.interceptorClass = interceptorClass;    }

    /**     * 绑定委托对象并返回一个【代理占位】     *     * @param target 真实对象     * @param interceptorClass 拦截器全限定名     * @return 代理对象【占位】     */    public static Object bind(Object target, String interceptorClass) {        //取得代理对象        return Proxy.newProxyInstance(target.getClass().getClassLoader(),                target.getClass().getInterfaces(),                new InterceptorJdkProxy(target, interceptorClass));    }

    @Override    /**     * 通过代理对象调用方法，首先进入这个方法     *     * @param proxy  代理对象     * @param method  方法，被调用方法     * @param args  方法的参数     */    public Object invoke(Object proxy, Method method, Object[] args)            throws Throwable {        if (interceptorClass == null) {            //没有设置拦截器则直接反射原有方法            return method.invoke(target, args);        }        Object result = null;        //通过反射生成拦截器        Interceptor interceptor = (Interceptor)            Class.forName(interceptorClass).getConstructor().newInstance();        //调用前置方法        if (interceptor.before(proxy, target, method, args)) {            //反射原有对象方法            result = method.invoke(target, args);        } else {//返回false执行around方法            interceptor.around(proxy, target, method, args);        }        //调用后置方法        interceptor.after(proxy, target, method, args);        return result;    }}

这里有两个属性，一个是target，它是真实对象；另一个是字符串interceptorClass，它是一个拦截器的全限定名。解释一下这段代码的执行步骤。

第1步，在bind方法中用JDK动态代理绑定了一个对象，然后返回代理对象。

第2步，如果没有设置拦截器，则直接反射真实对象的方法，然后结束，否则进行第3步。

第3步，通过反射生成拦截器，并准备使用它。

第4步，调用拦截器的before方法，如果返回为true，则反射原来的方法；否则运行拦截器的around方法。

第5步，调用拦截器的after方法。

第6步，返回结果。

拦截器的工作流程，如图2所示。

图2 拦截器的工作流程

开发者只要知道拦截器的方法和作用就可以编写拦截器了，编写完成后可以设置拦截器，这样就完成了自己的任务，所以对于开发者来说是简单的。
设计者是精通Java的开发和设计的人员，由他们来完成动态代理的逻辑。
设计者只会把拦截器接口和作用展示给开发者，让动态代理的逻辑在开发者的视野中“消失”。

通过上面的论述，大家可以看到通过定义拦截器,可以进一步简化动态代理的使用，让开发者的编码代码变得更为简单，下面用代码进行测试。

public static void testInterceptor() {HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(    new HelloWorldImpl(),    "com.learn.ssm.chapter3.proxy.intercept.impl.MyInterceptor");proxy.sayHelloWorld();}

运行这段代码，得到以下结果：

反射方法前逻辑

取代了被代理对象的方法

反射方法后逻辑

从测试的结果来看，显然拦截器已经生效。

▼

以上内容来自曾引领数万人学会SSM+Redis整合开发的技术畅销书升级版《Java EE互联网轻量级框架整合开发：SSM+Redis+Spring微服务（上下册）》。

前版读者评论

京东满100减50

快快扫码抢购吧！

如果喜欢本文欢迎 在看丨留言丨分享至朋友圈 三连

 热文推荐  
一部好看过武侠小说的热血互联网史！
书单 | 有这10本书，不怕黑客攻击了！
分布式系统中协调和复制技术的原理
QQ浏览器背后的推荐AI中台 | AICon

▼点击阅读原文，查看本书详情~

本文参与腾讯云自媒体同步曝光计划，分享自微信公众号。

原始发表：2021-09-22，如有侵权请联系 cloudcommunity@tencent.com 删除

ssm

本文分享自博文视点Broadview 微信公众号，前往查看

如有侵权，请联系 cloudcommunity@tencent.com 删除。

本文参与腾讯云自媒体同步曝光计划，欢迎热爱写作的你一起参与！

登录后参与评论

0 条评论

热度