技术控

    今日:2| 主题:49347
收藏本版 (1)
最新软件应用技术尽在掌握

[其他] Spring AOP的实现原理

[复制链接]
我宣你 发表于 2016-10-1 02:59:19
58 1

立即注册CoLaBug.com会员,免费获得投稿人的专业资料,享用更多功能,玩转个人品牌!

您需要 登录 才可以下载或查看,没有帐号?立即注册

x
AOP(Aspect Orient Programming),我们一般称为面向方面(切面)编程,作为面向对象的一种补充,用于处理系统中分布于各个模块的横切关注点,比如事务管理、日志、缓存等等。AOP实现的关键在于AOP框架自动创建的AOP代理,AOP代理主要分为静态代理和动态代理,静态代理的代表为AspectJ;而动态代理则以Spring AOP为代表。本文会分别对AspectJ和Spring AOP的实现进行分析和介绍。
  使用AspectJ的编译时增强实现AOP

  之前提到,AspectJ是静态代理的增强,所谓的静态代理就是AOP框架会在编译阶段生成AOP代理类,因此也称为编译时增强。
  举个实例的例子来说。首先我们有一个普通的    Hello类  
  1. public class Hello {
  2.     public void sayHello() {
  3.         System.out.println("hello");
  4.     }
  5.     public static void main(String[] args) {
  6.         Hello h = new Hello();
  7.         h.sayHello();
  8.     }
  9. }
复制代码
使用AspectJ编写一个Aspect
  1. public aspect TxAspect {
  2.     void around():call(void Hello.sayHello()){
  3.         System.out.println("开始事务 ...");
  4.         proceed();
  5.         System.out.println("事务结束 ...");
  6.     }
  7. }
复制代码
这里模拟了一个事务的场景,类似于Spring的声明式事务。使用AspectJ的编译器编译
  1. ajc -d . Hello.java TxAspect.aj
复制代码
编译完成之后再运行这个    Hello类,可以看到以下输出  
  1. 开始事务 ...
  2. hello
  3. 事务结束 ...
复制代码
显然,AOP已经生效了,那么究竟AspectJ是如何在没有修改Hello类的情况下为Hello类增加新功能的呢?
  查看一下编译后的    Hello.class  
  1. public class Hello {
  2.     public Hello() {
  3.     }
  4.     public void sayHello() {
  5.         System.out.println("hello");
  6.     }
  7.     public static void main(String[] args) {
  8.         Hello h = new Hello();
  9.         sayHello_aroundBody1$advice(h, TxAspect.aspectOf(), (AroundClosure)null);
  10.     }
  11. }
复制代码
   可以看到,这个类比原来的      Hello.java多了一些代码,这就是AspectJ的静态代理,它会在编译阶段将Aspect织入Java字节码中,   
    运行的时候就是经过增强之后的AOP对象。
   
  1. public void ajc$around$com_listenzhangbin_aop_TxAspect$1$f54fe983(AroundClosure ajc$aroundClosure) {
  2.         System.out.println("开始事务 ...");
  3.         ajc$around$com_listenzhangbin_aop_TxAspect$1$f54fe983proceed(ajc$aroundClosure);
  4.         System.out.println("事务结束 ...");
  5.     }
复制代码
从Aspect编译后的class文件可以更明显的看出执行的逻辑。    proceed方法就是回调执行被代理类中的方法。  
  使用Spring AOP

  与AspectJ的静态代理不同,Spring AOP使用的动态代理,所谓的动态代理就是说AOP框架不会去修改字节码,而是在内存中临时为方法生成一个AOP对象,这个AOP对象包含了目标对象的全部方法,并且在特定的切点做了增强处理,并回调原对象的方法。
  Spring AOP中的动态代理主要有两种方式,JDK动态代理和CGLIB动态代理。JDK动态代理通过反射来接收被代理的类,并且要求被代理的类必须实现一个接口。JDK动态代理的核心是    InvocationHandler接口和    Proxy类。  
  如果目标类没有实现接口,那么Spring AOP会选择使用CGLIB来动态代理目标类。CGLIB(Code Generation Library),是一个代码生成的类库,可以在运行时动态的生成某个类的子类,注意,CGLIB是通过继承的方式做的动态代理,因此如果某个类被标记为    final,那么它是无法使用CGLIB做动态代理的。  
  为了验证以上的说法,可以做一个简单的测试。首先测试实现接口的情况。
  定义一个接口
  1. public interface Person {
  2.     String sayHello(String name);
  3. }
复制代码
实现类
  1. @Component
  2. public class Chinese implements Person {
  3.     @Timer
  4.     @Override
  5.     public String sayHello(String name) {
  6.         System.out.println("-- sayHello() --");
  7.         return name + " hello, AOP";
  8.     }
  9.     public void eat(String food) {
  10.         System.out.println("我正在吃:" + food);
  11.     }
  12. }
复制代码
这里的    @Timer注解是我自己定义的一个普通注解,用来标记Pointcut。  
  定义Aspect
  1. @Aspect
  2. @Component
  3. public class AdviceTest {
  4.     @Pointcut("@annotation(com.listenzhangbin.aop.Timer)")
  5.     public void pointcut() {
  6.     }
  7.     @Before("pointcut()")
  8.     public void before() {
  9.         System.out.println("before");
  10.     }
  11. }
复制代码
运行
  1. @SpringBootApplication
  2. @RestController
  3. public class SpringBootDemoApplication {
  4.     //这里必须使用Person接口做注入
  5.     @Autowired
  6.     private Person chinese;
  7.     @RequestMapping("/test")
  8.     public void test() {
  9.         chinese.sayHello("listen");
  10.         System.out.println(chinese.getClass());
  11.     }
  12.     public static void main(String[] args) {
  13.         SpringApplication.run(SpringBootDemoApplication.class, args);
  14.     }
  15. }
复制代码
输出
  1. public aspect TxAspect {
  2.     void around():call(void Hello.sayHello()){
  3.         System.out.println("开始事务 ...");
  4.         proceed();
  5.         System.out.println("事务结束 ...");
  6.     }
  7. }0
复制代码
可以看到类型是    com.sun.proxy.$Proxy53,也就是前面提到的Proxy类,因此这里Spring AOP使用了JDK的动态代理。  
  再来看看不实现接口的情况,修改    Chinese类  
  1. public aspect TxAspect {
  2.     void around():call(void Hello.sayHello()){
  3.         System.out.println("开始事务 ...");
  4.         proceed();
  5.         System.out.println("事务结束 ...");
  6.     }
  7. }1
复制代码
运行
  1. public aspect TxAspect {
  2.     void around():call(void Hello.sayHello()){
  3.         System.out.println("开始事务 ...");
  4.         proceed();
  5.         System.out.println("事务结束 ...");
  6.     }
  7. }2
复制代码
输出
  1. public aspect TxAspect {
  2.     void around():call(void Hello.sayHello()){
  3.         System.out.println("开始事务 ...");
  4.         proceed();
  5.         System.out.println("事务结束 ...");
  6.     }
  7. }3
复制代码
可以看到类被CGLIB增强了,也就是动态代理。这里的CGLIB代理就是Spring AOP的代理,这个类也就是所谓的AOP代理,AOP代理类在切点动态地织入了增强处理。
  小结

  AspectJ在编译时就增强了目标对象,Spring AOP的动态代理则是在每次运行时动态的增强,生成AOP代理对象,区别在于生成AOP代理对象的时机不同,相对来说AspectJ的静态代理方式具有更好的性能,但是AspectJ需要特定的编译器进行处理,而Spring AOP则无需特定的编译器处理。
  参考:

          《Spring AOP 实现原理与 CGLIB 应用》   
          《Spring 容器AOP的实现原理——动态代理》   
          《AOP的底层实现-CGLIB动态代理和JDK动态代理》
友荐云推荐




上一篇:Create a Simple 'Hello World' App With Meteor and Apollo
下一篇:Guide to Excel VLOOKUP basics and top five rookie mistakes
酷辣虫提示酷辣虫禁止发表任何与中华人民共和国法律有抵触的内容!所有内容由用户发布,并不代表酷辣虫的观点,酷辣虫无法对用户发布内容真实性提供任何的保证,请自行验证并承担风险与后果。如您有版权、违规等问题,请通过"联系我们"或"违规举报"告知我们处理。

日耳曼 发表于 2016-10-9 10:51:16
好帖必须得顶起
回复 支持 反对

使用道具 举报

*滑动验证:
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

我要投稿

推荐阅读

扫码访问 @iTTTTT瑞翔 的微博
回页顶回复上一篇下一篇回列表手机版
手机版/CoLaBug.com ( 粤ICP备05003221号 | 文网文[2010]257号 )|网站地图 酷辣虫

© 2001-2016 Comsenz Inc. Design: Dean. DiscuzFans.

返回顶部 返回列表