Spring中AOP的实现原理

AOP（Aspect-Oriented Programming，面向方面编程），对 OOP（Object-Oriented Programming，面向对象编程）

• 【OOP与AOP】
  • 概念
    • AOP（Aspect-Oriented Programming，面向方面编程）
    • OOP（Object-Oriented Programming，面向对象编程）
  • 方向
    • OOP 定义从上到下的关系
    • AOP 定义从左到右的关系
• 【两个部分】
  • 核心关注点
    • 业务处理的主要流程
  • 横切关注点
    • 与业务主要流程关系不大的部分
    • 经常发生在核心关注点的多处，而各处都是基本相似的功能
    • 如权限认证、日志、事务处理

二、AOP 使用场景

1、AOP框架种类

• AspectJ
• JBoss AOP
• Spring AOP

2、使用 AOP 场景

• 性能监控：在方法调用前后记录调用事件，方法执行太长或超时报警。
• 缓存代理：缓存某方法的返回值，下次执行该方法时，直接从缓存里获取。
• 软件破解：使用AOP修改软件的验证类的判断逻辑。
• 记录日志：在方法执行前后记录系统日志。
• 工作流系统：工作流系统需要将业务代码和流畅引擎代码混合在一起执行，那么可以使用 AOP 将其分离，并动态挂载业务。
• 权限验证：方法执行前验证是否有权限执行当前方法，没有则抛出没有权限执行异常，由业务代码捕获。

3、传统编码与AOP区别

三、核心概念

【术语】：

• 切面（Aspect）：
  一个关注点的模块化，这个关注点可能会横切多个对象。
  事务管理是 J2EE 应用中一个关于横切关注点的很好列子。
  在 Spring AOP 中，切面可以使用基于模式或者基于 @Aspect 注解的方式来实现。

• 连接点（Joinpoint）：
  在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。
  在 Spring AOP 中，一个连接点总是表示一个方法的执行。

• 切入点（Pointcut）：
  匹配连接点的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如：当执行某个特定名称的方法时）。
  切入点表达式如何和连接点匹配是 AOP 的核心：Spring 缺省使用 Aspect 切入点语法。

• 引入（Introduction）：
  用来给一个类型声明额外的方法或属性（也被称为连接类型声明（inter-type declaration））
  Spring 允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，可以使用引入来使一个 bean 实现 isModified 接口，以便简化缓存机制。

• 目标对象（Target Object）：
  被一个或者多个切面所通知的对象，也被称为通知（advised）对象。
  既然 Spring AOP 是通过运行时代理实现的。这个对象永远是一个被代理（proxied）对象。

• AOP 代理（AOP Proxy）：
  AOP 框架创建的对象，用来实现切面契约（例如，通知方法执行等等）。
  在 Spring 中，AOP 代理可以是 JDK 动态代理或者 CGLIB 代理。

• 织入（Weaving）：
  把切面连接到其它的应用程序类型或者对象上，并创建一个被通知的对象。这些可以在编译时（例如使用 AspectJ 编译器），类加载时和运行时完成。Spring 和其他纯 Java AOP 框架一样，在运行时完成织入。

• 通知（Advice）：
  在切面的某个特定的连接点上执行的动作。其中包括“around”、“before” 和 “after” 等不同类型的通知。
  许多 AOP 框架（包括 Spring）都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

【通知类型】

• 前置通知（Before advice）：
  @Before
  在某连接点之前执行的通知，但这个通知不能阻止了连接点之前的执行流程（除非它抛出一个异常）。

• 后置通知（After returning advice）：
  @After
  在某连接点正常完成后执行的通知，例如，一个方法么有抛出任何异常，正常返回。

• 异常通知（After throwing advice）：
  @After-returning
  在方法抛出异常退出时执行的通知。

• 最终通知（After（finally）advice）：
  @After-throwing
  当某连接点退出的时候执行的通知（不论是正常退出还是异常退出）；

• 环绕通知（Around advice）：
  @Around
  包围一个连接点的通知，如方法调用，这是最强大的一种通知类型。

三、简单例子

1、基于注解的方式

@Aspectj 
public class TransactionDemo {
    @Pointcut(value="execution(* com.yangxin.core.service.*.*.*(..))")
    public void point() { //... }
    
    @Before(value="point()")
    public void before() {
        System.out.println("transaction begin");
    }
    
    @AfterReturning(value = "point()")
    public void after() {
        System.out.println("transaction commit");
    }
    
    @Around("point()")
    public void around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("transaction begin");
        joinPoint.proceed();
        System.out.println("transaction commit");
    }
} 

在 applicationContext.xml 中配置:

<aop:aspectj-autoproxy />
    <bean id="transactionDemo" class="com.yangxin.core.transaction.TransactionDemo" />   

2、基于 XML 的方式

<aop:config>
    <aop:aspect ref="log">
        <aop:pointcut
                expression="(execution(* spring.ch3.topic1.Chief.*(..)))"
                id="chiefPointCut" />
        <aop:before method="washOven" pointcut-ref="chiefPointCut" />
        <aop:before method="prepare" pointcut-ref="chiefPointCut" />
        <aop:after method="after" pointcut-ref="chiefPointCut" />
    </aop:aspect>
</aop:config>
    

四、Spring AOP 原理

AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。
AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异：AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。

Spring 的 AOP 代理由 Spring 的 IoC 容器负责生成、管理，其依赖关系也由 IoC 容器负责管理。因此，AOP 代理可以直接使用容器中的其他 Bean 实例作为目标，这种关系可由 IoC 容器的依赖注入提供。

aop开发时，其中需要参与开发的只有 3 个部分：

• 定义普通业务组件。
• 定义切入点，一个切入点可能横切多个业务组件。
• 定义增强处理，增强处理就是在 AOP 框架为普通业务组件织入的处理动作。

五、两种动态代理方式

Spring默认采取的动态代理机制实现AOP，当动态代理不可用时（代理类无接口）会使用CGlib机制。

Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。

1、JDK 动态代理

• JDK动态代理主要涉及到java.lang.reflect包中的两个类：Proxy和InvocationHandler。InvocationHandler是一个接口，通过实现该接口定义横切逻辑，并通过反射机制调用目标类的代码，动态将横切逻辑和业务逻辑编制在一起。
• Proxy利用InvocationHandler动态创建一个符合某一接口的实例，生成目标类的代理对象。

2、CGLib动态代理

• CGLib全称为Code Generation Library，是一个强大的高性能，高质量的代码生成类库，可以在运行期扩展Java类与实现Java接口，CGLib封装了asm，可以再运行期动态生成新的class。和JDK动态代理相比较：JDK创建代理有一个限制，就是只能为接口创建代理实例，而对于没有通过接口定义业务方法的类，则可以通过CGLib创建动态代理。

六、补充实例

package springMVCmybatis.com.my.aop;
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Around; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.annotation.Pointcut; 
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint; 
import org.aspectj.lang.annotation.After; 
import org.aspectj.lang.annotation.AfterReturning; 
import org.aspectj.lang.annotation.AfterThrowing; 
import org.springframework.core.annotation.Order;

@Aspect
@Order(3)
public class MyAopTest {
    @Pointcut("execution(* springMVCmybatis.addController.addEmp(..))")
    private void pointCutMethod() { //... }
    
    @Pointcut("execution(* springMVCmybatis.com.my.aop.UserServiceImp.*(..))") 
    private void testAOP() { //... }
    
    /**
    * 声明前置通知 ，JoinPont是srpring提供的静态变量，
    * 通过joinPoint参数可以获得目标方法的类名，方法参数，方法名等信息，这个参数可有可无。
    */
    @Before("pointCutMethod() || testAOP()") 
    public void doBefore(JoinPoint joinPoint) { 
        System.out.println("@Before:开始添加--order=3"); 
    } 
    
    /**
    * 声明后置通知 ，如果result的类型与proceed执行的方法返回的参数类型不匹配那么就不会执行这个方法
    */
    @AfterReturning(pointcut = "pointCutMethod()  || testAOP()", returning = "result") 
    public void doAfterReturning(String result) { 
        System.out.println("@AfterReturning:后置通知--order=3"); 
        System.out.println("---" + result + "---"); 
    } 
    
    /**
    * 声明例外通知 
    */
    @AfterThrowing(pointcut = "pointCutMethod() || testAOP()", throwing = "e") 
    public void doAfterThrowing(Exception e) { 
        System.out.println("@AfterThrowing:例外通知--order=3"); 
        System.out.println(e.getMessage()); 
    }
    
    /**
    * 声明最终通知
    */
    @After("pointCutMethod() || testAOP()") 
    public void doAfter() { 
        System.out.println("@After:最终通知--order=3"); 
    } 

    /**
    * 声明环绕通知
    * 参数必须是ProceedingJoinPoint，通过该对象的proceed()方法来执行目标函数，
    * proceed()的返回值就是环绕通知的返回值，proceedingJoinPoint是个接口，
    * implement JoinPoint,所以也可以获得目标函数的类名，方法名等参数。
    */
    @Around("pointCutMethod() || testAOP()") 
    public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
        System.out.println("@Around:进入方法---环绕通知--order=3"); 
        Object o = pjp.proceed(); 
        System.out.println("@Around:退出方法---环绕通知--order=3"); 
        return o; 
    }
}

七、切点表达式

1、方法签名表达式

execution(<修饰符模式>?<返回类型模式><方法所在类的完全限定名称模式>(<参数模式>)<异常模式>?)
execution(modifiers-pattern? ret-type-pattern fully-qualified-class-name (param-pattern) throws-pattern?)  　

对比方法的定义来记忆，一个java方法的全部定义方式可以表示成下面的方式：

public String springMVCmybatic.com.my.aop.UserServiceImp(String a, int b) throw Exception{}

• modifier-pattern?：表示方法的修饰符，可有可无；对应的就是 public
• ret-type-pattern：表示方法的返回值；对应的就是 String
• fully-qualified-class-name 方法所在类的完全限定名称；对应的就是 springMVCmybatic.com.my.aop.UserServiceImp
• param-pattern：表示方法的参数；对应的就是 String a, int b
• throws-pattern：表示方法抛出的异常，可有可无；对应的就是 throw Exception

2、&&，||，！（表达式之间可以采用与，或，非的方式来过滤。）

@Around("pointCutMethod() || testAOP()") 
public Object doAround(ProceedingJoinPoint pjp) throws Throwable { 
    System.out.println("@Around:进入方法---环绕通知"); 
    Object o = pjp.proceed(); 
    System.out.println("@Around:退出方法---环绕通知"); 
    return o; 
}

八、多个切点的执行顺序

上面的例子中，定义了order=3，重新创建一个切面，定义order=6，执行的结果是：

@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
@Around:进入方法---环绕通知--order=6
@Before:开始添加--order=6
============执行业务方法findUser,查找的用户是：张三=============
@Around:退出方法---环绕通知--order=6
@After:最终通知--order=6
@AfterReturning:后置通知--order=6
---张三---
@Around:退出方法---环绕通知--order=3
@After:最终通知--order=3
@AfterReturning:后置通知--order=3
---张三---
 
 
@Around:进入方法---环绕通知--order=3
@Before:开始添加--order=3
@Around:进入方法---环绕通知--order=6
@Before:开始添加--order=6
============执行业务方法addUser=============
@After:最终通知--order=6
@AfterThrowing:例外通知--order=6
null
@After:最终通知--order=3
@AfterThrowing:例外通知--order=3
null

从结果中可以看出order越小越先执行，执行完了之后就order越小就越后推出。总结为下面的图：

spring