SpringBoot.07.SpringBoot切面编程之AOP

转x33g5p2x  于2022-04-11 转载在 Spring  
字(10.1k)|赞(0)|评价(0)|浏览(442)

前言

SpringBoot是对spring和springmvc的进一步封装，因此在SpringBoot中同样支持Spring中的AOP切面编程，不过在SpringBoot中为了快速开发仅仅提供了注解方式的切面编程。

AOP介绍

概念

面向切面编程（AOP是Aspect Oriented Program的首字母缩写）。通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是函数式编程的一种衍生泛型。利用AOP可以对业务逻辑的各个部分进行隔离，从而是的业务逻辑各部分之间的耦合度降低，提高程序的重用性，有人提高开发效率。

AOP采取横向抽取机制，补充了传统**纵向继承体系（OOP）**无法解决的重复性代码优化（性能监视、事务管理、安全检查、缓存），将业务逻辑和系统处理的代码（关闭连接、事务管理、操作日志记录）解耦。这样维护起来更加方便。

纵向集成体系

横向抽取机制

相关术语

  • Joinpoint：连接点。所谓连接点是指那些被拦截到的点。在spring中，这些点指的是方法，因为spring只支持方法类型的连接点
  • Pointcut：切入点。所谓切入点是指我们要对哪些Joinpoint进行拦截的定义
  • Advice：通知|增强。所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知分为前置通知，后置通知，异常通知，最终通知，环绕通知（切面要完成的功能）
  • Introduction：引介。引介是一种特殊的通知。在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法或Field
  • Target：目标对象。代理的目标对象
  • Weaving：织入。是指把增强应用到目标对象来创建新的代理对象的过程
  • Proxy：代理。一个类被AOP织入增强后，就产生一个结果代理类
  • Aspect：切面。是切入点和通知的结合，以后咱们自己来编写和配置的
  • Advisor：通知器、顾问。和Aspect很相似

AOP使用

在SpringBoot中使用AOP较之于传统的SSM框架就比较简单了。只需要引用spring-boot-starter-aop这一个依赖就可以了。

小试牛刀

1.新建Module

新建Module - springboot-06-aop，按照下图所示填写信息：

点击下一步选择依赖Spring Web，点击Finish。如下图所示：

2.项目配置

我们以springboot-05-logback中的代码为例演示AOP的使用。首先我们规整一下项目，然后将springboot-05-logback中的代码拷贝到本次案例。如下图所示：

3.pom.xml

我们在pom.xml中引入AOP的依赖（记得刷新）。完整的pom文件如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.5.0</version>
  9.         <relativePath/>
  10.     </parent>
  12.     <groupId>com.christy</groupId>
  13.     <artifactId>springboot-06-aop</artifactId>
  14.     <version>0.0.1-SNAPSHOT</version>
  15.     <name>springboot-06-aop</name>
  16.     <description>Demo project for Spring Boot</description>
  18.     <properties>
  19.         <java.version>1.8</java.version>
  20.     </properties>
  22.     <dependencies>
  23.         <!-- spring-boot-starter-web -->
  24.         <dependency>
  25.             <groupId>org.springframework.boot</groupId>
  26.             <artifactId>spring-boot-starter-web</artifactId>
  27.         </dependency>
  29.         <!-- spring-boot-starter-test -->
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-test</artifactId>
  33.             <scope>test</scope>
  34.         </dependency>
  36.         <!-- druid -->
  37.         <dependency>
  38.             <groupId>com.alibaba</groupId>
  39.             <artifactId>druid</artifactId>
  40.             <version>1.2.6</version>
  41.         </dependency>
  43.         <!-- mysql-connector-java -->
  44.         <dependency>
  45.             <groupId>mysql</groupId>
  46.             <artifactId>mysql-connector-java</artifactId>
  47.             <version>5.1.38</version>
  48.         </dependency>
  50.         <!-- mybatis-spring-boot-starter
  51.           由于springboot整合mybatis版本中默认依赖mybatis 因此不需要额外引入mybati版本,否则会出现冲突
  52.          -->
  53.         <dependency>
  54.             <groupId>org.mybatis.spring.boot</groupId>
  55.             <artifactId>mybatis-spring-boot-starter</artifactId>
  56.             <version>2.1.4</version>
  57.         </dependency>
  59.         <!-- 每次新建的项目如果需要开启热部署都需要引入该依赖 -->
  60.         <dependency>
  61.             <groupId>org.springframework.boot</groupId>
  62.             <artifactId>spring-boot-devtools</artifactId>
  63.             <optional>true</optional>
  64.         </dependency>
  66.         <!-- lombok -->
  67.         <dependency>
  68.             <groupId>org.projectlombok</groupId>
  69.             <artifactId>lombok</artifactId>
  70.         </dependency>
  72.         <!-- Spring AOP -->
  73.         <dependency>
  74.             <groupId>org.springframework.boot</groupId>
  75.             <artifactId>spring-boot-starter-aop</artifactId>
  76.         </dependency>
  77.     </dependencies>
  79.     <build>
  80.         <plugins>
  81.             <plugin>
  82.                 <groupId>org.springframework.boot</groupId>
  83.                 <artifactId>spring-boot-maven-plugin</artifactId>
  84.             </plugin>
  85.         </plugins>
  86.     </build>
  88. </project>
4.MyAspect.java
  1. import lombok.extern.slf4j.Slf4j;
  2. import org.aspectj.lang.JoinPoint;
  3. import org.aspectj.lang.ProceedingJoinPoint;
  4. import org.aspectj.lang.annotation.*;
  5. import org.springframework.stereotype.Component;
  7. /**
  8.  * @Author Christy
  9.  * @Date 2021/9/14 10:25
  10.  *
  11.  * @Aspect 该注解作用于类上,代表这个类是一个切面
  12.  **/
  13. @Aspect
  14. @Component
  15. @Slf4j
  16. public class MyAspect {
  17.     /**
  18.      *
  19.      * @Before 该注解作用方法上 代表这个方法是一个前置通知方法 该方法是没有返回值的
  20.      * execution() 切点的函数
  21.      *  第一个*：代表的是方法返回值 *即代表所有的返回值
  22.      *  com.christy.service：包名，代表切面切入的位置
  23.      *  包名后的第一个*：代表的是该包下面的所有类
  24.      *  包名后的第二个*：代表的是类中的所有方法
  25.      *  (..)：代表方法中的任意|所有参数
  26.      *  execution(* com.christy.service.*.*(..))：
  27.      *      意思就是切面的切点作用在包com.christy.service下的所有类中的所有方法
  28.      */
  29.     @Before("execution(* com.christy.service.*.*(..))")
  30.     public void before(JoinPoint joinPoint){
  31.         log.info("这是一个前置通知Before");
  32.         // 目标对象
  33.         log.info("目标对象：" + joinPoint.getTarget());
  34.         // 方法名
  35.         log.info("方法名：" + joinPoint.getSignature());
  36.         // 方法中的参数
  37.         log.info("方法中的参数：" + joinPoint.getArgs());
  38.     }
  40.     /**
  41.      *
  42.      * @After 该注解作用方法上 代表这个方法是一个后置（最终）通知方法
  43.      *        在目标对象方法之后执行通知，有没有异常都会执行
  44.      *        该方法是没有返回值的
  45.      */
  46.     @After("execution(* com.christy.service.*.*(..))")
  47.     public void after(JoinPoint joinPoint){
  48.         log.info("这是一个后置通知After");
  49.         // 目标对象
  50.         log.info("目标对象：" + joinPoint.getTarget());
  51.         // 方法名
  52.         log.info("方法名：" + joinPoint.getSignature());
  53.         // 方法中的参数
  54.         log.info("方法中的参数：" + joinPoint.getArgs());
  55.     }
  57.     /**
  58.      *
  59.      * @AfterReturning 该注解作用方法上 代表这个方法是一个后置通知方法
  60.      *                 在目标对象方法之后执行通知，有异常则不执行了
  61.      *                 该方法可以获取目标方法的返回值
  62.      */
  63.     @AfterReturning(value = "execution(* com.christy.service.*.*(..))",returning = "result")
  64.     public void afterReturning(JoinPoint joinPoint, Object result){
  65.         log.info("这是一个后置结果通知AfterReturning");
  66.         // 目标对象
  67.         log.info("目标对象：" + joinPoint.getTarget());
  68.         // 方法名
  69.         log.info("方法名：" + joinPoint.getSignature());
  70.         // 方法中的参数
  71.         log.info("方法中的参数：" + joinPoint.getArgs());
  72.         // 目标方法返回值
  73.         log.info("目标方法返回值：{}",result);
  74.     }
  76.     /**
  77.      *
  78.      * @AfterReturning 该注解作用方法上 代表这个方法是一个后置异常通知方法
  79.      *                 在目标对象方法抛出异常之后执行通知
  80.      * throwing = "ex" 声明ex的类型会限制目标方法抛出指定类型的异常
  81.      *                 这里将ex的类型声明为Throwable说明不限制类型
  82.      */
  83.     @AfterThrowing(value = "execution(* com.christy.service.*.*(..))",throwing = "ex")
  84.     public void afterThrowing(JoinPoint joinPoint, Throwable ex){
  85.         log.info("这是一个后置异常通知AfterThrowing");
  86.         // 目标对象
  87.         log.info("目标对象：" + joinPoint.getTarget());
  88.         // 方法名
  89.         log.info("方法名：" + joinPoint.getSignature());
  90.         // 方法中的参数
  91.         log.info("方法中的参数：" + joinPoint.getArgs());
  92.         // 方法中抛出的异常
  93.         log.info("方法中抛出的异常：", ex);
  94.     }
  96.     /**
  97.      *
  98.      * @Around 该注解作用方法上 代表这个方法是一个环绕通知方法
  99.      */
  100.     @Around("execution(* com.christy.service.*.*(..))")
  101.     public Object Around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
  102.         log.info("这是一个环绕通知Around");
  103.         // 目标对象
  104.         log.info("目标对象：" + proceedingJoinPoint.getTarget());
  105.         // 方法名
  106.         log.info("方法名：" + proceedingJoinPoint.getSignature());
  107.         // 方法参数
  108.         log.info("方法参数：" + proceedingJoinPoint.getArgs());
  109.         // 放行执行目标方法
  110.         Object proceed = proceedingJoinPoint.proceed();
  111.         log.info("目标方法执行之后回到环绕通知");
  112.         // 返回目标方法返回值 如果不返回目标方法是获取不到返回值的
  113.         return proceed;
  114.     }
  115. }
5.测试

我们运行test包下的类UserTest.java中的方法testFindAll()。具体的代码如下：

  1. import com.christy.service.UserService;
  2. import org.junit.jupiter.api.Test;
  3. import org.springframework.beans.factory.annotation.Autowired;
  5. public class UserTest extends BaseTest{
  7.     private UserService userService;
  8.     @Autowired
  9.     public UserTest(UserService userService) {
  10.         this.userService = userService;
  11.     }
  13.     @Test
  14.     public void testFindALl(){
  15.         userService.findAll().forEach(user -> System.out.println(user.toString()));
  16.     }
  17. }
5.1 正常运行

在正常情况下的运行流程：环绕通知->前置通知->方法->后置结果通知->后置通知->环绕通知。如下图所示：

正常情况下访问，通知和方法都能正确执行

5.2 方法中抛出异常

我们修改UserServiceImpl中的方法findAll，在里面抛出一个异常。如下所示：

  1. import com.christy.entity.User;
  2. import com.christy.mapper.UserMapper;
  3. import com.christy.service.UserService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  7. import java.util.List;
  9. /**
  10.  * @Author Christy
  11.  * @Date 2021/9/2 14:56
  12.  **/
  13. @Service
  14. public class UserServiceImpl implements UserService {
  16.     private UserMapper userMapper;
  17.     @Autowired
  18.     public UserServiceImpl(UserMapper userMapper) {
  19.         this.userMapper = userMapper;
  20.     }
  22.     @Override
  23.     public List<User> findAll() {
  24.         int i = 1/0;
  25.         return userMapper.findAll();
  26.     }
  27. }

启动项目，然后浏览器访问http://localhost:8805/user/findAll。控制台打印如下：

在抛出异常情况下，AfterReturning是不执行的；afterThrowing会执行。

注解方式

注解方式相较于上面的案例，他的控制粒度更细。什么意思呢？比如我不想某个包下的所有类中的所有方法都使用AOP。我希望指定的方法使用AOP。这个怎么做呢？看下面的案例

1.MyAspectAnnotations.java
  1. import java.lang.annotation.*;
  3. /**
  4.  * @Author Christy
  5.  * @Date 2021/9/14 14:44
  6.  **/
  7. @Target(ElementType.METHOD)
  8. @Retention(RetentionPolicy.RUNTIME)
  9. public @interface MyAspectAnnotations {
  10.     String value();
  11. }
2.MyAspect2.java
  1. import com.christy.config.annotations.MyAspectAnnotations;
  2. import lombok.extern.slf4j.Slf4j;
  3. import org.aspectj.lang.JoinPoint;
  4. import org.aspectj.lang.annotation.After;
  5. import org.aspectj.lang.annotation.Aspect;
  6. import org.aspectj.lang.annotation.Pointcut;
  7. import org.aspectj.lang.reflect.MethodSignature;
  8. import org.springframework.stereotype.Component;
  10. import java.lang.reflect.Method;
  12. /**
  13.  * @Author Christy
  14.  * @Date 2021/9/14 14:47
  15.  **/
  16. @Aspect
  17. @Component
  18. @Slf4j
  19. public class MyAspect2 {
  21.     /**
  22.      * @PointCut: 该注解在切面类中定义一个通用的切入点
  23.      *  @annotation: 用于匹配当前执行方法持有指定注解的方法；
  24.      **/
  25.     @Pointcut("@annotation(com.christy.config.annotations.MyAspectAnnotations)")
  26.     public void customerPointCut() {
  27.     }
  29.     /**
  30.      *
  31.      * @After 该注解作用方法上 代表这个方法是一个后置（最终）通知方法
  32.      *        在目标对象方法之后执行通知，有没有异常都会执行
  33.      *        该方法是没有返回值的
  34.      */
  35.     @After("customerPointCut()")
  36.     public void after(JoinPoint joinPoint){
  37.         log.info("这是一个后置通知After");
  39.         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
  40.         Method method = signature.getMethod();
  42.         MyAspectAnnotations myAspectAnnotations = method.getAnnotation(MyAspectAnnotations.class);
  43.         String value = myAspectAnnotations.value();
  44.         log.info("我是使用自定义通知注解返回的消息：{}",value);
  45.     }
  46. }
3.UserServiceImpl.java
  1. import com.christy.config.annotations.MyAspectAnnotations;
  2. import com.christy.entity.User;
  3. import com.christy.mapper.UserMapper;
  4. import com.christy.service.UserService;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.stereotype.Service;
  8. import java.util.List;
  10. /**
  11.  * @Author Christy
  12.  * @Date 2021/9/2 14:56
  13.  **/
  14. @Service
  15. public class UserServiceImpl implements UserService {
  17.     private UserMapper userMapper;
  18.     @Autowired
  19.     public UserServiceImpl(UserMapper userMapper) {
  20.         this.userMapper = userMapper;
  21.     }
  23.     @Override
  24.     @MyAspectAnnotations(value = "自定义通知注解：当前访问的方法UserServiceImpl-findAll()")
  25.     public List<User> findAll() {
  26.         return userMapper.findAll();
  27.     }
  28. }
4.测试

启动项目，浏览器访问http://localhost:8805/user/findAll。控制台打印如下：

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://hardy.blog.csdn.net/article/details/120342145

内容来源于网络，如有侵权，请联系作者删除！

spring全家桶

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com