Spring AOP

• 什么是 Spring AOP
• 为什要⽤ AOP
• Spring AOP 应该怎么学习呢
• • AOP 组成
  • • 切⾯（Aspect）
    • 切点（Pointcut）
    • 通知（Advice）
    • 连接点（Join Point）
    • Spring AOP 实现
    • • 添加 AOP 框架⽀持
      • 创建切面
      • 创建切点
      • 创建通知
      • 创建连接点
      • 创建对照组"连接点"
      • 三级目录
      • Spring AOP 实现原理
      • 总结

        什么是 Spring AOP

        AOP（Aspect Oriented Programming）：⾯向切⾯编程，它是⼀种思想，它是对某⼀类事情的集中处理。⽐如⽤户登录权限的效验，没学 AOP 之前，我们所有需要判断⽤户登录的⻚⾯（中的⽅法），都要各⾃实现或调⽤⽤户验证的⽅法，然⽽有了 AOP 之后，我们只需要在某⼀处配置⼀下，所有需要判断⽤户登录⻚⾯（中的⽅法）就全部可以实现⽤户登录验证了，不再需要每个⽅法中都写相同的⽤户登录验证了

        AOP 是⼀种思想，⽽ Spring AOP 是⼀个框架，提供了⼀种对 AOP 思想的实现，它们的关系和IoC 与 DI 类似

        为什要⽤ AOP

        想象⼀个场景，我们在做后台系统时，除了登录和注册等⼏个功能不需要做⽤户登录验证之外，其他⼏乎所有⻚⾯调⽤的前端控制器（ Controller）都需要先验证⽤户登录的状态，那这个时候我们要怎么处理呢

        我们之前的处理⽅式是每个 Controller 都要写⼀遍⽤户登录验证，然⽽当你的功能越来越多，那么你要写的登录验证也越来越多，⽽这些⽅法⼜是相同的，这么多的⽅法就会代码修改和维护的成本。那有没有简单的处理⽅案呢？答案是有的，对于这种功能统⼀，且使⽤的地⽅较多的功能，就可以考虑 AOP来统⼀处理

        除了统⼀的⽤户登录判断之外，AOP 还可以实现：

        • 统⼀⽇志记录
        • 统⼀⽅法执⾏时间统计
        • 统⼀的返回格式设置
        • 统⼀的异常处理
        • 事务的开启和提交等

          也就是说使⽤ AOP 可以扩充多个对象的某个能⼒，所以 AOP 可以说是 OOP（Object OrientedProgramming，⾯向对象编程）的补充和完善

          Spring AOP 应该怎么学习呢

          Spring AOP 学习主要分为以下 3 个部分：

          1. 学习 AOP 是如何组成的？也就是学习 AOP 组成的相关概念
          2. 学习 Spring AOP 使⽤
          3. 学习 Spring AOP 实现原理

          AOP 组成

          切⾯（Aspect）

          切⾯（Aspect）由切点（Pointcut）和通知（Advice）组成，它既包含了横切逻辑的定义，也包括了连接点的定义

          切⾯是包含了：通知、切点和切⾯的类，相当于 AOP 实现的某个功能的集合

          切点（Pointcut）

          定义一个拦截规则

          Pointcut 是匹配 Join Point 的谓词

          Pointcut 的作⽤就是提供⼀组规则（使⽤ AspectJ pointcut expression language 来描述）来匹配 Join Point，给满⾜规则的 Join Point 添加 Advice

          切点相当于保存了众多连接点的⼀个集合（如果把切点看成⼀个表，⽽连接点就是表中⼀条⼀条的数据）

          通知（Advice）

          执行AOP的逻辑业务

          切⾯也是有⽬标的 ——它必须完成的⼯作，在 AOP 术语中，切⾯的⼯作被称之为通知

          通知：定义了切⾯是什么，何时使⽤，其描述了切⾯要完成的⼯作，还解决何时执⾏这个⼯作的问题

          Spring 切⾯类中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤：

          • 前置通知使⽤ @Before：通知⽅法会在⽬标⽅法调⽤之前执⾏
          • 后置通知使⽤ @After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤
          • 返回之后通知使⽤ @AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤
          • 抛异常后通知使⽤ @AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤
          • 环绕通知使⽤ @Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为

            连接点（Join Point）

            所有可能触发切点的点称作连接点

            应⽤执⾏过程中能够插⼊切⾯的⼀个点，这个点可以是⽅法调⽤时，抛出异常时，甚⾄修改字段时。切⾯代码可以利⽤这些点插⼊到应⽤的正常流程之中，并添加新的⾏为

            连接点相当于需要被增强的某个 AOP 功能的所有⽅法

            AOP 整个组成部分的概念如下图所示，以多个⻚⾯都要访问⽤户登录权限为例：

            

            Spring AOP 实现

            接下来我们使⽤ Spring AOP 来实现⼀下 AOP 的功能，完成的⽬标是拦截所有 UserController ⾥⾯的⽅法，每次调⽤ UserController 中任意⼀个⽅法时，都执⾏相应的通知事件。

            Spring AOP 的实现步骤如下

            1. 添加 Spring AOP 框架⽀持
            2. 定义切⾯和切点
            3. 定义通知

            添加 AOP 框架⽀持

            在 pom.xml 中添加如下配置：

                    
                        org.springframework.boot
                        spring-boot-starter-aop
                    
            

            

            创建切面

            

            创建切点

            切点指的是具体要处理的某⼀类问题，⽐如⽤户登录权限验证就是⼀个具体的问题，记录所有⽅法的执⾏⽇志就是⼀个具体的问题，切点定义的是某⼀类问题

            Spring AOP 切点的定义如下，在切点中我们要定义拦截的规则，具体实现如下

            

            其中 pointcut ⽅法为空⽅法，它不需要有⽅法体，此⽅法名就是起到⼀个“标识”的作⽤，标识下⾯的通知⽅法具体指的是哪个切点（因为切点可能有很多个）

            切点表达式说明

            AspectJ ⽀持三种通配符

            • * ：匹配任意字符，只匹配⼀个元素（包，类，或⽅法，⽅法参数）
            • ..：匹配任意字符，可以匹配多个元素 ，在表示类时，必须和 * 联合使⽤
            • + ：表示按照类型匹配指定类的所有类，必须跟在类名后⾯，如 com.cad.Car+ ,表示继承该类的所有⼦类包括本身

              切点表达式由切点函数组成，其中 execution() 是最常⽤的切点函数，⽤来匹配⽅法，语法为：

              execution(<修饰符><返回类型><包.类.⽅法(参数)><异常>)
              

              创建通知

              通知定义的是被拦截的⽅法具体要执⾏的业务，⽐如⽤户登录权限验证⽅法就是具体要执⾏的业务。

              Spring AOP 中，可以在⽅法上使⽤以下注解，会设置⽅法为通知⽅法，在满⾜条件后会通知本⽅法进⾏调⽤

              • 前置通知使⽤@Before：通知⽅法会在⽬标⽅法调⽤之前执⾏
              • 后置通知使⽤@After：通知⽅法会在⽬标⽅法返回或者抛出异常后调⽤
              • 返回之后通知使⽤@AfterReturning：通知⽅法会在⽬标⽅法返回后调⽤
              • 抛异常后通知使⽤@AfterThrowing：通知⽅法会在⽬标⽅法抛出异常后调⽤
              • 环绕通知使⽤@Around：通知包裹了被通知的⽅法，在被通知的⽅法通知之前和调⽤之后执⾏⾃定义的⾏为

                具体实现如下：

                

                创建连接点

                

                运行程序，触发切点结果如下：

                

                创建对照组"连接点"

                

                运行程序，"触发"切点结果如下：

                

                由于该方法并没有被拦截，所以没有触发切点并执行通知

                三级目录

                Spring AOP 实现原理

                Spring AOP 是构建在动态代理基础上，因此 Spring 对 AOP 的⽀持局限于⽅法级别的拦截

                Spring AOP ⽀持 JDK Proxy 和 CGLIB ⽅式实现动态代理。默认情况下，实现了接⼝的类，使⽤ AOP 会基于 JDK ⽣成代理类，没有实现接⼝的类，会基于 CGLIB ⽣成代理类

                

                织⼊（Weaving）：代理的⽣成时机

                织⼊是把切⾯应⽤到⽬标对象并创建新的代理对象的过程，切⾯在指定的连接点被织⼊到⽬标对象中

                在⽬标对象的⽣命周期⾥有多个点可以进⾏织⼊：

                • 编译期：切⾯在⽬标类编译时被织⼊。这种⽅式需要特殊的编译器。AspectJ的织⼊编译器就是以这种⽅式织⼊切⾯的
                • 类加载期：切⾯在⽬标类加载到JVM时被织⼊。这种⽅式需要特殊的类加载器（ClassLoader）,它可以在⽬标类被引⼊应⽤之前增强该⽬标类的字节码。AspectJ5的加载时织⼊（load-time weaving. LTW）就⽀持以这种⽅式织⼊切⾯
                • 运⾏期：切⾯在应⽤运⾏的某⼀时刻被织⼊。⼀般情况下，在织⼊切⾯时，AOP容器会为⽬标对象动态创建⼀个代理对象。SpringAOP就是以这种⽅式织⼊切⾯的

                  动态代理

                  此种实现在设计模式上称为动态代理模式，在实现的技术⼿段上，都是在 class 代码运⾏期，动态的织⼊字节码

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

                  • CGLIB是Java中的动态代理框架，主要作⽤就是根据⽬标类和⽅法，动态⽣成代理类
                  • Java中的动态代理框架，⼏乎都是依赖字节码框架（如 ASM，Javassist 等）实现的
                  • 字节码框架是直接操作 class 字节码的框架。可以加载已有的class字节码⽂件信息，修改部分信息，或动态⽣成⼀个 class

                    JDK 和 CGLIB 实现的区别

                    JDK 动态代理：通过实现代理类的子类实现动态代理

                    CGLIB 动态代理：通过反射实现，要求被代理的类必须实现接口

                    总结

                    AOP 是对某⽅⾯能⼒的统⼀实现，它是⼀种实现思想，Spring AOP 是对 AOP 的具体实现，SpringAOP 可通过 AspectJ（注解）的⽅式来实现 AOP 的功能，Spring AOP 的实现步骤是：

                    1. 添加 AOP 框架⽀持
                    2. 定义切⾯和切点
                    3. 定义通知

                    Spring AOP 是通过动态代理的⽅式，在运⾏期将 AOP 代码织⼊到程序中的，它的实现⽅式有两种：

                    JDK Proxy 和 CGLIB

                     
                     网站开发需要多少钱  江西南昌网络公司  上海网络公司排名  真正免费建站  网站在线优化工具  建一个网页