前言
本篇学习静态代理和动态代理,静态代理和动态代理是spring面向切面编程的底层原理
一、什么是代理模式?
代理模式是程序设计中的一种设计模式:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下,一个对象不适合或者不能直接引用另一个对象,而代理对象可以在客户端和目标对象之间起到中介的作用。
举个生活中的简单例子:
租客--------中介----------房东
现在假设没有中介,那么租房的这行为将会变成如下的情景。房东想要把房子租出去,但是他没有客源,于是他需要自己去告知租客,自己需要出租房子。例如需要自己去发传单。贴告示等等。然后有租客了就需要带着租客看房子,签合同,以后房子出了任何问题,都需要找房东解决。比如,灯泡坏了,厕所堵了,房间漏水等等。所有的工作都是房东一个人来完成。
现在可以有中介了。那么中介可以把房东所有的工作代替。中介同时对租客和房东负责,负责帮房东找客源,负责收缴房租。负责日常的问题解决。把租房这个功能交给中介来干。可以更高效的完成这些工作,而且可以让房东少去了很多麻烦。
中介就相当于代理。
那么程序设计中的代理是可以做哪些工作?
代理的目的可以把目标方法增强,把非核心代码抽调出来,统一进行管理。就类似于中介手里总会有客源和房源,这样房东就减少了工作量,租客也很快就能找到自己合适的房子。所谓的目标方法增强就是可以在功能执行前,和执行以后做一些别的操作。比如,在方法执行前,先进性权限校验。方法执行以后,进行日志记录。
二、静态代理和动态代理
1.静态代理
以租房为例,实现静态代理:
创建房东接口:
public interface FangDong {
void zufang();
}
实现接口:
public class FangdongImpl implements FangDong {
@Override
public void zufang() {
System.out.println("房东租房..." );
}
}
创建代理对象:
// 代理
public class FangdongProxy {
// 目标对象
private FangDong fangDong;
public FangdongProxy(FangDong fangDong){
this.fangDong = fangDong;
}
void zufang(){
// 前置增强
System.out.println("前:发传单,找客源" );
// 房东租房
fangDong.zufang();
// 后置增强
System.out.println("后:签合同" );
}
}
实现租房功能的测试
// 开始租房
public static void main(String[] args) {
// 找代理
FangdongProxy proxy = new FangdongProxy(new FangdongImpl( ));
// 真正租房
proxy.zufang();
}
执行成功
通过静态代理模式模拟实现了当房东租房的时候,先发了传单,租房完成后签了合同。然而静态代理有弊端。即只能创建一个代理,做一件事,一个代理不能做多件事。代码的重用性不高。无论是租房子,卖车子,还是别的功能。每次都需要新建一个新的代理,就像房产中介,不可以去卖车一样。
2.动态代理
如果可以实现。不管我要什么功能,我只需要创建一个代理,就可以完全的适用于所有的业务,那样就完美了。动态代理就可以实现这种功能。动态代理可以根据代理目标类,动态的产生代理对象。即实现动态代理之后,完全不需要再自己手动创建很多的代理类,而是根据我当前的需求,自动产生代理对象。这就是动态代理。
动态代理的实现有两种方案:
- JDK动态代理 2) CGLIB动态代理.
JDK的动态代理
JDK代理,是Java自有技术,无需导入依赖包.
案例:使用动态代理实现房东租房
接着上边的基础代码实现,首先创建JDK动态代理类
public class JDKProxy implements InvocationHandler {
// 目标类
private Object target;
// 指定目标对象
public JDKProxy(Object target){
this.target = target;
}
/**
* @param proxy 被代理对象
* @param method 目标方法
* @param args 目标方法的参数
* @return 目标方法的返回值
* @throws Throwable
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 目标方法前:
System.out.println("前置增强" );
// 目标方法执行
Object obj = method.invoke(target,args);
//目标方法后
System.out.println("后置增强" );
return obj;
}
}
测试:
public static void main(String[] args) {
// 目标类的类加载器
ClassLoader classLoader = FangdongImpl.class.getClassLoader( );
// 目标类的实现的所有接口
Class<?>[] interfaces = FangdongImpl.class.getInterfaces( );
// 目标方法执行处理器
JDKProxy handler = new JDKProxy(new FangdongImpl( ));
/**
* 参数1: 目标类的类加载器
* 参数2: 目标类的所实现的所有接口
* 参数3: 自己实现的目标方法处理器
*/
FangDong fangDong = (FangDong) Proxy.newProxyInstance(classLoader, interfaces, handler);
fangDong.zufang();
}
通过演示可以得出。动态代理可以动态的产生代理对象。
CJLIB动态代理技术
CGLIB动态代理技术,又叫字节码增强.动态产生代理对象,可以代理接口也可以代理实现类.CGLIB是第三方技术,spring框架中已经整合了cglib的技术,所以只需导入spring-aop的依赖即可.
案例: 使用动态代理技术,动态的产生汽车厂商的代理
创建代理对象
public class MyCglibInterceptor implements MethodInterceptor {
// cglib的增强器
private Enhancer enhancer = new Enhancer();
// 创建拦截器时,指定目标类的字节码
public MyCglibInterceptor(Class clazz){
enhancer.setSuperclass(clazz);
enhancer.setCallback(this);
}
// 提供一个获得代理对象的方法
public Object createProxyBean(){
return enhancer.create();
}
/**
* @param target 目标对象
* @param method
* @param args 目标方法的参数
* @param methodProxy 目标方法的代理对象
* @return 目标方法的返回值
* @throws Throwable
*/
@Override
public Object intercept(Object target, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
// 目标方法前:
System.out.println("前置增强:权限校验,或者事务开启" );
// 目标方法执行
Object ret = methodProxy.invokeSuper(target,args);
// 目标方法前:
System.out.println("后置增强:日志记录,或者事务提交" );
return ret;
}
}
创建测试类
public static void main(String[] args) {
// 此处,只需要将其他类字节码文件传入此处
// 即可得到其他类的代理对象
MyCglibInterceptor interceptor = new MyCglibInterceptor(CarFactoryImpl.class);
CarFactoryImpl carFactory = (CarFactoryImpl) interceptor.createProxyBean( );
carFactory.saleCar();
}
总结
无论是静态代理还是动态代理,其目的都是对目标方法功能的增强
代理技术一般在开发中使用的场景为
- 日志记录
- 事务开启与提交
- 性能检测
- 权限校验
- 等等
静态代理和动态代理的区别
静态代理只能代理一个目标类,动态代理可以自动生成不同的代理,应对不同的被代理对象。
两种动态代理实现方式的区别在于:
JDK实现的动态代理只能代理接口,即代理目标类必须要有接口才可以实现动态代理。
CJLIB实现的动态代理可以在没有接口的情况下实现动态代理。