本文主要讲解内容如下：

  1. Spring的核心之一 - AOP思想

(1) 代理模式- 动态代理

① JDK的动态代理 （Java官方）

② CGLIB 第三方代理

AOP概述

什么是AOP(面向切面编程)

AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行时动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，进而提高开发效率。

传统Web开发模型: 纵向的编程

AOP思想和动态代理 - 图1

面向切面编程: 纵横配合的编程.

AOP思想和动态代理 - 图2

AOP思想和动态代理 - 图3

AOP的作用及优势

作用：在程序运行期间，不修改任何相关源码对已有方法进行增强。

优势：减少重复代码、提高开发效率、方便后期维护。

AOP的实现方式

使用动态代理模式来实现

可能通过上面的介绍，我们还是没有对AOP有一个清晰的认识。没关系，我们看看下面的具体应用。

案例中问题

通过下面的代码，我们能看出什么问题吗?

模拟事务管理器

  1. public class TransactionMangerHandler {
  3.     public void begin() {
  4.         System.out.println("开启事务");
  5.     }
  7.     public void commit() {
  8.         System.out.println("提交事务");
  9.     }
  11.     public void rollback() {
  12.         System.out.println("回滚事务");
  13.     }
  15.     public void closeSession() {
  16.         System.out.println("关闭session");
  17.     }
  18. }

Service层代码

  1. public class UserServiceImpl implements UserService {
  2.     // 引入事务管理器
  3.     private TransactionManagerHandler txManager = new TransactionManagerHandler();
  5.     @Override
  6.     public void insert() {
  7.         try {
  8.             txManager.begin();
  9.             System.out.println("调用dao层insert方法");
  10.             txManager.commit();
  11.         } catch (Exception e) {
  12.             txManager.rollback();
  13.         } finally {
  14.             txManager.close();
  15.         }
  16.     }
  18.     @Override
  19.     public void update() {
  20.         try {
  21.             txManager.begin();
  22.             System.out.println("调用dao层update方法");
  23.             txManager.commit();
  24.         } catch (Exception e) {
  25.             txManager.rollback();
  26.         } finally {
  27.             txManager.close();
  28.         }
  29.     }
  30. }

存在的问题

上面代码的问题就是：我们的事务控制的代码是重复性的。这还只是一个业务类，如果有多个业务类，每个业务类中都会有这些重复性的代码。是不是重复代码太多了？

通过传统方式来控制业务层的事务，那么会出现大量的冗余代码，例如开启事务、提交事务、事务回滚、关闭资源。这些冗余的代码，降低了开发效率，并且不利于代码后期的维护。我们可以借助AOP思想来集中管理冗余的代码。AOP可以理解为在业务方法的执行前后植入一些增强（事务开始、事务提交、事务回滚、资源关闭），到这里，AOP总的来说就是解决方法内部代码冗余的问题，并且在一定程度上使得方法内部的非业务逻辑代码和业务逻辑代码解耦，提高开发效率、质量的同时方便代码的后期维护！

解决上述问题的方案

  1. JDK的动态代理 - Java官方。
  2. CGLIB动态代理 -第三方组织开源。
  3. Spring的AOP技术(底层就是JDK动态代理和CGLIB代理技术)。

什么是动态代理技术？

Java中的动态代理，就是使用者使用的不是真实的对象，而是使用一个代理对象，而这个代理对象中包含的是真实的对象，代理对象的作用就是不改变原有对象的功能方法的基础之上封装新的功能。可以认为是真实对象的方法在代理对象的某一个制定好规则的方法中执行。如事务管理。

动态代理技术，可以使得业务逻辑代码和非业务逻辑代码相分离，提高了开发效率，控制事务的代码都已经在代理对象的方法中搭建好了，当需要调用真实对象的方法时，那么就会调用代理对象中已经搭建好框架的方法，只需将真实对象的方法植入到框架的指定位置，即可完成真实对象方法的访问。

JDK动态代理

JDK动态代理是Java官方的动态代理技术。

使用JDK官方的Proxy类创建代理对象：

  1. 需要通过Proxy类创建代理对象。
  2. 创建代理对象必须要有一个代理处理类（实现接口InvocationHandler的类）。

JDK动态代理API分析

1、java.lang.reflect.Proxy 类:
Java动态代理机制生成的所有动态代理类的父类，它提供了一组静态方法来为一组接口动态地生成代理类及其对象。

主要方法：

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

方法职责：为指定类加载器、一组接口及调用处理器生成动态代理类实例

参数:

  • loader: 类加载器
  • interfaces : 模拟的接口
  • hanlder: 代理执行处理器

返回：动态生成的代理对象

2、java.lang.reflect.InvocationHandler接口:

public Object invoke(Object proxy, Method method, Object[] args)

方法职责：负责集中处理动态代理类上的所有方法调用

参数:

  • proxy:生成的代理对象
  • method:当前调用的真实方法对象
  • args:当前调用方法的实参

返回: 真实方法的返回结果

3、JDK动态代理操作步骤：
①　实现InvocationHandler接口，创建增强代码处理器。
②　给Proxy类提供ClassLoader对象和代理接口类型数组，创建动态代理对象。
③　在处理器中实现增强操作。

案例代码

在我们的UserServiceImpl实现类中，使用JDK动态代理，进行方法的增强，增强事物的功能。

—UserService&UserServiceImpl

  1. public interface UserService {
  3.     void insert();
  5.     void update();
  6. }
  7. public class UserServiceImpl implements UserService {
  9.     @Override
  10.     public void insert() {
  11.         System.out.println("执行了service层的insert方法");
  12.     }
  14.     @Override
  15.     public void update() {
  16.         System.out.println("执行了service层的update方法");
  17.     }
  18. }

—JDK动态代理工具类

  1. /**
  2.  * 获取代理对象的工具类
  3.  * 增强功能：事务管理
  4.  */
  5. @Component
  6. public class DynamicProxyUtil {
  8.     // 模拟的事务管理器
  9.     @Autowired
  10.     private TransactionMangerHandler tx;
  12.     /**
  13.      *  根据类的字节码获取代理对象
  14.      * @param cls 被代理类的字节码
  15.      * @param <T> 被代理类的类型
  16.      * @return 代理对象
  17.      */
  18.     public <T> T getProxyObject(Class<T> cls) {
  19.         /*
  20.             Proxy类是JDK动态代理类
  21.             静态方法newProxyInstance用于创建类的代理对象dd
  22.          */
  23.         Object proxyObj = Proxy.newProxyInstance(cls.getClassLoader(),
  24.                 cls.getInterfaces(), new InvocationHandler() {
  25.                     @Override
  26.                     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  27.                         Object result = null; // 代理方法执行结果
  28.                         try {
  29.                             tx.begin(); // 开启事务
  30.                             result = method.invoke(cls.newInstance(), args); // 执行被代理方法
  31.                             tx.commit();  // 提交事务
  32.                         } catch (Exception e) {
  33.                             e.printStackTrace();
  34.                             tx.rollback(); // 回滚事务
  35.                         } finally{
  36.                             tx.closeSession(); // 关闭资源
  37.                         }
  38.                         return result; // 返回被代理方法的执行结果
  39.                     }
  40.                 });
  41.         return (T) proxyObj; // 返回代理对象
  42.     }
  43. }

—配置类

  1. @Configuration
  2. public class SpringConfig {
  4.     @Bean(name = "tx")
  5.     public TransactionMangerHandler getTransactionMangerHandler() {
  6.         return new TransactionMangerHandler();
  7.     }
  9.     @Bean(name = "dynamicProxyUtil")
  10.     public DynamicProxyUtil getDynamicProxyUtil() {
  11.         DynamicProxyUtil proxyUtil = new DynamicProxyUtil();
  12.         return proxyUtil;
  13.     }
  14. }

—测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = SpringConfig.class)
  3. public class DynamicProxyTest {
  5.     @Resource(name = "dynamicProxyUtil")
  6.     private DynamicProxyUtil proxyUtil;
  8.     @Test
  9.     public void testInsert() {
  10.         // 通过ProxyUtil工具类获取某个类的代理对象
  11.         UserService userService = proxyUtil.getProxyObject(UserServiceImpl.class);
  12.         userService.insert();
  13.     }
  15.     @Test
  16.     public void testUpdate() {
  17.         UserService userService = proxyUtil.getProxyObject(UserServiceImpl.class);
  18.         userService.update();
  19.     }

—测试结果

AOP思想和动态代理 - 图4

AOP思想和动态代理 - 图5

JDK动态代理的不足

  1. JDK动态代理的对象必须要实现接口，因为JDK动态代理是基于接口代理的。
  2. 需要为每个对象创建代理对象。
  3. 代理粒度大，动态代理的最小单位是类(所有类中的方法都会被处理)，但是查询方法不需要事务，因此不需要被代理。

更详细内容参考https://www.cnblogs.com/satire/p/14620634.html

CGLIB动态代理（第三方代理）

CGLIB(Code Generation Library)是一个开源项目。

CGLIB和JDK动态代理一样都是动态代理，但是CGLIB可以代理没有实现接口的类。

CGLIB代理没有实现接口的类时，程序在JVM运行过程中动态的为这个类创建一个子类，并重写父类方法，在调用父类方法时，在方法执行之前、之后、异常、最终做增强。

Spring默认已经集成CGLIB代理,直接可以使用即可,不用拷贝任何jar包。

案例代码

在我们的UserServiceImpl的实现类中，使用CGLIB的动态代理，进行方法的增强，增强事物的功能。

—UserServiceImpl2

  1. public class UserServiceImpl2 {
  3.     public void insert() {
  4.         System.out.println("执行了service层的insert方法");
  5.     }
  7.     public void update() {
  8.         System.out.println("执行了service层的update方法");
  9.     }
  10. }

—CGLIB代理工具类

  1. @Component("cglibProxyUtil")
  2. public class CglibProxyUtil {
  4.     @Autowired
  5.     @Qualifier("tx")
  6.     private TransactionMangerHandler tx;
  8.     /**
  9.      * 返回一个代理对象,代理对象就做了方法的增强,(事物管理,日志控制,权限管理等等)
  10.      * @param cls 被代理类的字节码
  11.      * @return
  12.      */
  13.     public <T> T getProxyObject(Class<T> cls) {
  15.         Enhancer enhancer = new Enhancer();
  16.         // 设置类加载器
  17.         enhancer.setClassLoader(cls.getClassLoader());
  18.         // 设置被代理类的字节码
  19.         enhancer.setSuperclass(cls);
  20.         // 设置功能增强
  21.         /**
  22.          * 代理类的增强方法,正常增强的地方
  23.          * @param proxy 代理对象
  24.          * @param method 被代理对象的方法
  25.          * @param args 被代理对象方法的参数
  26.          * @return  被代理对象执行的结果
  27.          * @throws Throwable
  28.          */
  29.         enhancer.setCallback(new InvocationHandler() {
  30.             @Override
  31.             public Object invoke(Object o, Method method, Object[] args) throws Throwable {
  32.                 Object result = null;
  33.                 try {
  34.                     tx.begin();
  35.                     result = method.invoke(cls.newInstance(), args);
  36.                     tx.commit();
  37.                 } catch (Exception e) {
  38.                     e.printStackTrace();
  39.                     tx.rollback();
  40.                 } finally {
  41.                     tx.closeSession();
  42.                 }
  43.                 return result;
  44.             }
  45.         });
  46.         // 创建代理对象
  47.         Object proxyObj = enhancer.create();
  48.         return (T) proxyObj;
  49.     }
  50. }

—配置类

  1. @Configuration
  2. public class SpringConfig {
  4.     @Bean(name = "tx")
  5.     public TransactionMangerHandler getTransactionMangerHandler() {
  6.         return new TransactionMangerHandler();
  7.     }
  9.     @Bean(name = "cglibProxyUtil")
  10.     public CglibProxyUtil getDynamicProxyUtil() {
  11.         CglibProxyUtil proxyUtil = new CglibProxyUtil();
  12.         return proxyUtil;
  13.     }
  14. }

—测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration(classes = SpringConfig.class)
  3. public class CglibProxyTest {
  5.     @Resource(name = "cglibProxyUtil")
  6.     private CglibProxyUtil proxyUtil;
  8.     @Test
  9.     public void testInsert() {
  10.         // 通过ProxyUtil工具类获取某个类的代理对象
  11.         UserServiceImpl2 proxyObj = proxyUtil.getProxyObject(UserServiceImpl2.class);
  12.         proxyObj.insert();
  13.     }
  15.     @Test
  16.     public void testUpdate() {
  17.         UserServiceImpl2 proxyObj = proxyUtil.getProxyObject(UserServiceImpl2.class);
  18.         proxyObj.update();
  19.     }
  20. }

—测试结果

AOP思想和动态代理 - 图6

AOP思想和动态代理 - 图7

CGLIB代理的不足

  1. CGLIB可以标类的子类，并重写父类非final修饰符的方法。
  2. 要求类不能是final的，要代理的方法要是非final、非static、非private的。
  3. 动态代理的最小单位是类(所有类中的方法都会被处理)。

小结

解决代码重复的方案

在Spring中：

  • 若目标对象实现了若干接口，Spring就会使用JDK动态代理。
  • 若目标对象没有实现任何接口，Spring就使用CGLIB动态代理。

直接使用代理的缺陷

如果直接使用动态代理技术（JDK代理、CGLIB代理）解决代码重复问题，我们会发现，我们每一个类都要配置代理类，非常的麻烦。

动态代理模式的缺陷是什么

动态代理模式的缺陷是：

  1. 实现类必须要实现接口 -JDK动态代理
  2. 无法通过规则制定拦截无需功能增强的方法。

如何解决这个问题？

使用Spring提供了AOP的实现。