面向切面的Spring

2022-02-11 19:25:35

写在前面

本文是博主在看完面向切面的Spring（《Spring实战》第4章）后的一些实践笔记。
为什么要用AOP呢？作者在书中也明确提到了，使用AOP，可以让代码逻辑更多的去关注自己本身的业务，而不用混杂和关注一些其它的东西。包括：安全，缓存，事务，日志等等。

名词概念

通知（Advice）

定义了切面做什么和什么时候去做。简单点来说，就是AOP执行时会调用的方法，通知除了定义切面要完成的工作(What)，还会定位什么时候(When)去履行这项工作，是在方法调用前，还是调用之后，还是前后都是，还是抛出异常时

在切面定义中，一共有以下五种通知类型

类型	作用
Before	某方法调用之前发出通知
After	某方法完成之后发出通知，不考虑方法运行的结果
AfterReturning	将通知放置在被通知的方法成功执行之后
AfterThrowing	将通知放置在被通知的方法抛出异常之后
Around	通知包裹在被通知的方法的周围，在方法调用之前和之后发出（环绕通知 = 前置 + 目标方法执行 + 后置通知）

切点，也叫切入点（Pointcut）

上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有十几个连接点了对吧，但是你并不想在所有方法附件都使用通知（使用叫织入，下面再说），你只是想让其中几个，在调用这几个方法之前、之后或者抛出异常时干点什么，那么就用切入点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法

连接点，也叫参加点（JoinPoint）

连接点是切面在应用程序执行过程中插入的地方，可能是方法调用（前、后）的时候，也可能是异常抛出的时候。连接点如果可以说是切点的全集，那么切点就是连接点的子集

切面（Aspect）

切面其实就是通知和切点的结合。通知说明了干什么和什么时候干（通过方法上使用@Before、@After等就能知道），则切点说明了在哪干（指定到底是哪个方法），这就组成了一个完整的切面定义

Spring对AOP的支持

Spring建议在Java中编写AOP，虽然用XML也可以实现
Spring通过使用代理类，在运行阶段将切面编织进bean中
Spring只支持方法级别的连接点，不像AspectJ还可以通过构造器或属性注入

切点表达式

切点表达式算是一些比较概念性的知识，下面截了两个图供大家参考参考

切点表达式1

切点表达式2

看得头晕了吧，不过好在只有execution()是用来执行匹配的，剩下的都是为了限制或定制连接点要匹配的位置
以下是execution()定义的格式（其中，带?号的为可选，否则必须给出） :

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern)

还是举个真实栗子模仿一下吧

execution(* com.example.aspectj.UserDao.updateName(..))

execution：用于定义什么方法执行时会被触发，这里是指com.example.aspectj包下的UserDao接口中的updateName方法执行时触发
* ：忽略方法返回值类型
(..) ：匹配任意参数

实战测试（SpringBoot + JPA）

Create Entity

@Table(name = "tb_user")
@Entity
@Data
public class User {

    @Id
    @GeneratedValue
    private Integer id;

    private String name;

}

Create Dao

public interface UserDao extends JpaRepository<User, Integer> {

    @Modifying
    @Transactional
    @Query("update User u set u.name = ?1 where u.id = ?2")
    int updateName(String name, int id);

}

Create Service

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    @Transactional
    public void save(User user) {
        userDao.save(user);
    }

    public void update(String name, int id) {
        userDao.updateName(name, id);
    }

}

第一种风格的切面

Create Aspect（使用了@Before、@After、@AfterReturning和@AfterThrowing这四个注解）

@Aspect
public class UserAspectjOne {

    @Resource
    private UserService userService;

    @Before("execution(* com.example.aspectj.UserDao.updateName(..))")
    public void before() {
        System.out.println("1.------------before()");
    }

    @After("execution(* com.example.aspectj.UserDao.updateName(..))")
    public void after() {
        System.out.println("1.------------after()");
    }

    @AfterReturning("execution(* com.example.aspectj.UserDao.updateName(..))")
    public void afterReturning() {
        System.out.println("1.------------afterReturning()");
        User user = new User();
        user.setName("afterReturning1");
        userService.save(user);
    }

    @AfterThrowing("execution(* com.example.aspectj.UserDao.updateName(..))")
    public void afterThrowing() {
        System.out.println("1.------------afterThrowing()");
        User user = new User();
        user.setName("afterThrowing1");
        userService.save(user);
    }

}

Create Configuration

@Configuration
// @EnableAspectJAutoProxy //实测可以不添加该注解，因为SpringBoot中已经默认开启了AOP功能
public class AspectjConfiguration {

    @Bean
    public UserAspectjOne userAspectjOne() {
        return new UserAspectjOne();
    }

}

SpringBoot已经默认开启了aop

Test updateName() with UserAspectjOne

6.1 先往数据库里添加一条数据

@Test
public void testAdd() {
    User user = new User();
    user.setName("jared");
    userDao.save(user);
}

添加User

- 6.2 测试正常执行updateName()
``` java
@Test
public void testUpdateName() {
    userService.update("jared qiu", 1);
}
```

- 6.3.1 打印结果 

![输出结果][5]

- 6.3.2 数据库结果

![数据库结果][6]

- 6.4 测试非正常执行updateName()，只需要把UserDao类中updateName()上的@Modifying或者@Transactional注解去掉即可
``` java
@Test
public void testUpdateName() {
    userService.update("error jared qiu", 1);
}
```

- 6.5.1 打印结果 

![输出结果][7]

- 6.5.2 数据库结果

![数据库结果][8]

第二种风格的切面

Create Aspect（依旧使用了@Before、@After、@AfterReturning和@AfterThrowing这四个注解，但新增了@Pointcut注解，把切面的定义抽离了出来进行统一）

@Aspect
public class UserAspectjTwo {

    @Resource
    private UserService userService;

    @Pointcut("execution(* com.example.aspectj.UserDao.updateName(..))")
    public void pointcut() {
    }

    @Before("pointcut()")
    public void before() {
        System.out.println("2.------------before()");
    }

    @After("pointcut()")
    public void after() {
        System.out.println("2.------------after()");
    }

    @AfterReturning("pointcut()")
    public void afterReturning() {
        System.out.println("2.------------afterReturning()");
        User user = new User();
        user.setName("afterReturning2");
        userService.save(user);
    }

    @AfterThrowing("pointcut()")
    public void afterThrowing() {
        System.out.println("2.------------afterThrowing()");
        User user = new User();
        user.setName("afterThrowing2");
        userService.save(user);
    }

}

Create Configuration

@Configuration
public class AspectjConfiguration {

    @Bean
    public UserAspectjTwo userAspectjTwo() {
        return new UserAspectjTwo();
    }

}

Test updateName() with UserAspectjTwo

6.1 先往数据库里添加一条数据

@Test
public void testAdd() {
    User user = new User();
    user.setName("jared");
    userDao.save(user);
}

添加User

- 6.2 测试正常执行updateName()
``` java
@Test
public void testUpdateName() {
    userService.update("jared qiu", 1);
}
```

- 6.3.1 打印结果 

![输出结果][10]

- 6.3.2 数据库结果

![数据库结果][11]

- 6.4 测试非正常执行updateName()，只需要把UserDao类中updateName()上的@Modifying或者@Transactional注解去掉即可
``` java
@Test
public void testUpdateName() {
    userService.update("error jared qiu", 1);
}
```

- 6.5.1 打印结果 

![输出结果][12]

- 6.5.2 数据库结果

![数据库结果][13]

第三种风格的切面

Create Aspect（使用了@Around这个环绕注解）

@Aspect
public class UserAspectjThree {

    @Resource
    private UserService userService;

    /**
     * 方法的返回值类型须与切面所在方法的返回值类型保持一致
     */
    @Around("execution(* com.example.aspectj.UserDao.updateName(..))")
    public int around(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("3.------------before()");
            System.out.println("3.------------after()");
            joinPoint.proceed();//用于启动目标方法执行（必须）
            System.out.println("3.------------afterReturning()");
            User user = new User();
            user.setName("afterReturning3");
            userService.save(user);
        } catch (Throwable e) {
            System.out.println("3.------------afterThrowing()");
            User user = new User();
            user.setName("afterThrowing3");
            userService.save(user);
        }
        return 1;
    }

}

Create Configuration

@Configuration
public class AspectjConfiguration {

    @Bean
    public UserAspectjThree userAspectjThree() {
        return new UserAspectjThree();
    }

}

Test updateName() with UserAspectjThree
- 6.1 先往数据库里添加一条数据
```
@Test
public void testAdd() {
    User user = new User();
    user.setName("jared");
    userDao.save(user);
}
```
添加User
- 6.2 测试正常执行updateName()
```
@Test
public void testUpdateName() {
    userService.update("jared qiu", 1);
}
```
- 6.3.1 打印结果
输出结果
- 6.3.2 数据库结果
数据库结果
- 6.4 测试非正常执行updateName()，只需要把UserDao类中updateName()上的@Modifying或者@Transactional注解去掉即可
```
@Test
public void testUpdateName() {
    userService.update("error jared qiu", 1);
}
```
- 6.5.1 打印结果
输出结果
- 6.5.2 数据库结果
数据库结果

第四种风格的切面

Create Aspect（依旧使用了@Around这个环绕注解，但加入了@Pointcut注解和传递了参数）

@Aspect
public class UserAspectjFour {

    @Resource
    private UserService userService;

    @Pointcut("execution(* com.example.aspectj.UserDao.updateName(String,*)) && args(name,*)")
    public void pointcut(String name) {
    }

    @Around(value = "pointcut(name)", argNames = "joinPoint,name")
    public int around(ProceedingJoinPoint joinPoint, String name) {
        try {
            System.out.println("4.------------before()");
            System.out.println("4.------------after()");
            Object proceed = joinPoint.proceed();
            System.out.println(proceed);
            System.out.println("4.------------afterReturning()");
            User user = new User();
            user.setName("afterReturning4" + name);
            userService.save(user);
        } catch (Throwable e) {
            System.out.println("4.------------afterThrowing()");
            User user = new User();
            user.setName("afterThrowing4" + name);
            userService.save(user);
        }
        return 1;
    }

}

Create Configuration

@Configuration
public class AspectjConfiguration {

    @Bean
    public UserAspectjFour userAspectjFour() {
        return new UserAspectjFour();
    }

}

Test updateName() with UserAspectjFour
- 6.1 先往数据库里添加一条数据
```
@Test
public void testAdd() {
    User user = new User();
    user.setName("jared");
    userDao.save(user);
}
```
添加User
- 6.2 测试正常执行updateName()
```
@Test
public void testUpdateName() {
    userService.update("jared qiu", 1);
}
```
- 6.3.1 打印结果
输出结果
- 6.3.2 数据库结果
数据库结果
- 6.4 测试非正常执行updateName()，只需要把UserDao类中updateName()上的@Modifying或者@Transactional注解去掉即可
```
@Test
public void testUpdateName() {
    userService.update("error jared qiu", 1);
}
```
- 6.5.1 打印结果
输出结果
- 6.5.2 数据库结果
数据库结果

扩展@EnableAspectJAutoProxy

表示开启AOP代理自动配置，如果配@EnableAspectJAutoProxy表示使用cglib进行代理对象的生成；设置@EnableAspectJAutoProxy(exposeProxy=true)表示通过aop框架暴露该代理对象，使得aopContext能够直接访问
从@EnableAspectJAutoProxy的定义可以看出，它引入AspectJAutoProxyRegister.class对象，该对象是基于注解@EnableAspectJAutoProxy注册了一个AnnotationAwareAspectJAutoProxyCreator，通过调用AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry)，注册了一个aop代理对象生成器

@EnableAspectJAutoProxy

AspectJAutoProxyRegistrar

参考链接

AspectJ
Spring AOP系列
 Spring AOP中JoinPoint的表达式定义描述

码农公寓