Spring AOP 的简单应用

因为工作需求，自己去了解一下aop并做下的记录，当然大部分都是参考他人博客以及官方文档。

[关于 AOP](#关于 AOP)
- 相关术语
[Spring AOP的使用](#Spring AOP的使用)
- 基于注解的使用
  - 添加依赖
  - [开启 @Aspect 注解](#开启 @Aspect 注解)
  - [定义 aspect（切面）](#定义 aspect（切面）)
  - [声明 pointcut](#声明 pointcut)
  - 切点标志符
  - [声明 advice](#声明 advice)
代码地址
参考链接

关于 AOP

大家都知道Spring框架有两大重要特性，IOC 控制反转（Inversion of Control，IoC）以及AOP 面向切面编程（Aspect Oriented Program， AOP）。今天主要是来一起了解一下AOP。

其主要作用是，在不修改源代码的情况下给某个或者一组操作添加额外的功能。像日志记录，事务处理，权限控制等功能，都可以用AOP来“优雅”地实现，使这些额外功能和真正的业务逻辑分离开来，软件的结构将更加清晰。

简单来说在运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

Spring AOP的使用

我们可以通过三种方式来使用Spring AOP，他们分别是：@Aspect-based（Annotation），Schema-based（XML），以及底层的Spring AOP API。我们后续讲解的主要是基于注解的实现。

使用xml的实现原理与使用注解基本一致，基本上只是把注解包含的配置信息都转移到了xml配置文件中。

至于AOP API则是Spring1.2提供的历史用法，现在的Sping4也仍然支持，注解与xml也是基于其上的使用。它是SpringAOP的基础，有兴趣的可以去参考链接4查看。

基于注解的使用

添加 @AspectJ 支持

@AspectJ 是一种使用 Java 注解来实现 AOP 的编码风格.
@AspectJ 风格的 AOP 是 AspectJ Project 在 AspectJ 5 中引入的, 并且 Spring 也支持@AspectJ 的 AOP 风格.

添加依赖

 
  
    org.springframework
    spring-aop
    ${spring.version}
  
  
  
    org.aspectj
    aspectjrt
    ${aspectj.version}
  
  
    org.aspectj
    aspectjweaver
    ${aspectj.version}

开启 @Aspect 注解

    在 spring-mvc.xml 中添加一下语句 用于启用@Aspect注解
     //jdk 代理
    或
     //cglib 代理

    
    并且需要在xml中加上 aop 的 namespace

jdk 代理与 CGlib 代理
JDK动态代理只能对实现了接口的类生成代理，而不能针对类。
CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法。
因为是继承，所以该类或方法最好不要声明成final ，final可以阻止继承和多态。

定义 aspect（切面）

当使用注解 @Aspect 标注一个 Bean 后, 那么 Spring 框架会自动收集这些 Bean, 并添加到 Spring AOP 中, 例如:

@Aspect
@Component
public class TestAspect {
}

请注意，@Aspect 不能被 Spring 自动识别并注册为 Bean；为此，您需要添加一个单独的 @Component 注释

声明 pointcut

pointcut 声明由两部分组成：

Pointcut签名(signature) 包括方法名和相关参数

Pointcut表示式(expression) 用来指定哪些方法执行是我们感兴趣的(即因此可以织入 advice).

pointcut expression

这个方法必须无返回值.
这个方法本身就是 pointcut signature, pointcut 表达式使用@Pointcut 注解指定.
上图定义了一个 pointcut，它所描述的是：匹配在项目路径 aspects.trace.demo 下的所有方法的执行

切点标志符(designator)

具体使用请参考案例代码

execution - for matching method execution join points, this is the primary pointcut designator you will use when working with Spring AOP
within - limits matching to join points within certain types (simply the execution of a method declared within a matching type when using Spring AOP)
this - limits matching to join points (the execution of methods when using Spring AOP) where the bean reference (Spring AOP proxy) is an instance of the given type
target - limits matching to join points (the execution of methods when using Spring AOP) where the target object (application object being proxied) is an instance of the given type
args - limits matching to join points (the execution of methods when using Spring AOP) where the arguments are instances of the given types
bean - limit the matching of join points to a particular named Spring bean, or to a set of named Spring beans (when using wildcards).
@target - limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type
@args - limits matching to join points (the execution of methods when using Spring AOP) where the runtime type of the actual arguments passed have annotations of the given type(s)
@within - limits matching to join points within types that have the given annotation (the execution of methods declared in types with the given annotation when using Spring AOP)
@annotation - limits matching to join points where the subject of the join point (method being executed in Spring AOP) has the given annotation

声明 advice

advice 是和一个 pointcut 表达式关联在一起的, 并且会在匹配的 join point 的方法执行的前/后/周围运行. pointcut 表达式可以是简单的一个 pointcut 名字的引用, 或者是完整的 pointcut 表达式.

* Before

 Before Advice 由切面中的 @Before 注解声明

 代表 advice 在 joinpoint 之前执行
* After returning

 当匹配的方法正常执行并返回时运行 After returning Advice。

 由 @AfterReturning 注解声明

* After throwing 
 当匹配的方法执行并抛出异常退出时，运行。
 
 由 @AfterThorwing 注解声明。

* After (finally)
 当匹配的方法执行完成并退出后执行。
 
 通过 @After 声明
 
        try{
            try{
                //@Before
                method.invoke(..);
            }finally{
                //@After
            }
            //@AfterReturning
        }catch(){
            //@AfterThrowing
        }

* Around
 它可以在一个方法的之前之前和之后添加不同的操作, 并且甚至可以决定何时, 如何, 是否调用匹配到的方法.
 
 通过 @Around 声明