写在最前面:关于代理模式,我准备写两篇博客。第一篇写基本的代理模式,并提供常用的代理工具类,第二篇在实战中如何使用代理模式----使用注解式AOP操作常用的Controller层代码。
另外推荐关于代理模式的深度好文:
代理模式(Proxy Pattern),静态代理 VS 动态代理
一、定义
代理模式:为目标对象提供一种代理以控制对目标对象的访问。在某些情况下,一个对象不适合或者不能直接引用目标对象(比如包访问权限的类),而代理对象可以在客户端和目标对象之间起到中介的作用, 其特征是代理类与委托类(真实对象)有同样的接口。
代理类就像秘书一样,为老板代理一些琐碎的事情,管事的还是老板。
二、分类
静态代理,JDK动态代理,Cglib动态代理。
三、静态代理
优点:不修改目标对象,同时对目标对象进行功能扩展。
缺点:类多,代码重复,维护难
1. 静态代理很麻烦,需要大量的代理类
代理类与目标类拥有相同的接口,每一个代理类只能代理一个目标类,如果目标类很多,那么代理类也会变得很多。
代理类与目标类拥有相同的接口,每一个代理类只能代理一个目标类,如果目标类很多,那么代理类也会变得很多。
2. 代码重复,因为代理类与目标类都实现了相同的接口,那么也就是说有两个类实现了这个接口,有很多重复的代码。
3.代码维护成本高
另外,如果接口增加了一个方法,那么实现类需要去实现这个方法,代理类也要去实现这个方法,这增加了代码维护的难度。
另外,如果接口增加了一个方法,那么实现类需要去实现这个方法,代理类也要去实现这个方法,这增加了代码维护的难度。
下面是一个简单的例子
package me.jay.designPattern; /** * Created by jay.zhou on 2018/4/19. */ //被代理的对象或者说是委托对象,实现了接口 public class Subject implements Operation{ @Override public void function() { System.out.println("主体操作"); } } //代理的对象,与委托对象实现了相同的接口 class Proxy implements Operation{ //持有委托对象的引用 private Subject subject; //使用构造函数接收 public Proxy(Subject subject) { this.subject = subject; } /** * 在执行委托对象之前,加入增强操作 * 一般在实际中有:日志,安全,事务,缓存等操作 * */ @Override public void function() { System.out.println("增强操作,如 日志,安全,事务,缓存"); subject.function(); System.out.println("后置处理,如记录操作时间"); } public static void main(String[] args) { //创建一个真实对象 Subject realObject = new Subject(); //创建一个代理对象 Proxy proxy = new Proxy(realObject); //执行代理对象 proxy.function(); /** * 运行结果: * 增强操作,如 日志,安全,事务,缓存 * 主体操作 * 后置处理,如记录操作时间 * */ } } //业务接口,有一个function方法需要实现 interface Operation{ void function(); }
四、JDK动态代理
优点:代理类的字节码文件在程序运行的时候,由Java反射生成。
缺点:JDK动态代理只能代理有接口的目标类。
总是说“运行时”,到底什么才是运行时?运行时是指并不是在Java代码中定义的,而是相关Java类的字节码文件在JVM在运行的时候,根据我们在Java代码中的“指示”,动态的生成了相关类的字节码文件,就好比我们自己写了那个类一样。泛型也是这个道理。编译时是指,在JVM运行之前就定义好了相关的Java类。
下面是一个简单的例子
package me.jay.designPattern; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * Created by jay.zhou on 2018/4/19. */ public class DynamicProxy implements InvocationHandler{ //被代理的对象的引用,或者说是委托对象,也可以称它为真实对象 private Object target; public DynamicProxy(Object target) { this.target = target; } public Object getInstance(){ /** * 参数1:类加载器 * 参数2:被代理对象所实现的接口,我们动态生成的代理类也将实现这些接口 * 参数3:使用哪个调用处理器的invoke方法,当前就使用这个类的实例对象的invoke方法 * */ return Proxy.newProxyInstance(this.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("增强操作,如 日志,安全,事务,缓存"); //调用被代理对象的业务方法 Object result = method.invoke(target,args); System.out.println("后置增强,用于记录数据,或者记录时间,将数据存到全局map中等"); return result; } public static void main(String[] args) { //业务实现类实现了Operatino接口 Operation subject = new Subject(); //创建动态代理对象 DynamicProxy proxy = new DynamicProxy(subject); //创建代理实例对象 Operation proxyInstance = (Operation)proxy.getInstance(); //调用代理对象的方法,包裹了真实对象的方法 proxyInstance.function(); } }
五、Cglib动态代理
如果目标没有实现接口,那么可以用cglib动态代理。cglib是针对类来实现代理的,它生成目标类的一个子类作为代理类。缺点就是不能对final修饰的类进行代理,final修饰的类不能生成子类。
下面是一个简单的例子
package me.jay.designPattern; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodInterceptor; import net.sf.cglib.proxy.MethodProxy; import java.lang.reflect.Method; /** * Created by jay.zhou on 2018/4/19. */ //要cglib与asm的相关jar包,这个类用于继承,重写intercept方法 public class CglibProxy implements MethodInterceptor { //被代理的对象,或者是说是真实对象,委托对象 private Object target; public CglibProxy(Object target) { this.target = target; } /** * 创建代理对象 * * @return 创建出来的代理对象,是真实对象的一个子类 */ public Object getInstance() { //创建代理对象的工厂 Enhancer enhancer = new Enhancer(); //设置代理对象的父类是当前的真实对象 enhancer.setSuperclass(this.target.getClass()); // 回调方法,当调用代理对象的时候,让真实对象去操作 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("增强操作,如 日志,安全,事务,缓存"); Object result = method.invoke(target,args); System.out.println("后置增强,用于记录数据,或者记录时间,将数据存到全局map中等"); return result; } public static void main(String[] args) { Temp temp = new Temp(); CglibProxy proxy = new CglibProxy(temp); Temp tempInstance = (Temp)proxy.getInstance(); tempInstance.login(); /** * 运行结果: * 增强操作,如 日志,安全,事务,缓存 * 临时登录 * 后置增强,用于记录数据,或者记录时间,将数据存到全局map中等 */ } } class Temp { public void login(){ System.out.println("临时登录"); } }
六、增强工具类例子
在类中添加抽象方法,让子类去继承它,实现其它增强的方法。这有点像拦截器的感觉了。重写invoke方法,父类的用super.invoke()方法回调。
package me.jay.designPattern; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; /** * Created by jay.zhou on 2018/4/19. */ public abstract class DynamicProxy implements InvocationHandler{ //被代理的对象的引用,或者说是委托对象,也很称它为真实对象 private Object target; public DynamicProxy(Object target) { this.target = target; } //前处理 public abstract Object prehandle(); //后处理 public abstract Object posthandle(); public Object getInstance(){ /** * 参数1:类加载器 * 参数2:被代理对象所实现的接口,我们动态生成的代理类也将实现这些接口 * 参数3:使用哪个调用处理器的invoke方法,当前就使用这个类的实例对象的invoke方法 * */ return Proxy.newProxyInstance(this.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 { //调用被代理对象的业务方法 Object result = method.invoke(target, args); return result; } }
分割线--------------------------------------------------------------------------------------------