![KGFQCS8KLS02N2YVB]N~)KM.jpg](https://ucc.alicdn.com/pic/developer-ecology/36dea9df91e74246af369d4188f4f494.jpg?x-oss-process=image/resize,w_1400/format,webp "KGFQCS8KLS02N2YVB]N~)KM.jpg")
主要讲解AOP的实现姿势，包括AspectJ和Spring，以及自己对AOP内部实现的理解。
前言
看这篇文章前，请大家先看《【Spring基础系列5】Spring AOP基础（上）》，因为这两篇文章是自成体系，对于Spring AOP的基础知识，本来打算只写一篇，因为担心大家不愿意看长文，就拆成了上-下两篇文章。
Java中的AOP主要有4种实现方式，对于AspectJ基于XML的声明式，上一篇文章已经给出非常详细的示例，这篇文章主要针对AspectJ基于Annotation的声明式、基于Spring的JDK动态代理和CGLib动态代理这3种AOP实现方式进行讲解。
这篇文章也是Spring系列的最后一篇，前后花了近2周的时间总结的成果，如果想学习Spring的同学，建议从第一篇文章开始看：
- 《【Spring基础系列1】基于注解装配Bean》
- 《【Spring基础系列2】很全的Spring IOC基础知识》
- 《【Spring基础系列3】Spring常用的注解》
- 《【Spring基础系列4】注解@Transactional》
- 《【Spring基础系列5】Spring AOP基础（上）》
- 《【Spring基础系列5】Spring AOP基础（下）》
Spring AOP
Spring JDK动态代理
JDK 动态代理是通过 JDK 中的 java.lang.reflect.Proxy 类实现的。下面通过具体的案例演示 JDK 动态代理的使用，我们先新建一个接口，并给出具体实现类：
public interface CustomerDao { public void add(); // 添加 public void update(); // 修改 public void delete(); // 删除 public void find(); // 查询 }
public class CustomerDaoImpl implements CustomerDao { @Override public void add() { System.out.println("添加客户..."); } @Override public void update() { System.out.println("修改客户..."); } @Override public void delete() { System.out.println("删除客户..."); } @Override public void find() { System.out.println("修改客户..."); } }
新建一个切面类:
public class MyAspect { public void myBefore() { System.out.println("方法执行之前"); } public void myAfter() { System.out.println("方法执行之后"); } }
再新建一个通过代理实现的工厂类：
public class MyBeanFactory { public static CustomerDao getBean() { // 准备目标类 final CustomerDao customerDao = new CustomerDaoImpl(); // 创建切面类实例 final MyAspect myAspect = new MyAspect(); // 使用代理类，进行增强 return (CustomerDao) Proxy.newProxyInstance( // MyBeanFactory.class.getClassLoader(), // 这个也可以 CustomerDao.class.getClassLoader(), new Class[] { CustomerDao.class }, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { myAspect.myBefore(); // 前增强 Object obj = method.invoke(customerDao, args); myAspect.myAfter(); // 后增强 return obj; } }); } }
我使用MyBeanFactory.class.getClassLoader()，发现也不影响功能，后面有空再研究一下。
最后是测试示例：
public class JDKProxyTest { @Test public void test() { // 从工厂获得指定的内容（相当于spring获得，但此内容时代理对象） CustomerDao customerDao = MyBeanFactory.getBean(); // 执行方法 customerDao.add(); customerDao.update(); //customerDao.delete(); //customerDao.find(); } } // 输出： // 方法执行之前 // 添加客户... // 方法执行之后 // 方法执行之前 // 修改客户... // 方法执行之后
从输出结果中可以看出，在调用目标类的方法前后，成功调用了增强的代码，由此说明，JDK 动态代理已经实现。
Spring CGLlB动态代理
JDK 动态代理使用起来非常简单，但是它也有一定的局限性，这是因为 JDK 动态代理必须要实现一个或多个接口，如果不希望实现接口，则可以使用 CGLIB 代理。
CGLIB（Code Generation Library）是一个高性能开源的代码生成包，它被许多 AOP 框架所使用，其底层是通过使用一个小而快的字节码处理框架 ASM（Java 字节码操控框架）转换字节码并生成新的类，因此 CGLIB 要依赖于 ASM 的包。
下面看一下CGLlB动态代理的实现姿势，先定义一个实现类：
public class GoodsDao { public void add() { System.out.println("添加商品..."); } public void update() { System.out.println("修改商品..."); } public void delete() { System.out.println("删除商品..."); } public void find() { System.out.println("修改商品..."); } }
新建一个切面类:
public class MyAspect { public void myBefore() { System.out.println("方法执行之前"); } public void myAfter() { System.out.println("方法执行之后"); } }
再新建一个通过代理实现工厂类：
public class MyBeanFactory { public static GoodsDao getBean() { // 准备目标类 final GoodsDao goodsDao = new GoodsDao(); // 创建切面类实例 final MyAspect myAspect = new MyAspect(); // 生成代理类，CGLIB在运行时，生成指定对象的子类，增强 Enhancer enhancer = new Enhancer(); // 确定需要增强的类 enhancer.setSuperclass(goodsDao.getClass()); // 添加回调函数 enhancer.setCallback(new MethodInterceptor() { // intercept 相当于 jdk invoke，前三个参数与 jdk invoke—致 @Override public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { myAspect.myBefore(); // 前增强 Object obj = method.invoke(goodsDao, args); // 目标方法执行 myAspect.myAfter(); // 后增强 return obj; } }); // 创建代理类 GoodsDao goodsDaoProxy = (GoodsDao) enhancer.create(); return goodsDaoProxy; } }
最后是测试示例：
public class JDKProxyTest { @Test public void test() { // 从工厂获得指定的内容（相当于spring获得，但此内容时代理对象） GoodsDao goodsDao = MyBeanFactory.getBean(); // 执行方法 goodsDao.add(); goodsDao.update(); // goodsDao.delete(); // goodsDao.find(); } } // 输出： // 方法执行之前 // 添加商品... // 方法执行之后 // 方法执行之前 // 修改商品... // 方法执行之后
从输出结果中可以看出，在调用目标类的方法前后，也成功调用了增强的代码，由此说明，使用 CGLIB 代理的方式同样实现了手动代理。
两者比较
可以直接参考文章《【Spring基础系列5】Spring AOP基础（上）》，再盗用上一篇文章的图，回顾一下：
重点：JDK动态代理是基于接口，CGLIB动态代理是基于类，上面的示例也能看出两者的区别，如果你在CGLIB代理的示例用接口替换，肯定会报错的。
使用ProxyFactoryBean创建AOP代理
这种方式我没有在项目中遇到过，仅作为扩展知识了解即可。
基础知识
上述已经讲解了 AOP 手动代理的两种方式，下面介绍 Spring 是如何创建 AOP 代理的。Spring 创建一个 AOP 代理的基本方法是使用 org.springframework.aop.framework.ProxyFactoryBean，这个类对应的切入点和通知提供了完整的控制能力，并可以生成指定的内容。
ProxyFactoryBean 类中的常用可配置属性如表所示：
具体实例
我们还是先定义一个接口和一个实现类，CustomerDao、CustomerDaoImpl同“Spring JDK动态代理“示例内容一样，只是需要对CustomerDaoImpl加上注解@Component("customerDao")，主要是为了减少配置。
@Component("customerDao") public class CustomerDaoImpl implements CustomerDao { // 方法同“Spring JDK动态代理“示例内容 }
然后定义一个切面类：
@Component public class MyAspect implements MethodInterceptor { public Object invoke(MethodInvocation mi) throws Throwable { System.out.println("方法执行之前"); Object obj = mi.proceed(); System.out.println("方法执行之后"); return obj; } }
下面这个非常重要，就是在applicationContext.xml文件中增加相应配置：
<context:component-scan base-package="com.java.spring.aop.xml" /> <!--生成代理对象 --> <bean id="customerDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean"> <!--代理实现的接口 --> <property name="proxyInterfaces" value="com.java.spring.aop.xml.CustomerDao" /> <!--代理的目标对象 --> <property name="target" ref="customerDao" /> <!--用通知增强目标 --> <property name="interceptorNames" value="myAspect" /> <!-- 如何生成代理，true:使用cglib; false :使用jdk动态代理 --> <property name="proxyTargetClass" value="true" /> </bean>
最后看一下测试用例：
public class FactoryBeanTest { @Test public void test() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); CustomerDao customerDao = (CustomerDao) applicationContext.getBean("customerDaoProxy"); customerDao.add(); customerDao.update(); // customerDao.delete(); // customerDao.find(); } } // 输出： // 方法执行之前 // 添加客户... // 方法执行之后 // 方法执行之前 // 修改客户... // 方法执行之后
这个和“Spring JDK动态代理”、“Spring CGLlB动态代理”的区别在于，前两者是手动方式，这个是自动方式，然后结合了“通知的分类”（可以参考《【Spring基础系列5】Spring AOP基础（上）》）。
AspectJ AOP
AspectJ 基于XML方式
直接参考文章《【Spring基础系列5】Spring AOP基础（上）》中的示例。
AspectJ 基于Annotation方式
基础知识
在 Spring 中，尽管使用 XML 配置文件可以实现 AOP 开发，但是如果所有的相关的配置都集中在配置文件中，势必会导致 XML 配置文件过于臃肿，从而给维护和升级带来一定的困难。
为此，AspectJ 框架为 AOP 开发提供了另一种开发方式——基于 Annotation 的声明式。AspectJ 允许使用注解定义切面、切入点和增强处理，而 Spring 框架则可以识别并根据这些注解生成 AOP 代理。关于 Annotation 注解的介绍如表所示：
具体实例
先定义一个具体的实现类：
@Component("customerDao") public class CustomerDaoImpl { public void add() throws Exception { System.out.println("添加客户..."); //throw new Exception("抛出异常测试"); } public void update() { System.out.println("修改客户..."); } public void delete() { System.out.println("删除客户..."); } public void find() { System.out.println("修改客户..."); } }
然后定义一个切面类：
@Aspect @Component public class MyAspect { // 用于取代：<aop:pointcut expression="execution(* com.java.spring.aop.customer.*.*(..))" id="myPointCut"/> @Pointcut("execution(* com.java.spring.aop.customer.*.*(..))") private void myPointCut() { } // 前置通知 @Before("myPointCut()") public void myBefore(JoinPoint joinPoint) { System.out.println("前置通知，方法名称:" + joinPoint.getSignature().getName()); } // 后置通知 @AfterReturning(value = "myPointCut()") public void myAfterReturning(JoinPoint joinPoint) { System.out.println("后置通知，方法名称：" + joinPoint.getSignature().getName()); } // 环绕通知 @Around("myPointCut()") public Object myAround(ProceedingJoinPoint proceedingJoinPoint) throws Throwable { System.out.println("环绕开始"); // 开始 Object obj = proceedingJoinPoint.proceed(); // 执行当前目标方法 System.out.println("环绕结束"); // 结束 return obj; } // 异常通知 @AfterThrowing(value = "myPointCut()", throwing = "e") public void myAfterThrowing(JoinPoint joinPoint, Throwable e) { System.out.println("异常通知，出错了"); } // 最终通知 @After("myPointCut()") public void myAfter() { System.out.println("最终通知"); } }
这里和“AspectJ 基于XML方式”一样，需要在applicationContext.xml文件中增加相应配置：
<context:component-scan base-package="com.java.spring.aop.customer" /> <context:component-scan base-package="com.java.spring.aop.annotation" /> <aop:aspectj-autoproxy proxy-target-class="true"/>
前面两行是自动注入注解的包，第三行是需要开启AOP，下面是测试用例：
public class AnnotationTest { @Test public void test() throws Exception { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); // 从spring容器获取实例 CustomerDaoImpl customerDao = (CustomerDaoImpl) applicationContext.getBean("customerDao"); // 执行方法 customerDao.add(); } } // 输出： // 环绕开始 // 前置通知，方法名称:add // 添加客户... // 环绕结束 // 最终通知 // 后置通知，方法名称：add
AOP实现方式探讨
开始看“Spring JDK动态代理”的示例时，感觉这个示例非常熟悉，大家可以看看《【设计模式系列6】代理模式》这篇文章，其实就是通过代理模式进行前后增强，唯一的区别是“Spring JDK动态代理”中对代理的对象封装成一个工厂，所以是工厂模式 + 代理模式，感觉也没啥技术含量。
但是看到“AspectJ 基于XML方式”示例时，我们回顾一下它的测试用例：
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml"); CustomerDaoImpl customerDao = (CustomerDaoImpl) applicationContext.getBean("customerDao"); // 执行方法 customerDao.add();
大家有没有发现疑问，我们直接获取customerDao这个Bean，调用里面的add()方法，就能实现增强，这个是怎么实现的呢。我理解通过Spring拿到customerDao这个Bean，其实不是customerDao本身，而是customerDao的装饰类M，也就是这个装设类M对customerDao的方法进行了修饰，怎么修饰呢？就是通过切面方法进行修饰！
上面听得可能有点蒙，大家可以看文章《【设计模式系列7】装饰器模式》，我还是直接盗用里面的图：
这里实体类是Chicken，装饰器是RoastFood，如果没有装饰器，调用cook()输出的是“鸡肉”，加上RoastFood装饰器修饰之后，调用cook()输出的是“烤鸡肉”，那么这个“烤”就是对“鸡肉”的装饰。
同理，CustomerDaoImpl对比Chicken，MyAspect对比“烤”，最后通过装饰器装饰后，将MyAspect中的方法装饰到CustomerDaoImpl中（《【设计模式系列7】装饰器模式》只在装饰类中定义了“烤”这个方法，你可以单独封装一个类N，里面封装一个“烤”方法，那么这个类N就可以对比为MyAspect）。
再回到我们上面的那个测试用例，应该就不难理解了，Spring先拿到CustomerDaoImpl类，这个类其实是通过MyAspect进行装饰，所以拿到的不是CustomerDaoImpl类本身，而是它的装饰器，最后将这个装饰器转成CustomerDaoImpl，至于为什么能转，是因为CustomerDaoImpl类和装饰器共同继承了CustomerDao接口。
总结：对于Spirng AOP，获取到的实体类其实不是实体类本身，而是这个实体类的装饰器，这个装饰器里应该是将实体类作为了装饰器的成员变量，然后通过切面MyAspect的方法进行增强，这里其实就是用到了装饰器模式。这个装饰器的获取，是通过工厂的封装，然后装饰器中实体类方法的调用，应该是采用的代理模式，所以Spirng AOP至少用到了装饰器、代理模式和工厂模式，然后完成整个功能的封装。
这个总结，仅是一家之言，可能有点天马行空，毕竟没有看AOP相关的源码和原理相关的文章，如果不是这样去设计AOP，那还有哪些其它的方法呢？目前我没有想到其它方式，如果文中有理解不对的地方，或者只是自己“一厢情愿”的话，欢迎大家给我指出！
后记
这篇文章就不写总结了，因为关于Spring AOP基础知识，我应该讲的还是比较详细，脉络也很清晰，就写点水文吧。
学习Spring相关的知识，总共学了10天，总结了6篇文章，虽然中间有几天状态不佳，但是整体学习的进度，我感觉还是不错的。下个系列我打算学习MyBatis，如果按照这个进度，MyBatis应该可以在6.20学习完毕。
学了Java也有一段时间，我也想说说我对Java的看法，我觉得Java真的就是一个工具，我学习Java的并发编程、Spring，感觉没有学到任何有关技术方面的东西，甚至可以说，学的东西和技术完全不靠边！学习Java语言生态的过程，其实就是学习Java的这一堆工具怎么使用，然后就没了，如果真说还学到其它什么知识，那可能就是编程的思想吧，因为Java的这些工具，用到了大量的设计模式，封装的功能确实非常通用，但是这个我其实只需要掌握到一定程度就够了，后面我还是需要在技术上深挖。
可能有同学会说，我学的还不够，是的，我也是刚开始学习Java，等我把MyBatis、SpringCloud、Dubbo等都学完了，那又能怎么样了，估计还是一堆工具。
不过话说话来，既然要去学习Java，这些工具我还是必须要掌握，不过等这堆工具我掌握到差不多的时候，我就不会再在上面花时间了，还是汲取些更优营养的知识，我才能更快成长。
