目录

• AOP:面向切面编程，AOP是一种编程思想，和语言无关。
• 拦截器和AOP之间的关系？
• 什么是AOP
• 使用场景及作用
• JDK实现
• JDK和CGLIB实现的区别
• Spring AOP中的实现
• SpringAOP的AspectJ支持
• AOP术语
• • 切点表达式说明
  • 切点表达式示例
  • 通知（Advice）
  • 织入（Weaving）
• SpringAOP的实现举例：
• • 第一步：引入依赖
  • 第二步：定义切面
  • 第三步：添加通知

AOP:面向切面编程，AOP是一种编程思想，和语言无关。

拦截器和AOP之间的关系？

拦截器的拦截粒度比较粗，而SpringAOP拦截粒度更细

什么是AOP

AOP称为面向切面编程，在系统开发中主要用来解决一些系统层面上的问题，比如：日志，权限，事务等等。
AOP利用一种称为“横切”的技术，将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect",即切面。
使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。
横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处基本相似，比如权限认证，日志，事务。AOP的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。

使用场景及作用

对以上统一业务来说，常见的切面业务如：

1. 响应统一的数据格式
2. 统一异常处理
3. 统一日志记录，如跟踪用户访问信息
4. 用户统一会话管理，权限管理
5. 方法执行时间计算
6. 事务管理
7. 其他

对于使用AOP技术来说，解决的最大问题就是对横切业务的统一管理：

1. 横切代码的高度复用，和业务代码互相独立，满足代码设计上的高内聚低耦合
2. 系统更好的扩展性，可维护性

我们学习Spring框架中的AOP，主要基于两种方式：JDK及CGLIB的方式。这两种方式的代理目标都是被代理类中的方法，在运行期，动态的织入字节码生成代理类。

JDK实现

JDK实现时，先通过实现InvocationHandler接口创建方法调用处理器，再通过Proxy来创建代理类。

JDK和CGLIB实现的区别

1. JDK实现，要求被代理类必须实现接口，之后是通过InvocationHandler及Proxy,在运行时动态的在内存中生成了代理类对象，该代理对象是通过实现同样的接口实现（类似静态代理接口实现的方式），只是该代理类是在运行期时，动态的织入统一的业务逻辑字节码来完成。
2. CGLIB实现，被代理类可以不实现接口，是通过继承被代理类，在运行时动态的生成代理类对象。

Spring AOP大部分可以通过CGLIB来实现动态代理，当一个类是final class 的时候就必须使用JDK Porxy来实现动态代理了，因为final class无法被继承。

Spring AOP中的实现

一个类的重要组成部分有两个：

1. 属性
2. 方法

SpringAOP只能实现方法拦截，不能实现属性拦截。但是对于AOP来说，AOP是既可以实现属性拦截又可以实现方法拦截的。
SpringAOP支持JDK和CGLIB的方式实现动态代理。默认情况下，实现了接口的类，使用AOP会基于JDK生成代理类，没有实现接口的类，会基于CGLIB生成代理类。

SpringAOP的AspectJ支持

SpringAOP只提供了AspectJ的注解语法支持，没有真实使用AspectJ的编译器,在运行时还是基于单纯的AOP。也就是说，加入spring-aspects依赖包，只是可以使用AspectJ的语法，运行时还是基于spring-aop依赖包的动态代理实现。

AOP术语

和大多数技术一样，AOP已经形成了自己的术语。描述切面的常用术语有：通知(Advice),切点(Pointcut)和连接点(Joinpoint)。
切面（Aspect）：由切点和通知组成，它既包含了横切逻辑的定义，也包括了连接点的定义。
连接点：连接点是在应用执行过程中能够插入切面（Aspect）的一个点。
切点：切点是指通知（Advice）所要织入（Weaving）的具体位置。（切点一定是连接点，连接点不一定是切点，只有程序执行的连接点才是切点）
打个比方：环形高速公路的所有出入口就叫做连接点。而某个我需要进，出的入口，出口才叫切点。

切点表达式说明

@AspectJ支持三种通配符

:匹配任意字符，只匹配一个元素（包，类，方法，方法参数）

:匹配任意字符，可以匹配多个元素，在表示类时，必须和*联合使用

：表示按照类型匹配指定类的所有类，必须跟在类名后面，如com.cad.car+,表示匹配该类的所有子类·包括本身
切点表达式由切点函数组成，其中execution()是最常用的切点函数，用来匹配方法。

切点表达式示例

execution(com.cad.demo.User.(…)):匹配User类里的所有方法
execution(com.cad.demo.User+.(…)):匹配该类的子类包括该类的所有方法
execution(com.cad..(…)):匹配com.cad包下的所有类的所有方法
execution(com.cad….(…)):匹配com.cad包下，子孙包下所有类的所有方法
execution(*addUser(String,int)):匹配addUser方法，且第一个参数类型是String，第二个参数类型是int
通知（Advice）:切面也是有目标（它必须完成的工作）的，在AOP术语中，切面的工作被称之为通知。

通知（Advice）

通知（Advice）:切面也是有目标（它必须完成的工作）的，在AOP术语中，切面的工作被称之为通知。
通知：定义了切面是什么，何时使用，其描述了切面切面要完成的工作，还解决何时执行这个工作的问题。
Spring切面类中，可以在方法上使用以下注解，会设置方法为通知方法，在满足条件后会通知本方法进行调用。

• 前置通知
  使用@Before:通知方法会在目标方法调用之前执行

• 后置通知
  使用@After:通知方法会在目标方法返回或者抛出异常后调用

• 返回之后通知
  使用@AfterReturing:通知方法会在目标方法返回后调用

• 抛异常后通知
  使用@AfterThrowing:通知方法会在目标方法抛出异常后调用

• 环绕通知
  使用@Around:通知包裹了被通知的方法，在被通知的方法通知之前和调用之后执行自定义的行为

许多AOP框架，包括Spring AOP,会将Advice模拟为一个拦截器（Interceptor）,并且在JoinPoint上维护多个Advice，进行层层拦截。如之前我们在SpringMVC中学习的@ControllerAdvice就是。

织入（Weaving）

织入是把切面应用到目标对象并创建新的代理对象的过程，切面在指定的连接点被织入到目标对象中。

SpringAOP的实现举例：

第一步：引入依赖

第二步：定义切面

第三步：添加通知

1. 首先创建一个controller用于测试

@RestController
@RequestMapping("/user")
public class UserController {
    @RequestMapping("/login")
    public int login(String username,String password){
        System.out.println("执行了login方法");
        return 0;
    }
    @RequestMapping("/register")
    public int register(String username,String password){
        System.out.println("执行了register方法");
        return 1;
    }
}

2. 再创建一个UserPointCut类

@Aspect//这个注解表示当前的类是一个切面
@Component//保证Spring启动之后，能够将当前的类加载到框架当中，加载到框架当中才能去用
public class UserPointCut {
    //1.定义切面的规则,使用注解定义规则
    @Pointcut("execution(* com.example.demo.controller.*Controller.*(..))")//表示对所有的Controller下的所有方法都会进行拦截
    public void pointcut(){

    }
    //2.添加通知
    @Before("pointcut()")//把切面的方法名写进去
    public void doBefore(){
        System.out.println("执行了前置通知");
    }
    @After("pointcut()")//把切面的方法名写进去
    public void doAfter(){
        System.out.println("执行了后置通知");
    }
    @AfterReturning("pointcut()")//把切面的方法名写进去
    public void doReturing(){
        System.out.println("执行了返回之后通知的方法");
    }
    @AfterThrowing("pointcut()")//把切面的方法名写进去
    public void doThrowing(){
        System.out.println("执行了抛出异常之后通知的方法");
    }
    @Around("pointcut()")//把切面的方法名写进去，环绕通知
    public Object doAround(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知：方法执行之前");
        Object result = null;
        try {
            result = joinPoint.proceed();//表示执行被代理的方法，当调用了这个方法才有“执行了register”方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("执行了环绕通知：执行了方法调用之后");
        return 0;
    }
}

3. 执行结果：
   输入url
   
   浏览器中的得到返回值：1
   idea控制台得到：
   

可以看出这些先后执行顺序。
如果Around通知变成这样：

@Around("pointcut()")//把切面的方法名写进去，环绕通知
    public Object doAround(ProceedingJoinPoint joinPoint){
        System.out.println("进入了环绕通知：方法执行之前");
        Object result = null;
        try {
            //result = joinPoint.proceed();//表示执行被代理的方法，当调用了这个方法才有“执行了register”方法
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        System.out.println("执行了环绕通知：执行了方法调用之后");
        return 0;
    }

再次输入url:

浏览器得到：0
idea控制台会得到：