本文介绍的是框架中十分常用的设计模式,所以开发者掌握它十分必要。
动态代理和责任链无论在Spring还是MyBatis中都有重要的应用。在分析Spring AOP和MyBatis技术原理时,它们广泛使用,值得读者认真研究。
代理模式的意义在于生成一个占位(又称代理对象),来代理真实对象(又称目标对象),从而控制真实对象的访问。
什么是代理模式
什么是代理模式?让我用例子给你讲清楚:
假设这样一个场景,你的公司是一家软件公司,你是一位软件工程师。客户带着需求去找公司显然不会直接和你谈,而是去找商务谈,此时客户会认为商务就代表公司。
用一张图来表示代理模式的含义,如图所示。
显然客户是通过商务去访问软件工程师的,那么商务(代理对象)的意义是什么呢?
商务可以进行谈判,比如项目启动前的商务谈判,软件的价格、交付、进度的时间节点等,或者项目完成后的商务追讨应收账款等。商务也有可能在开发软件之前谈判失败,此时商务就会根据公司规则去结束和客户的合作关系,这些都不用软件工程师来处理。
因此,代理的作用就是,在真实对象访问之前或者之后加入对应的逻辑,或者根据其他规则控制是否使用真实对象,显然在这个例子里商务控制了客户对软件工程师的访问。
经过上面的论述,我们知道商务和软件工程师是代理和被代理的关系,客户是通过商务去访问软件工程师的。此时客户就是程序中的调用者,商务就是代理对象,软件工程师就是真实对象。
我们需要在调用者调用对象之前产生一个代理对象,而这个代理对象需要和真实对象建立代理关系,所以代理必须包括两个步骤。
- 建立代理对象和真实对象之间的代理关系。
- 实现代理对象的代理逻辑方法。
在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