常用的设计模式：动态代理

最新推荐文章于 2023-12-04 20:11:13 发布

浩骞

最新推荐文章于 2023-12-04 20:11:13 发布

阅读量277

点赞数

分类专栏： Java 文章标签： java

原文链接：https://mp.weixin.qq.com/s/1Z168TE1NEier49TXfHrpA

版权

Java 专栏收录该内容

32 篇文章 11 订阅

订阅专栏

什么是代理模式

什么是代理模式？让我用例子给你讲清楚：

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

用一张图来表示代理模式的含义，如图所示。
在这里插入图片描述
显然客户是通过商务去访问软件工程师的，那么商务（代理对象）的意义是什么呢？

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

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

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

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

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

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

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

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

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

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

CGLIB动态代理

在这里插入图片描述

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

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

被代理对象

/**
 * 被代理对象
 */
public class HelloWorld {

    public void sayHelloWorld(String content) {
        System.out.println("Hello World " + content);
    }

}

代理对象

被代理对象不存在任何接口，所以没办法使用JDK动态代理，这里采用CBLIB动态代理技术，代码如下：

package cglib;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;

/**
 * CGLIB动态代理 适用于被代理对象没有实现接口的情况
 */
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.out.println("调用真实对象前");

        // CGLIB反射调用真实对象方法
        Object result = methodProxy.invokeSuper(proxy, args);

        System.out.println("调用真实对象后");
        return result;
    }
}

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

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

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

public class Test {

    public static void main(String[] args) {
        CglibProxyExample cpe = new CglibProxyExample();
        HelloWorld proxy = (HelloWorld) cpe.getProxy(HelloWorld.class);
        proxy.sayHelloWorld("你好 CglibProxy");
    }
}

在这里插入图片描述

JDK动态代理

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

/**
 * jdk动态代理必须有接口
 */
public interface HelloWorld {
    /**
     * 接口方法
     */
    public void sayHelloWorld(String content);
}

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

/**
 * 实现类（被代理对象）
 */
public class HelloWorldImpl implements HelloWorld {
    @Override
    public void sayHelloWorld(String content) {
        System.out.println("Hello World " + content);
    }
}

此时可以开始编写动态代理的代码了。在JDK动态代理中，要实现代理逻辑类必须实现 java.lang.reflect.InvocationHandler 接口，它定义了一个invoke() 方法，并提供接口数组用于下挂代理对象，代码如下:

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * JDK动态代理 是基于接口创建代理对象
 */
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("调用真实对象前");

        // 调用被代理对象的 sayHelloWorld 方法
        Object obj = method.invoke(target, args);

        System.out.println("调用真实对象后");
        return obj;
    }
}

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

第1步，建立代理对象和真实对象的关系

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

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

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

第2步，实现代理逻辑方法

invoke 方法可以实现代理逻辑

invoke方法的3个参数的含义如下:

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

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

public class Test {

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

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

JDK动态代理实现拦截器原理

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

下面将使用JDK动态代理来展示一个拦截器的本质

代码结构
在这里插入图片描述
使用上边定义的接口、被代理对象

public interface HelloWorld {
    public void sayHelloWorld(String content);
}

public class HelloWorldImpl implements HelloWorld {
    @Override
    public void sayHelloWorld(String content) {
        System.out.println("Hello World " + content);
    }
}

先定义拦截器接口Interceptor，代码如下：

/**
 * 自定义拦截器接口
 */
public interface MyInterceptor {

    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方法。
在反射真实对象方法或者around方法执行之后，调用after方法。

编写这个Interceptor的实现类，代码如下。

import java.lang.reflect.Method;

/**
 * 自定义拦截器实现类
 */
public class MyInterceptorImpl implements MyInterceptor {

    @Override
    public boolean before(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法前逻辑");
        return false;
    }

    @Override
    public void around(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("反射方法后逻辑");
    }

    @Override
    public void after(Object proxy, Object target, Method method, Object[] args) {
        System.out.println("取代了被代理对象的方法");
    }
}

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

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * 拦截器的动态代理代理对象
 */
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));
    }


    /**
     * 通过代理对象调用方法，首先进入这个方法
     *
     * @param proxy  代理对象
     * @param method 方法，被调用方法
     * @param args   方法的参数
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (interceptorClass == null) {
            // 没有为被代理对象设置拦截器，则直接反射调用被代理对象方法
            return method.invoke(target, args);
        }

        Object result = null;
        // 通过反射获取为被代理对象设置的拦截器
        MyInterceptor interceptor = (MyInterceptor) Class.forName(interceptorClass).getConstructor().newInstance();
        // 调用拦截器before方法
        if (interceptor.before(proxy, target, method, args)) {
            // 调用被代理对象的原有方法
            result = method.invoke(target, args);
        } else {
            // 调用拦截器around方法
            interceptor.around(proxy, target, method, args);
        }
        // 调用拦截器after方法
        interceptor.after(proxy, target, method, args);
        return result;
    }
}

这里有两个属性：

target，它是真实对象；
interceptorClass，它是一个拦截器的全限定名。

解释一下这段代码的执行步骤。

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

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

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

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

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

第6步，返回结果。

拦截器的工作流程，如图所示。
在这里插入图片描述

开发者只要知道拦截器的方法和作用就可以编写拦截器了，编写完成后可以设置拦截器，这样就完成了自己的任务，所以对于开发者来说是简单的。

设计者是精通Java的开发和设计的人员，由他们来完成动态代理的逻辑。

设计者只会把拦截器接口和作用展示给开发者，让动态代理的逻辑在开发者的视野中“消失”。

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

public class Test {

    public static void main(String[] args) {
        HelloWorld proxy = (HelloWorld) InterceptorJdkProxy.bind(
                new HelloWorldImpl(),
                "my_intercept_demo.MyInterceptorImpl");
        proxy.sayHelloWorld("你好");
    }
}

运行这段代码，得到以下结果：
在这里插入图片描述
从测试的结果来看，显然拦截器已经生效。

代码详见： https://gitee.com/qiu_yunzhao/daily_function_test/tree/master/dynamic_agent/src/main/java

浩骞

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
常用的设计模式：动态代理

目录![在这里插入图片描述](https://img-blog.csdnimg.cn/3d94ffc6de464ae2843ee0849209f70c.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/8556e9ca957449c9953b07081d54b8f2.png)![在这里插入图片描述](https://img-blog.csdnimg.cn/567c850eb5b6412194f458d283d3bf81.png)...
复制链接

扫一扫