专栏首页happyJared面向切面的Spring

面向切面的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还可以通过构造器或属性注入

切点表达式

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

切点表达式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)

  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();
    }

}

SpringBoot已经默认开启了aop

  1. 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]

第二种风格的切面

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

添加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); }

添加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 数据库结果

数据库结果

第四种风格的切面

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

添加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的表达式定义描述

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • 为 Spring Boot 应用添加 Redis Caching

    中大型应用开发中,缓存的重要性不言而喻,早期常用的进程式类的缓存,像 EhCache 或者是 ConcurrentHashMap 这样的容器,发展到如今,更流行...

    happyJared
  • Python中的ORM工具:Peewee

    上一篇文章介绍了Pyhton中的ORM工具:SQLAlchemy。本文延续之前的风格,介绍另一个ORM模块:Peewee,希望通过简单的CRUD示例可以帮助大家...

    happyJared
  • Python中的ORM工具:SQLAlchemy

    ORM全称Object Relational Mapping, 翻译过来叫对象关系映射。在Python生态中,目前较为流行的ORM模块有SQLAlchemy和p...

    happyJared
  • Python中namedtuple使用

    致Great
  • nginx配置 location及rewrite规则详解

    用户1214487
  • awk 列求和计算

    说明: [分隔符]:一般为“\t”制表符,具体视格式而定 [列数]:统计的列数索引,从1开始

    莫斯
  • ZOJ 3620 Escape Time II

    题意:      从初始房间到达终止房间需要经过一系列的房间,没经过一个房间会得到一个价值,从一个房间到达另一个房间同时需要消耗一定的时间,在规定的时间内从初始...

    用户1624346
  • django 使用框架下auth.mod

    1.models.py   创建模型User,并继承原模型类AbstraUser(在此处我增加了一个新的字段手机号)

    py3study
  • Head First设计模式——模板方法模式

    前言:本篇我们讲解模板方法模式,我们以咖啡和茶的冲泡来学习模板方法。关于咖啡另一个设计模式例子也以咖啡来讲解,可以看下:Head First设计模式——装饰者模...

    SpringSun
  • dubbo 释放端口

    小贝壳

扫码关注云+社区

领取腾讯云代金券