加载中……

设计模式——深度分析代理模式

〇、基本认知

0.1、作用

增强目标对象对原代码逻辑前后的增强，而使调用者无感知（如非入侵式日志记录）。或者保护目标对象。

某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端与目标对象之间起到中介作用。（结构模式）

0.2、包含的三种角色

抽象主题(Subject)：声明真实主题与代理的共同接口方法，可为接口或抽象类。（购房者与中介约定的协议）

真实主题(RealSubject)：被代理类，执行真正逻辑业务的对象。（购房者）

代理主题(Proxy)：代理类，持有RealSubject的引用，具备对其的代理权。在调用代理对象时除了调用被代理对象的方法还会在代理对象前后增加一些处理代码。（中介）

一、应用场景

生活中：房产中介（房源大部分在他们那儿，不找不行）、票贩子（控制了很多车票）等

程序中：spring中aop对业务逻辑层进行非侵入性日志记录，事务控制等

二、静态代理

对遵守协议的类进行代理，其中只能硬编码，没有遵守协议的类一律不代理。（这儿的“协议”可以用接口或类规定）

2.1、通用写法

代码展示

实现要点：

  1. 用接口规定一些方法

  2. 代理类中实现接口，并在声明接口作为成员变量，构造方法中传入接口引用指向成员变量，实现接口的方法中调用接口中规定的方法并加入功能增强的逻辑。

  3. 真实主题类中实现接口的方法。

  4. 调用者在调用时声明代理类，并传入真实主题类的引用，调用代理类的。

UML图：

// 抽象主题类（协议）
 public interface ISubject {
     /**
      * 主要业务：如日志记录（现实中如卖房中介、婚介所）
      */
     void business();
 }
 ​
 // 代理类（中介）
 public class MyProxy implements ISubject{
 ​
     private ISubject subject;
     public MyProxy(ISubject subject){
         this.subject = subject;
     }
     @Override
     public void business() {
         after();
         subject.business();
         before();
     }
 ​
     private void after(){
         System.out.println("===static proxy 前置处理===");
     }
     private void before(){
         System.out.println("===static proxy 后置处理===");
     }
 }
 ​
 // 真实主题类（买房者）
 public class RealSubject implements ISubject{
     @Override
     public void business() {
         System.out.println(" this is RealSubject");
     }
 }

2.2、应用案例

数据源切换，在分布式场景下根据订单创建时间自动按年份进行分库。

代码

// 订单实体
 @Data
 public class Order {
     private Object orderInfo;
     //订单创建时间进行按年分库
     private Long createTime;
     private String id;
 }

// 动态数据源-实体
 public class DynamicDataSourceEntity {
     public final static String DEFAULE_SOURCE = null;
 ​
     private final static ThreadLocal<String> local = new ThreadLocal<String>();
 ​
     private DynamicDataSourceEntity(){}
 ​
     public static String get(){return  local.get();}
 ​
     public static void restore(){
         local.set(DEFAULE_SOURCE);
     }
 ​
     // DB_2018 、DB_2019
     public static void set(String source){local.set(source);}
 ​
     public static void set(int year){local.set("DB_" + year);}
 }

// 订单接口和实现类
 public interface IOrderService {
     int createOrder(Order order);
 }
 ​
 public class OrderServiceImpl implements IOrderService{
     @Override
     public int createOrder(Order order) {
         System.out.println("OrderService调用orderDao创建订单");
         return 1;
     }
 }

// 代理类
 public class OrderServiceStaticProxy implements IOrderService {
     private SimpleDateFormat yearFormat = new SimpleDateFormat("yyyy");
     private IOrderService orderService;
     public OrderServiceStaticProxy(IOrderService orderService) {
         this.orderService = orderService;
     }
 ​
     @Override
     public int createOrder(Order order) {
         // ========== 前置操作，模拟根据年份切换数据源==========
         Long time = order.getCreateTime();
         Integer dbRouter = Integer.valueOf(yearFormat.format(new Date(time)));
         System.out.println("静态代理类自动分配到【DB_" +  dbRouter + "】数据源处理数据" );
         DynamicDataSourceEntity.set(dbRouter);
 ​
         // ========== 调用真实主题类的方法==========
         this.orderService.createOrder(order);
 ​
         // ========== 后置操作，切换回默认数据源==========
         DynamicDataSourceEntity.restore();
         return 0;
     }
 }

// 测试类
 public class Test {
     public static void main(String[] args) {
         try {
             Order order = new Order();
             SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd");
             Date date = sdf.parse("2019/03/01");
             order.setCreateTime(date.getTime());
 ​
             IOrderService orderService = (IOrderService)new OrderServiceDynamicProxy().getInstance(new OrderServiceImpl());
             orderService.createOrder(order);
         }catch (Exception e){
             e.printStackTrace();
         }
     }
 }

三、动态代理

不管目标对象是啥都可以对其进行代理，而静态代理只能对实现的接口的类进行代理。

动态代理会造成频繁gc

动态代理是通过动态生成代理类代码，动态生成的代码中让需要代理的类“遵守规则”，然后就对其代理，这样就避免了静态代理中需要硬编码手动遵守规则的麻烦。

3.1 JDK实现方式

// 抽象主题类
 public interface ISubject {
     /**
      * 主要业务：如日志记录（现实中如卖房中介、婚介所）
      */
     void business();
 }

// 代理类
 // 需要实现 InvocationHandler 类，用到jdk中封装好的 Proxy.newProxyInstance()
 public class ProxyProcess implements InvocationHandler {
 ​
     private ISubject target;
     public ISubject getInstance(ISubject target){
         this.target = target;
         Class<?> clazz = target.getClass();
         return (ISubject) Proxy.newProxyInstance(clazz.getClassLoader(),
                 clazz.getInterfaces(),
                 this);
     }
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         before();
         Object invoke = method.invoke(this.target, args);
         after();
         return invoke;
     }
     private void after(){
         System.out.println("===static proxy 前置处理===");
     }
     private void before(){
         System.out.println("===static proxy 后置处理===");
     }
 }

// 真实主题类
 public class RealSubject implements ISubject{
     @Override
     public void business() {
         System.out.println(" this is RealSubject");
     }
 }

// Test
 public class Test {
     public static void main(String[] args) {
         ProxyProcess proxy = new ProxyProcess();
         ISubject subject = proxy.getInstance(new RealSubject());
         subject.business();
       
         // 将临时代码输出到磁盘，可通过反编译tool查看到源码
         byte[] bytes = ProxyGenerator.generateProxyClass("$Proxy0",
                 new Class[]{ISubject.class});
         try {
             FileOutputStream fos = new FileOutputStream("E://$Proxy0.class");
             fos.write(bytes);
             fos.close();
         } catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

3.2 手写JDK Proxy

JDK动态代理采用字节重组，重新生成新的对象来代替原始对象。

动态生成代理对象步骤：

  1. 反射获取被代理类对象的引用和所有接口；

  2. 生成一个实现被代理类的所有接口的临时类；

  3. 编译动态生成的临时类；

  4. 加载到JVM中运行 ；

  5. 返回新的代理对象。

在JDK中有个在ClassPath下只要是$开头的.class文件，一般都是动态生成的。

查看反编译出的源码发现，$Proxy0继承了Proxy类，同时实现了ISubject接口且类加上了final修饰，里面重写了ISubject接口定义的方法，在静态块中保存了所有方法的引用，重写的方法用反射调用目标对象的方法。

我们自己实现JDK Proxy时主要要写这样几个类：InvocationHandler(定义回调接口)、Proxy(生成源代码)、ClassLoader(加载自定义Proxy生成的代码的类)

回调接口

public interface MyInvocationHandler {
     Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
 }

类加载器

public class MyClassLoader extends ClassLoader{
     private File classPathFile;
     public MyClassLoader(){
         // 代理类生成的文件位于本路径下
         String classPath = MyClassLoader.class.getResource("").getPath();
         this.classPathFile = new File(classPath);
     }
 ​
     @Override
     protected Class<?> findClass(String name) throws ClassNotFoundException {
         String className = MyClassLoader.class.getPackage().getName() + "." + name;
         if(classPathFile  != null){
             File classFile = new File(classPathFile,name.replaceAll("\\.","/") + ".class");
             if(classFile.exists()){
                 FileInputStream in = null;
                 ByteArrayOutputStream out = null;
                 try{
                     // 读取文件内容
                     in = new FileInputStream(classFile);
                     out = new ByteArrayOutputStream();
                     byte [] buff = new byte[1024];
                     int len;
                     while ((len = in.read(buff)) != -1){
                         out.write(buff,0,len);
                     }
                     // ClassLoader 中的方法，将class文件封装在Class类中
                     return defineClass(className,out.toByteArray(),0,out.size());
                 }catch (Exception e){
                     e.printStackTrace();
                 }
             }
         }
         return null;
     }
 }

生成代理类的类

public class MyProxy {
     public static final String ln = "\r\n";
 ​
     public static Object newProxyInstance(MyClassLoader classLoader, Class<?> [] interfaces, MyInvocationHandler h){
         try {
             // 1、动态生成源代码.java文件
             String src = generateSrc(interfaces);
 ​
             // 2、Java文件输出磁盘
             File f = write2Desk(src);
 ​
             //3、把生成的.java文件编译成.class文件
             compiler(f);
 ​
             //4、编译生成的.class文件加载到JVM中来
             // $Proxy0 和生成类时类名保持一致即可，生成的临时类放在本类同路径下
             // 所以这儿要自定义ClassLoader，在加载临时类时就在当前同路径下找的
             Class proxyClass =  classLoader.findClass("$Proxy0");
             // 注意：构造器中要传入调用处理器
             Constructor c = proxyClass.getConstructor(MyInvocationHandler.class);
             f.delete();
 ​
             //5、返回字节码重组以后的新的代理对象
             // 注意：构造器中要传入调用处理器
             return c.newInstance(h);
         }catch (Exception e){
             e.printStackTrace();
         }
         return null;
     }
 ​
     /**
      * 生成代理类的源代码
      *
      * @param interfaces
      * @return
      */
     private static String generateSrc(Class<?>[] interfaces){
         StringBuffer sb = new StringBuffer();
         // 包相关
         sb.append(MyProxy.class.getPackage() + ";" + ln);
         sb.append("import " + interfaces[0].getName() + ";" + ln);
         sb.append("import java.lang.reflect.*;" + ln);
         // 定义类并实现接口
         sb.append("public class $Proxy0 implements " + interfaces[0].getName() + "{" + ln);
         // 初始化变量
         sb.append("MyInvocationHandler h;" + ln);
         sb.append("public $Proxy0(MyInvocationHandler h) { " + ln);
         sb.append("this.h = h;");
         sb.append("}" + ln);
         // 实现接口中的方法
         for (Method m : interfaces[0].getMethods()){
             Class<?>[] params = m.getParameterTypes();
 ​
             StringBuffer paramNames = new StringBuffer();
             StringBuffer paramValues = new StringBuffer();
             StringBuffer paramClasses = new StringBuffer();
 ​
             // 处理接口方法中的参数（准备着，下一步用）
             for (int i = 0; i < params.length; i++) {
                 Class clazz = params[i];
                 String type = clazz.getName();
                 String paramName = toLowerFirstCase(clazz.getSimpleName());
                 paramNames.append(type + " " +  paramName);
                 paramValues.append(paramName);
                 paramClasses.append(clazz.getName() + ".class");
                 if(i > 0 && i < params.length-1){
                     paramNames.append(",");
                     paramClasses.append(",");
                     paramValues.append(",");
                 }
             }
 ​
             // 处理具体方法
             sb.append("public " + m.getReturnType().getName() + " " + m.getName() + "(" + paramNames.toString() + ") {" + ln);
             sb.append("try{" + ln);
             sb.append("Method m = " + interfaces[0].getName() + ".class.getMethod(\"" + m.getName() + "\",new Class[]{" + paramClasses.toString() + "});" + ln);
             // 处理正常情况下的返回值，让回调
             sb.append(((m.getReturnType() != void.class) ? "return " : "") + getCaseCode("this.h.invoke(this,m,new Object[]{" + paramValues + "})",m.getReturnType()) + ";" + ln);
             // 处理异常情况
             sb.append("}catch(Error _ex) { }");
             sb.append("catch(Throwable e){" + ln);
             sb.append("throw new UndeclaredThrowableException(e);" + ln);
             sb.append("}");
             sb.append(getReturnEmptyCode(m.getReturnType()));
             sb.append("}");
         }
         sb.append("}" + ln);
         return sb.toString();
     }
 ​
     /**
      * 将内容输出到磁盘
      *
      * @param src 源文件内容
      * @return {@link File} 文件信息
      * @throws IOException
      */
     private static File write2Desk(String src) throws IOException {
         String filePath = MyProxy.class.getResource("").getPath();
         File f = new File(filePath + "$Proxy0.java");
         FileWriter fw = new FileWriter(f);
         fw.write(src);
         fw.flush();
         fw.close();
         return f;
     }
 ​
     /**
      * 把生成的.java文件编译成.class文件
      *
      * @param f
      * @throws IOException
      */
     private static void compiler(File f) throws IOException {
         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
         StandardJavaFileManager manage = compiler.getStandardFileManager(null,null,null);
         Iterable iterable = manage.getJavaFileObjects(f);
 ​
         JavaCompiler.CompilationTask task = compiler.getTask(null,manage,null,null,null,iterable);
         task.call();
         manage.close();
     }
 ​
 ​
 ​
     private static Map<Class,Class> mappings = new HashMap<Class, Class>();
     static {
         mappings.put(int.class,Integer.class);
     }
 ​
     /**
      * 出现异常时返回的内容
      *
      * @param returnClass
      * @return
      */
     private static String getReturnEmptyCode(Class<?> returnClass){
         if(mappings.containsKey(returnClass)){
             return "return 0;";
         }else if(returnClass == void.class){
             return "";
         }else {
             return "return null;";
         }
     }
 ​
     private static String getCaseCode(String code,Class<?> returnClass){
         if(mappings.containsKey(returnClass)){
             return "((" + mappings.get(returnClass).getName() +  ")" + code + ")." + returnClass.getSimpleName() + "Value()";
         }
         return code;
     }
 ​
     /**
      * 将类名的首字母转为小写
      *
      * @param src
      * @return
      */
     private static String toLowerFirstCase(String src){
         char [] chars = src.toCharArray();
         if(65 <= chars[0] && chars[0] <= 90) {
             chars[0] += 32;
         }
         return String.valueOf(chars);
     }
 }

测试代理类

public class MyProxyProcess implements MyInvocationHandler {
 ​
     private ISubject target;
     public ISubject getInstance(ISubject target){
         this.target = target;
         Class<?> clazz = target.getClass();
         return (ISubject) MyProxy.newProxyInstance(new MyClassLoader(),
                 clazz.getInterfaces(),
                 this::invoke);
     }
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         before();
         Object invoke = method.invoke(this.target, args);
         after();
         return invoke;
     }
     private void after(){
         System.out.println("===static proxy 前置处理===");
     }
     private void before(){
         System.out.println("===static proxy 后置处理===");
     }
 }

调用过程分析

// Test类
 public class Test {
     public static void main(String[] args) {
         ProxyProcess proxy = new ProxyProcess();
         ISubject subject = proxy.getInstance(new RealSubject());
         subject.business(); // ====1 调用代理入口===============
     }
 }
 ​
 // 生成的代理类
 public class $Proxy0 implements ISubject {
     MyInvocationHandler h;
     // 实例化时将回调接口的引用记录下的
     public $Proxy0(MyInvocationHandler var1) {
         this.h = var1;
     }
 // ========实际调用到这儿===============
     public void business() {
         try {
             Method var1 = ISubject.class.getMethod("business");
             // =======2 调用回调接口中的方法===========
             this.h.invoke(this, var1, new Object[0]);
         } catch (Error var2) {
             ;
         } catch (Throwable var3) {
             throw new UndeclaredThrowableException(var3);
         }
 ​
     }
 }
 ​
 // ============3 调用回调接口 ===========
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     // 前置处理……
     before();
     // ==========4 回调真实主题类的业务方法==========
     Object invoke = method.invoke(this.target, args);
     after();
     return invoke;
 }
 private void after(){
     System.out.println("===static proxy 前置处理===");
 }
 private void before(){
     System.out.println("===static proxy 后置处理===");
 }

 

3.3 CGLib实现方式

添加cglib依赖（spring底层用sm框架，sm框架有依赖cglib的包）

 <dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib-nodep</artifactId>
  <version>2.2</version>
 </dependency>

// 真实主题类 
// 不用实现接口
 public class RealSubject {
     public void business() {
         System.out.println(" this is RealSubject");
     }
 }

// 代理类
 public class ProxyProcess implements MethodInterceptor {
 ​
     public Object getInstance(Class<?> clazz){
         Enhancer enhancer = new Enhancer();
         enhancer.setSuperclass(clazz);
         enhancer.setCallback(this);
         return enhancer.create();
     }
 ​
     @Override
     public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
         before();
         Object invoke = methodProxy.invokeSuper(o, objects);
         after();
         return invoke;
     }
 ​
     private void after(){
         System.out.println("=== proxy 前置处理===");
     }
     private void before(){
         System.out.println("=== proxy 后置处理===");
     }
 }

// 测试类
 public class Test {
     public static void main(String[] args) {
         // 利用CGLib的代理类可将内存中的.class文件写入本地磁盘
         System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./cglib_proxy_class/");
 ​
         RealSubject obj = (RealSubject) new ProxyProcess().getInstance(RealSubject.class);
         obj.business();
     }
 }

3.4 CGLib代理分析

查看CGLib生成的代理类可以主要看到生成了三个类

其中RealSubjectb6c07846.class代理类继承了需要代理的类

public class RealSubject$$EnhancerByCGLIB$$b6c07846 extends RealSubject implements Factory {
  // ……
  static void CGLIB$STATICHOOK1() {
      CGLIB$THREAD_CALLBACKS = new ThreadLocal();
      // ……
      CGLIB$business$0$Proxy = MethodProxy.create(var1, var0, "()V", "business", "CGLIB$business$0");
  }
 // 代理方法 methodProxy.invokeSuper()会调用
  final void CGLIB$business$0() {
      super.business();
  }
 // 被代理方法 methodProxy.invoke()调用。拦截器中调用会发生死循环（一直在调用拦截器）
  public final void business() {
      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
      if (this.CGLIB$CALLBACK_0 == null) {
          CGLIB$BIND_CALLBACKS(this);
          var10000 = this.CGLIB$CALLBACK_0;
      }
 ​
      if (var10000 != null) {
          // 调用拦截器
          var10000.intercept(this, CGLIB$business$0$Method, CGLIB$emptyArgs, CGLIB$business$0$Proxy);
      } else {
          super.business();
      }
  }
  // ……
 }

可以看到代理类中重写了RealSubject类中方法

对象调用过程：调用生成代理对象中的 business() -> 调用MethodInterceptor接口中的intercept() 【前置后置处理就在这儿】 -> methodProxy.invokeSuper() 【通过它调用到真实主题类中方法】 -> CGLIB0$Method -> 被代理对象的business()

调用过程代码分析

// Test 类
 public static void main(String[] args) {
  // 利用CGLib的代理类可将内存中的.class文件写入本地磁盘
  System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY, "./cglib_proxy_class/");
 ​
  RealSubject obj = (RealSubject) new ProxyProcess().getInstance(RealSubject.class);
  obj.business(); // ============ 1 入口=========
 }
 ​
 // CGLib生成-代理类
 public class RealSubject$$EnhancerByCGLIB$$b6c07846 extends RealSubject implements Factory {
  // ……
  static void CGLIB$STATICHOOK1() {
      CGLIB$THREAD_CALLBACKS = new ThreadLocal();
      // ……
      CGLIB$business$0$Proxy = MethodProxy.create(var1, var0, "()V", "business", "CGLIB$business$0");
  }
 // 代理方法 methodProxy.invokeSuper()会调用
  final void CGLIB$business$0() {
      super.business();
  }
  // ============2 调用1实际上调用到了代理类的这个重写的方法==========
 // 被代理方法 methodProxy.invoke()调用。拦截器中调用会发生死循环（一直在调用拦截器）
  public final void business() {
      MethodInterceptor var10000 = this.CGLIB$CALLBACK_0;
      if (this.CGLIB$CALLBACK_0 == null) {
          CGLIB$BIND_CALLBACKS(this);
          var10000 = this.CGLIB$CALLBACK_0;
      }
 // ============ 3 调用 方法拦截器中的方法============
      if (var10000 != null) {
          // 调用拦截器
          var10000.intercept(this, CGLIB$business$0$Method, CGLIB$emptyArgs, CGLIB$business$0$Proxy);
      } else {
          super.business();
      }
  }
  // ……
 }
 ​
 // 代理处理类
 public class ProxyProcess implements MethodInterceptor {
 ​
  public Object getInstance(Class<?> clazz){
      Enhancer enhancer = new Enhancer();
      enhancer.setSuperclass(clazz);
      enhancer.setCallback(this);
      return enhancer.create();
  }
 // ================3 拦截器中的intercept()========
 // ！！！！！！！ 前置、后置任务也都在这儿处理 ！！！！！！！
  @Override
  public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
      before();
      // ==========4 调用methodProxy.invokeSuper
      Object invoke = methodProxy.invokeSuper(o, objects);
      after();
      return invoke;
  }
 ​
  private void after(){
      System.out.println("=== proxy 前置处理===");
  }
  private void before(){
      System.out.println("=== proxy 后置处理===");
  }
 }
 ​
 ​
 // net.sf.cglib.proxy.MethodProxy#invokeSuper
 public Object invokeSuper(Object obj, Object[] args) throws Throwable {
  try {
      this.init();
      MethodProxy.FastClassInfo fci = this.fastClassInfo;
      // =========5 调用被代理类的FastClass类===
      return fci.f2.invoke(fci.i2, obj, args);
  } catch (InvocationTargetException var4) {
      throw var4.getTargetException();
  }
 }
 ​
 // CGLib生成-被代理类的FastClass类
 // 传来的参数 var1 = 15; var2 = 实例化的 RealSubject$$EnhancerByCGLIB$$24be692e
 public Object invoke(int var1, Object var2, Object[] var3) throws InvocationTargetException {
  24be692e var10000 = (24be692e)var2;
  int var10001 = var1;
 ​
  try {
      // 根据 index 直接定位执行方法
      switch(var10001) {
              // ……
          case 15:
              // ===========6 调用代理类的FastClass======
              var10000.CGLIB$business$0();
              return null;
      }
  }
 }
 ​
 // CGLib生成-代理类
 final void CGLIB$business$0() {
  // ============7 调用到被代理类的business()（真实主题类中的）
  super.business();
 }
 // ========= 然后往上返回就结束了========

 

CGLib代理执行效率之所以比JDK代理高，是因为CGLib采用了FastClass机制（简单理解：为代理类和被代理类各生成一个类，这个类会为代理类或被代理类的方法分配一个index(int类型)；这个index当作一个入参，FastClass就可以直接定位要调用的方法并直接调用，省去了反射调用，所以调用效率比JDK代理通过反射调用高）

RealSubject7fe7be4a.class 是代理类的FastClass

RealSubjectb6c078464d2aad20.class 是被代理类的FastClass

其余要点分析

FastClass并不是更代理类一起生成的，而是在第一次执行MethodProxy的invoke()或invokeSuper()时生成的，并放在了缓存中。

// net.sf.cglib.proxy.MethodProxy#invokeSuper
 // MethodProxy的invoke()和invokeSuper()都调用了init()
 public Object invokeSuper(Object obj, Object[] args) throws Throwable {
     try {
         this.init();
         MethodProxy.FastClassInfo fci = this.fastClassInfo;
         return fci.f2.invoke(fci.i2, obj, args);
     } catch (InvocationTargetException var4) {
         throw var4.getTargetException();
     }
 }
 ​
 public Object invoke(Object obj, Object[] args) throws Throwable {
     try {
         this.init();
         MethodProxy.FastClassInfo fci = this.fastClassInfo;
         // 调用FastClass
         return fci.f1.invoke(fci.i1, obj, args);
     } catch (InvocationTargetException var4) {
         throw var4.getTargetException();
     } catch (IllegalArgumentException var5) {
         if (this.fastClassInfo.i1 < 0) {
             throw new IllegalArgumentException("Protected method: " + this.sig1);
         } else {
             throw var5;
         }
     }
 }
 ​
 private void init() {
     if (this.fastClassInfo == null) {
         Object var1 = this.initLock;
         synchronized(this.initLock) {
             if (this.fastClassInfo == null) {
                 MethodProxy.CreateInfo ci = this.createInfo;
                 MethodProxy.FastClassInfo fci = new MethodProxy.FastClassInfo();
                 // 如果在缓存就取出，没有在缓存就生成新的FastClass
                 fci.f1 = helper(ci, ci.c1);
                 fci.f2 = helper(ci, ci.c2);
                 // 获取方法的index
                 fci.i1 = fci.f1.getIndex(this.sig1);
                 fci.i2 = fci.f2.getIndex(this.sig2);
                 this.fastClassInfo = fci;
             }
         }
     }
 }

3.5 JDK和CGLib动态代理对比

  1. JDK 实现被代理对象的接口，CGLib 继承被代理对象（所以不能代理有final修饰的）；

  2. 生成字节码层面：JDK和CGLib都在运行期生成字节码，JDK直接写字节码，CGLib使用ASM框架写字节码，CGLib实现更复杂、生成代理类比JDK效率低；

  3. 执行代理类层面：JDK代理方法通过反射机制调用，CGLib通过FastClass机制直接调用方法，CGLib执行效率更高。

 

四、代理模式与Spring

4.1 代理模式在Spring源码中的应用

Spring利用动态代理实现AOP有两个非常重要的类 JdkDynamicAopProxy 、CglibAopProxy。

4.2 Spring中的代理选择原则

当Bean有实现接口时就使用JDK代理，没有就使用CGLib代理。

可以通过配置强制使用CGLib代理

 <aop: aspectj-autoproxy proxy-target-class = "true"/>

五、代理模式的优缺点

5.1、优点

  • 将代理对象与真实目标对象分离

  • 在一定程度上降低了系统耦合性，扩展性好

  • 可以保护目标对象、增强目标对象功能

5.2、缺点

处理速度会比较慢

系统复杂度会增加

posted @ 2020-10-24 22:42  一泓清泉，一叶扁舟  阅读(45)  评论(0)    收藏  举报