面向切面的 Spring

最新推荐文章于 2022-07-05 17:05:42 发布
最新推荐文章于 2022-07-05 17:05:42 发布
阅读量146 收藏
点赞数
分类专栏： 草根Java之路 文章标签： AcpectJ Aop 读书笔记
欢迎关注我的个人公众号：超级码里奥。如果这对您有帮助，欢迎点赞和分享，转载请注明出处
本文链接：https://blog.csdn.net/qq_28804275/article/details/80891892
版权

写在前面

  本文是博主在看完面向切面的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的表达式定义描述

happyJared
关注
专栏目录
Spring——面向切面编程(AOP)
行者无疆的博客
06-05 3819
本文介绍了切向切面编程(AOP)中的各个概念，并用两个案例分别讲解了如何通过注解和XML配置的方式使用AOP。
@Pointcut 使用@annotation 带参数
weixin_33676492的博客
02-27 1万+
2019独角兽企业重金招聘Python工程师标准>>> ...
springboot+redis+lua脚本进行接口限流，解决高并发计数不准确问题
liu649983697的专栏
06-06 1705
springboot接口限流 redis + lettuce+lua脚本+自定义注解实现，配置redis集群高可用，
SpringBoot实现图形验证码生成与校验
lixianhe的博客
05-02 1万+
SpringBoot实现图形验证码生成与校验
Java 开发工程师 面试题(一)
探索技术与实践的旅程，分享编程经验与工具使用心得，助力开发者提升技能。
07-05 1941
1. 注解@Transactional事务的实现 2. Spring事务的 4个隔离级别 + 7个传播行为 3. IOC的三种注入方式 4. aop的5个通知类型 5. 分布式锁的作用 6. 浏览器发起一个请求的过程 7. http协议 8. 有状态bean 和 无状态bean 9. options请求（跨域预检） 10. http的9种 常见的请求方式 11. 如何证明当前对象是单例的 12. 多线程下，如何解决成员变量 13. transient 关键字作用 14. servlet的 / 和 /* 的区
spring AOP的@Around输出请求参数和返回参数
热门推荐
东东
11-08 3万+
先把我的打印日志代码贴出来 package com.zhd.exploit.api.config; import java.util.HashMap; import java.util.Map; import java.util.UUID; import javax.servlet.http.HttpServletResponseWrapper; import org.aspectj.lan...
使用Spring AOP切面解决数据库读写分离
Sam_Deep_Thinking
07-31 1万+
为了减轻数据库的压力，一般会使用数据库主从(master/slave)的方式，但是这种方式会给应用程序带来一定的麻烦，比如说，应用程序如何做到把数据写到master库，而读取数据的时候，从slave库读取。如果应用程序判断失误，把数据写入到slave库，会给系统造成致命的打击。 解决读写分离的方案很多，常用的有SQL解析、动态设置数据源。SQL解析主要是通过分析sql语句是insert/se
Spring AOP面向切面编程实现原理方法详解
08-18
Spring AOP面向切面编程实现原理方法详解 面向切面编程（AOP）是Spring框架中的一个重要内容，通过预编译方式和运行期动态代理实现，在不修改源代码的情况下，给程序动态统一添加功能的一种技术。AOP可以对业务逻辑...
面向切面的Spring
qq_44347658的博客
09-10 166
面向切面的Spring 面向切面编程基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 一.什么是面向切面编程? 切面能够帮助我们模块化横切关注点，简而言之，横切关注点可以被描述为影响应用多处的功能。 实现通用功能的方法常见有继承和委托，继承会导致一个脆弱的对象体系，委托需要对委托对象进行复杂的调用。而切面提供了取代继承和委托的另一种方案，在很多场景下更加清晰简洁。横切关注点被模块化为一种特殊的类即切面。 1.定义AOP术语 AOP也形成了自己的术语：通知、切点和连
详解spring面向切面aop拦截器
08-31
Spring 面向切面 AOP 拦截器详解 Spring 框架中有多种概念和名词，例如过滤器、拦截器、AOP 等。这篇文章主要介绍了 Spring 面向切面 AOP 拦截器的详细知识点。 AOP 概念 AOP（Aspect-Oriented Programming）是...
看完还不会spring中的面向切面,你来打我
见过水星的博客
05-25 793
本文主要介绍内容: 面向切面编程的基本原理 通过POJO创建切面 使用@AspectJ注解 为AspectJ切面注入依赖 软件系统的功能需要用到应用程序的多个地方，但是我们又不想在每个点都明确调用它们。日志、 安全和事务管理的确都很重要，但它们是否为应用对象主动参与的行为呢？如果让应用对象只关注于自己所针对的业务领域问题，而其他方面 的问题由其他应用对象来处理，这会不会更好呢？ 在软件开发中，散布于应用中多处的功能被称为横切关注点（cross-cutting concern）。通常来讲，这些横切关注点从
spring AOP切面实现多数据源、数据库切换
fenlin88l的博客
04-19 5483
应用场景： 对于数据量在1千万，单个mysql数据库就可以支持，但是如果数据量大于这个数时，那么查询的性能就会很低或是两个不同的数据库时。此时需要对数据库做水平切分，常见的做法是按照用户的账号进行hash，然后选择对应的数据库，以下是在springboot项目中利用AOP面向切面技术实现两个不同数据库之间的来回切换功能 一 配置数据源连接池 application.yml或ap...
log4j2-spring.xml
xu990128638的专栏
10-22 979
<?xml version="1.0" encoding="UTF-8"?> <!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出--> <!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数--> <configuration monitorInterval="5"> <!...
Spring-Aop切面+自定义注解将日志记录存储到数据库
qq_42112846的博客
07-30 2万+
SpringAop切面+自定义注解实现日志记录   在之前的SpringAop当中，实现了对service层的方法定义了切入点，从而在执行service层的方法的时候会自动加入事务，而这些操作，都是在配置文件当中去实现的；   在这篇博文当中，会一不同的方式来实现日志事务的添加，用的式注解的方式，而且切入点和事务都是一起定义在切面类当中的；   首先来说明一些概念：   Sprin...
Spring 面向切面编程AOP实现详解
08-25
Spring 面向切面编程AOP实现详解 面向切面编程（AOP）是一种编程技术，旨在将横切关注点从业务逻辑中分离出来，提高系统的可扩展性和可维护性。Spring 作为一个流行的 Java 框架，提供了完备的 AOP 实现机制。 1. ...
面向过程,面向对象,面向接口,面向切面的区别
小爷欣欣
07-08 4426
点击打开链接 上面的连接结合实例很好的解释了四者的区别, 简单理解: 面向过程:把所有的变量,方法写在一个主方法里面,强调使用正常的对事物的处理方式,比如人做饭的过程有买菜,洗菜,切菜,炒菜的过程,,在面向过程中则逐一顺次写出来. 面向对象:把数据以及对数据的操作放在一起，作为一个相互依存的整体，就是我们所说的对象。与面向过程不同的是,它把中心放在人身上,把买菜洗菜切菜,炒菜的行为,封装到
SSH事务的配置详解
学无止境
08-11 1253
其中: &lt;tx:method &gt;的属性详解 属性 类型 默认值 说明 propagation Propagation枚举 REQUIRED 事务传播属性 isolation isolation枚举 DEFAULT(所用数据库默认级别) 事务隔离级别 r...
Spring Data JPA 的时间注解：@CreatedDate 和 @LastModifiedDate
happyJared
12-04 1万+
选择 Spring Data JPA 框架开发时，常用在实体和字段上的注解有@Entity、@Id、@Column等。在表设计规范中，通常建议保留的有两个字段，一个是更新时间，一个是创建时间。Spring Data JPA 提供了相应的时间注解，只需要两步配置，就可以帮助开发者快速实现这方面的功能。 在实体类上加上注解 @EntityListeners(AuditingEntityListene...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值