JDK动态代理与CGLIB动态代理

一、代理模式概述

1.1.生活中代理案例

• 房屋中介代理
  • 客户手里面没有房源信息，找一个中介
• 商品代购
  • 这些代购者可以去拿到比较低成本的商品，拥有自己的渠道

1.2.为什么要使用代理

• 对于消费者而言，可以减少成本，只需要关心自己需要的商品，不需要去寻找渠道或者是找房源。

1.3.代理模式在 Java 中的应用

• 统一异常处理
• Mybatis 使用了代理
• Spring aop实现原理
• 日志框架

1.4.概述

• 代理模式（Proxy Pattern）：是23种设计模式中的一种，属于结构型的模式。指一个对象本身不做实际的操作，而是通过其它对象来得到自己想得到的结果。
• 意义：目标对象只需要关心自己的实现细节，通过代理对象来实现功能的增强，可以扩展目标对象的功能。
• 体现了非常重要的编程思想：不能随便修改源码，如果需要修改源码，通过修改代理的方式来实现功能的拓展。

1.5.生活中代理图示

• 图示
  

二、代理的实现方式

2.1.Java 中代理图示

• 图示
  

• 元素组成

  • 接口，定义行为和规范的
  • 被代理类，是目标对象
  • 代理类，做功能增强的

2.2.静态代理

2.2.1案例

• 通过代理模式实现事务操作

2.2.2实现案例

• 创建 domain 对象

  @Data
  public class Student {
      private String name;
      private int age;
  }
  

• 创建service 接口定义规范

  public interface IStudentService {
      /**
       * 添加学生
       */
      void save();
  
      /**
       * 查询学生信息
       * @param id
       * @return
       */
      Student query(Long id);
  }
  

• 创建实现类，被代理类

  public class StudentServiceImpl implements IStudentService {
      public void save() {
          System.out.println("保存学生信息");
      }
  
      public Student query(Long id) {
          Student student = new Student();
          student.setName("sy");
          student.setAge(18);
          return student;
      }
  }
  

• 创建事务类对象

  public class DaoTransaction {
      public void before(){
          System.out.println("开启事务操作");
      }
  
      public void after(){
          System.out.println("关闭事务");
      }
  }
  

• 创建代理类对象

  public class ProxyStudent implements IStudentService {
      //目标类对象
      private StudentServiceImpl studentService;
      //需要做的增强对象
      private DaoTransaction transaction;
      //通过构造器获取目标类和增强类对象
      public ProxyStudent(StudentServiceImpl studentService,DaoTransaction daoTransaction){
          this.studentService = studentService;
          this.transaction = daoTransaction;
      }
          
  
      public void save() {
          //开启事务操作
          transaction.before();
          //目标类的操作
          studentService.save();
          //关闭事务操作
          transaction.after();
      }
  
      public Student query(Long id) {
          return studentService.query(id);
      }
  }
  

• 测试代理类对象

  public class TestStudent {
  
      @Test
      public void testSave(){
          DaoTransaction transaction = new DaoTransaction();
          StudentServiceImpl studentService = new StudentServiceImpl();
          //获取代理类对象
          //包含了目标对象以及前置通知和后置通知
          ProxyStudent proxyStudent = new ProxyStudent(studentService, transaction);
          proxyStudent.save();
          proxyStudent.query(1L);
  
      }
  }
  

• 运行结果
  

2.2.3静态代理存在问题

• 不利于代码拓展，比如接口中新添加一个抽象方法时，所有实现类都需要重新实现，否则报错
• 代理对象需要创建很多，这种设计很不方便和麻烦

三、动态代理

3.1.概述

• 概述：在不改变原有功能代码的前提下，能够动态的实现方法的增强

3.2.JDK动态代理

3.2.1基础准备

• 创建 service 接口

  public interface IStudentService {
      /**
       * 添加学生
       */
      void save();
  
      /**
       * 查询学生信息
       * @param id
       * @return
       */
      Student query(Long id);
  }
  

• 创建service实现类(需要代理的类)

  public class StudentServiceImpl implements IStudentService {
      public void save() {
          System.out.println("保存学生信息");
      }
  
      public Student query(Long id) {
          System.out.println("查询操作");
          Student student = new Student();
          student.setName("sy");
          student.setAge(18);
          return student;
      }
  }
  

• 增强类

  public class DaoTransaction {
      public void before(){
          System.out.println("开启事务操作");
      }
  
      public void after(){
          System.out.println("关闭事务");
      }
  }
  

3.2.2实现InvocationHandler 接口

• InvocationHandler 接口，用来做方法拦截

• 实现接口

  public class TransactionHandler implements InvocationHandler {
      //增强类对象
      private DaoTransaction transaction;
      //需要代理的目标对象
      private Object obj;
      
      public TransactionHandler(DaoTransaction transaction,Object obj){
          this.transaction=transaction;
          this.obj=obj;
      }
      
      public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
          Object ret = null;
          
          //判断当前方法是否是save,是才做事务操作
          if("save".equals(method.getName())){
              transaction.before();
              ret = method.invoke(obj,args);
              transaction.after();
          }else{
              ret = method.invoke(obj,args);
          }
              
          
          return ret;
      }
  }
  

• 分别介绍里面的参数

  • Proxy:代理实例，可以通过newProxyInstance创建代理实例

    public static Object newProxyInstance(ClassLoader loader,
                                              Class<?>[] interfaces,
                                              InvocationHandler h)
    

    • ClassLoader 类加载器，直接通过需要代理的类获取就行
    • Class[]: 目标类所实现的所有接口
    • InvocationHandler：方法拦截处理器，可以在里面实现方法的增强

  • Method:执行目标方法的，invoke 方法执行

  • args:参数数组

3.2.3测试

• 方法

   @Test
      public void testSave(){
          //增强类对象
          DaoTransaction transaction = new DaoTransaction();
          //目标执行类
          IStudentService service = new StudentServiceImpl();
          //方法拦截处理器
          TransactionHandler handler = new TransactionHandler(transaction, service);
          //获取代理实例对象
          IStudentService proxyStudentService =(IStudentService) Proxy.newProxyInstance(StudentServiceImpl.class.getClassLoader(),
                  StudentServiceImpl.class.getInterfaces(), handler);
          proxyStudentService.save();
          Student query = proxyStudentService.query(1L);
  
      }
  

3.2.4底层运行原理

• 生成代理类的字节码来学习

  private void saveProxyClass(String path){
          byte[] $proxy1s = ProxyGenerator.generateProxyClass("$Proxy1",
                  StudentServiceImpl.class.getInterfaces());
          FileOutputStream out = null;
          try {
              out =  new FileOutputStream(new File(path + "$Proxy1.class"));
              out.write($proxy1s);
          } catch (Exception e) {
              e.printStackTrace();
          }finally {
              if(out !=null){
                  try {
                      out.flush();
                      out.close();
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
  
          }
  
      }
  

• 生成字节码反编译结果

  public final class $Proxy1 extends Proxy implements IStudentService {
      private static Method m1;
      private static Method m4;
      private static Method m2;
      private static Method m0;
      private static Method m3;
  
      public $Proxy1(InvocationHandler var1) throws  {
          super(var1);
      }
  
      public final boolean equals(Object var1) throws  {
          try {
              return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
              throw var3;
          } catch (Throwable var4) {
              throw new UndeclaredThrowableException(var4);
          }
      }
  
      public final Student query(Long var1) throws  {
          try {
              return (Student)super.h.invoke(this, m4, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
              throw var3;
          } catch (Throwable var4) {
              throw new UndeclaredThrowableException(var4);
          }
      }
  
      public final String toString() throws  {
          try {
              return (String)super.h.invoke(this, m2, (Object[])null);
          } catch (RuntimeException | Error var2) {
              throw var2;
          } catch (Throwable var3) {
              throw new UndeclaredThrowableException(var3);
          }
      }
  
      public final int hashCode() throws  {
          try {
              return (Integer)super.h.invoke(this, m0, (Object[])null);
          } catch (RuntimeException | Error var2) {
              throw var2;
          } catch (Throwable var3) {
              throw new UndeclaredThrowableException(var3);
          }
      }
  
      public final void save(Student var1) throws  {
          try {
              super.h.invoke(this, m3, new Object[]{var1});
          } catch (RuntimeException | Error var3) {
              throw var3;
          } catch (Throwable var4) {
              throw new UndeclaredThrowableException(var4);
          }
      }
  
      static {
          try {
              m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
              m4 = Class.forName("cn.sycoder.service.IStudentService").getMethod("query", Class.forName("java.lang.Long"));
              m2 = Class.forName("java.lang.Object").getMethod("toString");
              m0 = Class.forName("java.lang.Object").getMethod("hashCode");
              m3 = Class.forName("cn.sycoder.service.IStudentService").getMethod("save", Class.forName("cn.sycoder.domain.Student"));
          } catch (NoSuchMethodException var2) {
              throw new NoSuchMethodError(var2.getMessage());
          } catch (ClassNotFoundException var3) {
              throw new NoClassDefFoundError(var3.getMessage());
          }
      }
  }
  

• 执行原理图

• 文字说明：
  • 通过实现接口，获取到接口里面的所有方法
  • 通过Proxy 创建代理类实例
  • 通过反射机制，获取到一个个的方法对象
  • 调用InvocationHandler 接口中的invoke 方法，从而实现业务的增强

3.CGLIB动态代理

• JDK动态代理有一个前提，需要代理的类必须实现接口，如果没有实现接口，只能通过CGLIB来实现，其实就是对于JDK动态代理的一个补充

• 注意：

  • 类不能被 final 修饰

  • 方法不能被 final 修饰

    

3.1基础准备

• 导包

  <dependency>
      <groupId>cglib</groupId>
      <artifactId>cglib</artifactId>
      <version>2.2.2</version>
  </dependency>
  

• 准备需要代理目标类

  public class StudentServiceImpl implements IStudentService {
      public void save(Student student) {
          System.out.println("保存学生信息");
      }
  
      public Student query(Long id) {
          System.out.println("查询操作");
          Student student = new Student();
          student.setName("sy");
          student.setAge(18);
          return student;
      }
  }
  

  public interface IStudentService {
      /**
       * 添加学生
       */
      void save(Student student);
  
      /**
       * 查询学生信息
       * @param id
       * @return
       */
      Student query(Long id);
  }
  

3.2实现方法拦截MethodInterceptor

• 实现方法拦截

  public class CglibInterceptor implements MethodInterceptor {
  
      DaoTransaction transaction;
      public CglibInterceptor(DaoTransaction transaction){
          this.transaction = transaction;
      }
      
      public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
          //事务增强
          transaction.before();
          Object ret = methodProxy.invokeSuper(o, objects);
          //事务增强
          transaction.after();
          return ret;
      }
  }
  

3.3测试

• 测试代码

  @Test
      public void testSave() {
          //生成目标代理类
          System.setProperty(DebuggingClassWriter.DEBUG_LOCATION_PROPERTY,"F:\\03-Spring\\Design Mode\\proxy_pattern\\homework\\cglib-proxy-03\\src\\");
          //得到方法拦截器
          CglibInterceptor interceptor = new CglibInterceptor(new DaoTransaction());
          //使用CGLIB框架生成目标类的子类（代理类）实现增强
          Enhancer enhancer = new Enhancer();
          //设置父类字节码
          enhancer.setSuperclass(StudentServiceImpl.class);
          //设置拦截处理
          enhancer.setCallback(interceptor);
          IStudentService service = (IStudentService) enhancer.create();
          service.save(new Student());
  
      }
  

3.4底层运行原理

• 运行原理图
  
• 文字说明：
  • 通过继承的方式去获取到目标对象的方法
  • 通过传递方法拦截器 MethodInterceptor 实现方法拦截，在这里面做具体的增强
  • 调用生成的代理类对象具体执行重写的 save 方法，直接去调用方法拦截器里面的 intercept 方法
  • 前后加上了增强操作，从而实现了不修改目标代码实现业务增强

四、总结

代理类型	实现机制	回调方式	使用场景	效率
JDK动态代理	通过实现接口，通过反射机制获取到接口里面的方法，并且自定义InvocationHandler 接口，实现方法拦截	调用 invoke 方法实现增强	目标类有接口实现	1.8高于CGLIB
CGLIB动态代理	继承机制，通过继承重写目标方法，使用MethodInterceptor 调用父类的目标方法从而实现代理	调用interceptor方法	不能使用final修饰的类和方法	第一次调用生成字节码比较耗时间，多次调用性能还行