面向切面的Spring

写在前面

  本文是博主在看完面向切面的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还可以通过构造器或属性注入

切点表达式

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

面向切面的Spring
切点表达式1
面向切面的Spring
切点表达式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)

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

    @Id
    @GeneratedValue
    private Integer id;

    private String name;

}
  1. 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);

}

  1. 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);
    }

}

第一种风格的切面

  1. 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);
    }

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

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

}
面向切面的Spring
SpringBoot已经默认开启了aop
  1. Test updateName() with UserAspectjOne

    • 6.1 先往数据库里添加一条数据
    @Test
    public void testAdd() {
        User user = new User();
        user.setName("jared");
        userDao.save(user);
    }
    
    面向切面的Spring
    添加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]

第二种风格的切面

  1. 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);
    }

}
  1. Create Configuration
@Configuration
public class AspectjConfiguration {

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

}
  1. Test updateName() with UserAspectjTwo

    • 6.1 先往数据库里添加一条数据
    @Test
    public void testAdd() {
        User user = new User();
        user.setName("jared");
        userDao.save(user);
    }
    
    面向切面的Spring
    添加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]

第三种风格的切面

  1. 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;
    }

}
  1. Create Configuration
@Configuration
public class AspectjConfiguration {

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

}
  1. Test updateName() with UserAspectjThree

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

第四种风格的切面

  1. 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;
    }

}
  1. Create Configuration
@Configuration
public class AspectjConfiguration {

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

}
  1. Test updateName() with UserAspectjFour

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

扩展@EnableAspectJAutoProxy

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

参考链接

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

上一篇:windows系统下的django开发环境搭建


下一篇:iOS11新特性:新增拖拽交互体验(一)