标签：通知 代理 切点 详解 切面 AOP 方法

目录

• 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控制台会得到：

标签：通知,代理,切点,详解,切面,AOP,方法
来源： https://blog.csdn.net/weixin_47331155/article/details/122045781

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。