SpringAOP的代理模式
代理模式作为23种经典设计模式之一,其比较官方的定义为“为其他对象提供一种代理以控制对这个对象的访问”,简单点说就是,之前A类自己做一件事,在使用代理之后,A类不直接去做,而是由A类的代理类B来去做。代理类其实是在之前类的基础上做了一层封装。java中有静态代理、JDK动态代理、CGLib动态代理的方式。静态代理指的是代理类是在编译期就存在的,相反动态代理则是在程序运行期动态生成的
一、静态代理
静态代理的特点是, 为每一个业务增强都提供一个代理类, 由代理类来创建代理对象
静态代理,简单点来说就是在程序运行之前,代理类和被代理类的关系已经确定。静态代理的实现方式一般有以下几个步骤,首先要定义一个公共的接口,供代理类和被代理类实现,如下
公共接口
/**
* 这是一个公共的接口
*/
public interface publicInterface {
void save();
void find();
}
被代理类
/**
* 被代理类
*/
public class UserDao implements publicInterface {
@Override
public void save() {
System.out.println("模拟保存用户");
}
@Override
public void find() {
System.out.println("模拟查询用户");
}
}
从被代理类上可以看到,被代理类要做的就是save和find操作,如果不使用代理模式,那么我们的使用方式则是直接使用,如下
public class test {
public static void main(String[] args) {
//不使用代理类
UserDao userDao = new UserDao();
userDao.save();
System.out.println("---------------");
userDao.find();
System.out.println("*****************");
//使用代理类
publicInterface proxyUserDao = new proxyUserDao();
proxyUserDao.save();
System.out.println("----------------");
proxyUserDao.find();
}
}
通过测试方法,可以得出执行方法的结果如下,
模拟保存用户
---------------
模拟查询用户
代理类
/**
* 这是一个代理类
*/
public class proxyUserDao implements publicInterface{
private UserDao userDao=new UserDao();
@Override
public void save() {
System.out.println("代理操作,开启事务");
userDao.save();
System.out.println("代理操作,关闭事务");
}
@Override
public void find() {
System.out.println("代理操作,开启事务");
userDao.find();
System.out.println("代理操作,关闭事务");
}
}
可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例,通过被代理类实例调用被代理对象的方法,另外在方法之前前后均可加入其它的方法处理逻辑,
最后,看使用代理类的测试方法:
public class test {
public static void main(String[] args) {
//使用代理类
publicInterface proxyUserDao = new proxyUserDao();
proxyUserDao.save();
System.out.println("----------------");
proxyUserDao.find();
}
}
返回的执行结果如下:
代理操作,开启事务
模拟保存用户
代理操作,关闭事务
----------------
代理操作,开启事务
模拟查询用户
代理操作,关闭事务
对比,使用静态代理和不使用静态代理,可以发现使用了代理之后,可以在被代理方法的执行前或后加入别的代码,实现诸如权限及日志的操作。
但是,静态代理也存在一定的问题,如果被代理方法很多,就要为每个方法进行代理,增加了代码维护的成本。有没有其他的方式可以减少代码的维护,那就是动态代理。
二、动态代理
静态代理会为每一个业务增强都提供一个代理类, 由代理类来创建代理对象, 而动态代理并不存在代理类, 代理对象直接由代理生成工具动态生成
1、JDK动态代理
JDK提供了动态代理的方式,可以生成代理类
动态代理类,如下:
/**
* 这是一个动态代理
*/
public class DynamicProxy implements InvocationHandler {
private UserDao userDao=null; //被代理对象
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("开始JDK动态代理");
method.invoke(userDao,args);
System.out.println("结束JDK动态代理");
return null;
}
//构造方法
public DynamicProxy(UserDao userDao){
this.userDao=userDao;
}
}
需要实现JDK中的InvocationHandler接口,实现其中的invoke方法,在此方法中通过反射的方式调用被代理类的方法,可以在方法执行前或后进行别的处理,下面看测试代码
/**
* JDK动态代理
*/
public class DynamicProxyTest {
public static void main(String[] args) {
UserDao userDao = new UserDao();
DynamicProxy dynamicProxy = new DynamicProxy(userDao);
//生成代理对象
/**
* 三个参数
* 1.被代理类的类加载器
* 2.被代理类实现的接口
* 3.invocationHandler的实现类
*/
publicInterface proxyInstance =
(publicInterface) Proxy.newProxyInstance(userDao.getClass().getClassLoader(),
userDao.getClass().getInterfaces(),
dynamicProxy);
proxyInstance.save();
System.out.println("-------------");
proxyInstance.find();
}
}
在测试代码中通过Proxy类的newProxyInstance方法,生成代理类的proxyInstance,需要三个参数,第一个为被代理类的类加载器,第二个为被代理类实现的接口,第三个则为invocationHandler的实现类,这样就生成了代理对象,然后通过代理对象调用方法执行结果如下,
开始JDK动态代理
模拟保存用户
结束JDK动态代理
-------------
开始JDK动态代理
模拟查询用户
结束JDK动态代理
从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的,生成对象后使用“实例调用方法”的方式进行方法调用,那么代理类的被代理类的关系只有在执行这行代码的时候才会生成,因此成为动态代理。
JDK的动态代理也存在不足,即被代理类必须要有实现的接口,如没有接口则无法使用JDK动态代理(从newProxyInstance方法的第二个参数可得知,必须传入被代理类的实现接口),那么需要使用CGLib动态代理。
2、CGLib动态代理
CGLib动态代理是一个第三方实现的动态代理类库,不要求被代理类必须实现接口,它采用的是继承被代理类,使用其子类的方式,弥补了被代理类没有接口的不足,
要使用CGLib必须要引入第三方类库,我这里使用的类库加入依赖
<!--CGLib动态代理-->
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
</dependency>
<dependency>
<groupId>org.ow2.asm</groupId>
<artifactId>asm</artifactId>
<version>9.1</version>
</dependency>
</dependencies>
定义一个没有实现接口的类
/**
* 这是一个没有实现接口的一个类
*/
public class CGLibProxy {
public CGLibProxy(){
System.out.println("CGLibProxy构造方法");
}
public void hello() {
System.out.println("你已经进入CGLib动态代理!");
}
/**
* 该方法不能被子类覆盖,Cglib是无法代理final修饰的方法的
*/
final public String sayOthers(String name) {
System.out.println("CGLibProxy:hello>>" + name);
return null;
}
}
要使用CGLib代理需要实现其MethodInterceptor接口:
/**
* 自定义一个MethodInterceptor
*/
public class MyMethodInterceptor implements MethodInterceptor {
/**
*
* @param obj :cglib生成的代理对象
* @param method :被代理对象方法
* @param args :方法入参
* @param methodProxy :代理方法
* @return
* @throws Throwable
*/
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
System.out.println("CGLib动态代理开始");
// Object object = methodProxy.invoke(obj, args);
Object object = methodProxy.invokeSuper(obj, args);
System.out.println("CGLib动态代理结束");
return object;
}
}
生成CGLIB代理对象调用目标方法测试类
public class CGLibProxyTest {
public static void main(String[] args) {
// 通过CGLIB动态代理获取代理对象的过程
Enhancer enhancer = new Enhancer();
// 设置enhancer对象的父类
enhancer.setSuperclass(CGLibProxy.class);
// 设置enhancer的回调对象
enhancer.setCallback(new MyMethodInterceptor());
// 创建代理对象
CGLibProxy cgLibProxy = (CGLibProxy) enhancer.create();
// 通过代理对象调用目标方法
cgLibProxy.hello();
cgLibProxy.sayOthers("final修饰的方法");
}
}
可以看出使用Enhancer生成代理类,需要设置被代理类,也就是父类(从这里可以看出是使用继承,生成的子类),设置回调方法。
CGLibProxy构造方法
CGLib动态代理开始
你已经进入CGLib动态代理!
CGLib动态代理结束
CGLibProxy:hello>>final修饰的方法
在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例
并且final类无法进行代理
五、总结
对静态代理、JDK动态代理、CGLib动态代理做一个总结,静态代理的维护成本比较高,有一个被代理类就需要创建一个代理类,而且需要实现相同的接口。JDK动态代理模式和CGLib动态代理的区别是JDK动态代理需要被代理类实现接口,而CGLib则是生成被代理类的子类,要求被代理类不能是final的,因为final类无法被继承。