我对AOP的理解

 

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 字节码生成库)

其他动态代理框架

jboss：javassist （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容器开发步骤，需要描述哪个连接点需要哪个通用功能（增强）

  参考：http://www.iteye.com/topic/1122310

 

 

 

横切关注点的表现有：　　
　　·代码纠结/混乱——当一个模块或代码段同时管理多个关注点时发生这种情况。如我既要实现业务、还要实现安全和事务。即有些关注点同时被多个不同的模块实现。实现了重复的功能。
　　·代码分散——当一个关注点分布在许多模块中并且未能很好地局部化和模块化时发生这种情况 。如许多模块调用用户是否登录验证代码。调用了重复的功能。

 

 

 

AOP包括三个清晰的开发步骤：

1：功能横切：找出横切关注点。

2：实现分离：各自独立的实现这些横切关注点所需要完成的功能。

3：功能回贴：在这一步里，方面集成器通过创建一个模块单元—— 方面来指定重组的规则。重组过程——也叫织入或结合—— 则使用这些信息来构建最终系统。

 

推荐阅读书籍：

AspectJ in Action

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

 

 

推荐阅读的帖子：

AOP的实现机制

 

 

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

评论

12 楼 wangzhen199009 2015-08-11  

不明觉厉 

11 楼 879913935 2015-03-10  

我说个场景哈，现在比如要弄个类似百度贴吧或者论坛之类的东西，有很多操作都会增加积分，比如发帖，回复，这些操作加积分的逻辑其实算是公用的东西，那我要是通过拦截器来加，怎么弄呢？事务感觉不是一个啊，我的事务是在service这层，拦截器拦截哪个哈？怎么样写这个拦截器才能保证我积分操作完了，对应的操作执行在一个事务里，不知道说的清楚吗

10 楼 564435224 2014-10-08  

牛人啊。。。。。。。。。。。。。。。！

9 楼 337240552 2012-11-23  

aop这些概念比较抽象 但是楼主讲的比较清晰 对着图就好理解很多

8 楼 wuhuajun 2012-11-09  

Long_yuan 写道

您好，感谢你的精彩讲解。怎么实现日志记录和安全检查啊？有点不明白

直接通过表达式 找切入点感觉不太好 如果通过配合注解方式就比较好 那边想增强 直接加个注解就行了  虽然比表达式方式多写了点

7 楼 Long_yuan 2012-09-02  

您好，感谢你的精彩讲解。怎么实现日志记录和安全检查啊？有点不明白

6 楼 jinnianshilongnian 2012-07-27  

a114d 写道

强大

谢谢啊

5 楼 a114d 2012-07-27  

强大

4 楼 jinnianshilongnian 2012-07-20  

nicegege 写道

  

谢谢

3 楼 nicegege 2012-07-20  

  

2 楼 jinnianshilongnian 2012-07-16  

azhen1986 写道

牛人啊....

谢谢

1 楼 azhen1986 2012-07-16  

牛人啊....