论坛首页 Java企业应用论坛

我对AOP的理解

浏览 35243 次
该帖已经被评为精华帖
作者 正文
   发表时间:2012-04-04   最后修改:2012-04-05

1、问题 


问题:想要添加日志记录、性能监控、安全监测 

 

2、最初解决方案 

2.1、最初解决方案

缺点:太多重复代码,且紧耦合

 

2.2、抽象类进行共性设计,子类进行个性设计,此处不讲解,缺点一荣俱荣,一损俱损

 

2.3、使用装饰器模式/代理模式改进的解决方案

装饰器模式:动态地给一个对象添加一些额外的职责。就增加功能来说, 装饰器模式相比生成子类更为灵活。
代理模式:为其他对象提供一种代理以控制对这个对象的访问。


 
缺点:紧耦合,每个业务逻辑需要一个装饰器实现或代理

2.4、JDK动态代理解决方案(比较通用的解决方案) 
public class MyInvocationHandler implements InvocationHandler { 
    private Object target;
    public MyInvocationHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //1.记录日志    2.时间统计开始      3.安全检查
        Object retVal = method.invoke(target, args);
        //4.时间统计结束
        return retVal;   
    }
    public static Object proxy(Object target) {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                target.getClass().getInterfaces(), new MyInvocationHandler(target));
    }
}

 编程模型 

   //proxy     在其上调用方法的代理实例 
   //method 拦截的方法
   //args       拦截的参数
   Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        Object retVal=null;
        //预处理
        //前置条件判断
        boolean ok = true;        
        if(!ok) {//不满足条件
            throw new RuntimeException("你没有权限");
        }
        else {//反射调用目标对象的某个方法
            retVal = method.invoke(target, args);
        }
        //后处理
        return retVal;
    }
  

缺点:使用麻烦,不能代理类,只能代理接口  

 

CGLIB动态代理解决方案(比较通用的解决方案)
public class MyInterceptor implements MethodInterceptor  {	
    private Object target;
    public MyInterceptor(Object target) {
        this.target = target;
    }
    @Override
    public Object intercept(Object proxy, Method method, Object[] args, 
                                         MethodProxy invocation) throws Throwable {
        //1.记录日志 2.时间统计开始   3.安全检查
        Object retVal = invocation.invoke(target, args);
        //4.时间统计结束
        return retVal;   
    }
    public static Object proxy(Object target) {
        return Enhancer.create(target.getClass(), new MyInterceptor(target));
    }
}

 编程模型

 //proxy 在其上调用方法的代理实例    method拦截的方法    args  拦截的参数
 //invocation 用来去调用被代理对象方法的
@Override
public Object intercept(Object proxy, Method method, Object[] args, 
                                       MethodProxy invocation) throws Throwable {
    //预处理
    //前置条件判断
    boolean ok = true;        
    if(!ok) {//不满足条件
        throw new RuntimeException("出错了");
    }
    else {//调用目标对象的某个方法
        Object retVal = invocation.invoke(target, args);
    }
    //后处理
    return retVal;
}
优点:能代理接口和类
缺点:使用麻烦,不能代理final

 

动态代理本质 

本质:对目标对象增强
           最终表现为类(动态创建子类),看手工生成(子类)还是自动生成(子类)
代理限制:
           只能在父类方法被调用之前或之后进行增强(功能的修改),不能在中间进行修改,要想在方法调用中增强,需要ASM(java 字节码生成库)
其他动态代理框架
jbossjavassist hibernate 3.3中默认为javassist
                           hibernate 3.3之前中默认为cglib

 


 
2.5、AOP解决方案(通用且简单的解决方案)
@Aspect
public class PayEbiAspect {    
    @Pointcut(value="execution(* pay(..))")
    public void pointcut() {}
    @Around(value="pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        //1.记录日志
        //2.时间统计开始
        //3.安全检查
        Object retVal = pjp.proceed();//调用目标对象的真正方法
        //4.时间统计结束
        return retVal;
    }
}
编程模型
    //2 切入点
    @Pointcut(value="execution(* *(..))")
    public void pointcut() {}
    //3 拦截器的interceptor
    @Around(value="pointcut()")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object retVal=null;
        //预处理
        //前置条件判断
        boolean ok = true;
        if(!ok) {//不满足条件
           throw new RuntimeException("你没有权限");
        }
        else {//调用目标对象的某个方法
             retVal = pjp.proceed(); 
        }
        //后处理
        return retVal;
    }
 
缺点:依赖AOP框架 

AOP入门
概念:
n关注点:可以认为是所关注的任何东西,比如上边的支付组件;
n关注点分离:将问题细化为单独部分,即可以理解为不可再分割的组件,如上边的日志组件和支付组件;
n横切关注点:会在多个模块中出现,使用现有的编程方法,横切关注点会横越多个模块,结果是使系统难以设计、理解、实现和演进,如日志组件横切于支付组件。
织入:横切关注点分离后,需要通过某种技术将横切关注点融合到系统中从而完成需要的功能,因此需要织入,织入可能在编译期、加载期、运行期等进行。

nAOP是什么(Aspect   Oriented   Programming)
 AOP是一种编程范式,提供从另一个角度来考虑程序结构以完善面向对象编程(OOP)。
 AOP为开发者提供了一种描述横切关注点的机制,并能够自动将横切关注点织入到面向对象的软件系统中,从而实现了横切关注点的模块化。
 AOP能够将那些与业务无关,却为业务模块所共同调用的逻辑或责任,例如事务处理、日志管理、权限控制等,封装起来,便于减少系统的重复代码,降低模块间的耦合度,并有利于未来的可操作性和可维护性。
nAOP能干什么,也是AOP带来的好处
1:降低模块的耦合度
2:使系统容易扩展
3:设计决定的迟绑定:使用AOP,设计师可以推迟为将来的需求作决定,因为它
可以把这种需求作为独立的方面很容易的实现。
4:更好的代码复用性

 
AOP基本概念
 连接点(Joinpoint):
    表示需要在程序中插入横切关注点的扩展点,连接点可能是类初始化、方法执行、方法调用、字段调用或处理异常等等,Spring只支持方法执行连接点,AOP中表示在哪里做
切入点(Pointcut):
    选择一组相关连接点的模式,即可以认为连接点的集合,Spring支持perl5正则表达式和AspectJ切入点模式,Spring默认使用AspectJ语法,AOP中表示为在哪里做的集合
增强(Advice):或称为增强
    在连接点上执行的行为,增强提供了在AOP中需要在切入点所选择的连接点处进行扩展现有行为的手段;包括前置增强(before advice)、后置增强 (after advice)、环绕增强 (around advice),在Spring中通过代理模式实现AOP,并通过拦截器模式以环绕连接点的拦截器链织入增强 ;AOP中表示为做什么
方面/切面(Aspect):
      横切关注点的模块化,比如上边提到的日志组件。可以认为是增强、引入和切入点的组合;在Spring中可以使用Schema@AspectJ方式进行组织实现;AOP中表示为在哪里做和做什么集合
目标对象(Target Object):
    需要被织入横切关注点的对象,即该对象是切入点选择的对象,需要被增强的对象,从而也可称为被增强对象;由于Spring AOP 通过代理模式实现,从而这个对象永远是被代理对象,AOP中表示为对谁做
AOP代理(AOP Proxy):
    AOP框架使用代理模式创建的对象,从而实现在连接点处插入增强(即应用切面),就是通过代理来对目标对象应用切面。在Spring中,AOP代理可以用JDK动态代理或CGLIB代理实现,而通过拦截器模型应用切面。
织入(Weaving):
    织入是一个过程,是将切面应用到目标对象从而创建出AOP代理对象的过程,织入可以在编译期、类装载期、运行期进行。
引入(inter-type declaration):
    也称为内部类型声明,为已有的类添加额外新的字段或方法,Spring允许引入新的接口(必须对应一个实现)到所有被代理对象(目标对象), AOP中表示为做什么(新增什么)

AOP的Advice类型
前置增强(Before advice):
    在某连接点之前执行的增强,但这个增强不能阻止连接点前的执行(除非它抛出一个异常)。
后置返回增强(After returning advice):
    在某连接点正常完成后执行的增强:例如,一个方法没有抛出任何异常,正常返回。
后置异常增强(After throwing advice):
    在方法抛出异常退出时执行的增强。
后置最终增强(After (finally) advice):
    当某连接点退出的时候执行的增强(不论是正常返回还是异常退出)。
环绕增强Around Advice):
    包围一个连接点的增强,如方法调用。这是最强大的一种增强类型。 环绕增强可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。


 
AOP开发步骤
  类似于IoC/DI容器开发步骤,需要描述哪个连接点需要哪个通用功能(增强

横切关注点的表现有:  
  ·代码纠结/混乱——当一个模块或代码段同时管理多个关注点时发生这种情况。 
  ·代码分散——当一个关注点分布在许多模块中并且未能很好地局部化和模块化时发生这种情况 。
AOP包括三个清晰的开发步骤:
1功能横切:找出横切关注点。
2实现分离:各自独立的实现这些横切关注点所需要完成的功能。
3功能回贴:在这一步里,方面集成器通过创建一个模块单元—— 方面来指定重组的规则。重组过程——也叫织入或结合—— 则使用这些信息来构建最终系统。

推荐阅读书籍:
AspectJ in Action

AOSD中文版--基于用例的面向方面软件开发



推荐阅读的帖子:

 


文章主要是为了抛砖引玉,希望有更多牛人的指点。

  • 大小: 21.8 KB
  • 大小: 37.4 KB
  • 大小: 35.4 KB
  • 大小: 21.4 KB
  • 大小: 50.9 KB
  • 大小: 21.3 KB
  • 大小: 54 KB
   发表时间:2012-04-04  
aop不就是代理模式吗?spring很久没弄,但记得里面用的也是jdk和CGLib。
0 请登录后投票
   发表时间:2012-04-04  
从反编aspjectj的class来看,其实是增强了方法各种时间,比如调用,返回,执行中等时间点,你说他是代理吧,你操作的时候的对象还是你自己的类实例,而不是类似与$proxy34.update()这样的.所以,我觉得aop只是一种对原对象的增强方式.
0 请登录后投票
   发表时间:2012-04-04  
总结的不错,赞一个!
0 请登录后投票
   发表时间:2012-04-04  
kjj 写道
从反编aspjectj的class来看,其实是增强了方法各种时间,比如调用,返回,执行中等时间点,你说他是代理吧,你操作的时候的对象还是你自己的类实例,而不是类似与$proxy34.update()这样的.所以,我觉得aop只是一种对原对象的增强方式.


这个倒是,对于aspectj可以增强类的如成员变量、构造器、方法调用、执行等等。
因为aspectj要通过修改字节码来实现,因此我也觉得“增强”这个概念更适合点。
0 请登录后投票
   发表时间:2012-04-04   最后修改:2012-04-04
hyj1254 写道
aop不就是代理模式吗?spring很久没弄,但记得里面用的也是jdk和CGLib。


aop不是代理。aop是一种编程范式,类似于oop
0 请登录后投票
   发表时间:2012-04-04  
LZ搞培训的?
0 请登录后投票
   发表时间:2012-04-05   最后修改:2012-04-05
咦?感觉和我记忆中的一些内容有冲突。

我记忆中,jdk的代理,其实是继承了你的被通知bean。然后在你的方法上做切入。
因为我清楚的记得,当时书上说,final 修饰的方法不能被通知。
所以只能代理类,不能代理接口。
你的第一个jdk代理的的代码是自己总结的还是别的地方看到的?

cglib是能代理接口代理类。

之前没有想到源码层那么深。对于你给的例子不知道怎么判断。
0 请登录后投票
   发表时间:2012-04-05  
leonayx123 写道
咦?感觉和我记忆中的一些内容有冲突。

我记忆中,jdk的代理,其实是继承了你的被通知bean。然后在你的方法上做切入。
因为我清楚的记得,当时书上说,final 修饰的方法不能被通知。
所以只能代理类,不能代理接口。
你的第一个jdk代理的的代码是自己总结的还是别的地方看到的?

cglib是能代理接口代理类。

之前没有想到源码层那么深。对于你给的例子不知道怎么判断。


jdk动态代理只能代理接口,cglib可以代理接口和类。
final的类不能被代理,final的方法不能被通知(无法覆盖)。
0 请登录后投票
   发表时间:2012-04-05  
selvemen 写道
学习了,谢谢

谢谢支持
0 请登录后投票
论坛首页 Java企业应用版

跳转论坛:
Global site tag (gtag.js) - Google Analytics