Spring AOP简介
文章目录
Spring AOP简介
1. AOP 概述
1.1.1 What's AOP?
AOP(Aspect Orient Programming):面向切面编程
AOP是一种设计思想,是软件设计领域中的面向切面编程,它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式,实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。如图-1所示:
AOP与OOP(Object Orient Programming)字面意思相近,但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块,一个模块有哪些对象,对象有哪些属性),面向切面的运行期代理方式,理解为一个动态过程,可以在对象运行时动态织入一些扩展功能或控制对象执行。
1.1.2 AOP 应用场景分析?
实际项目中通常会将系统分为两大部分,一部分是核心业务,一部分是非核业务。在编程实现时我们首先要完成的是核心业务的实现,非核心业务一般是通过特定方式切入到系统中,这种特定方式一般就是借助AOP进行实现。
AOP就是要基于OCP(开闭原则),在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以"控制"对象的执行。例如AOP应用于项目中的日志处理,事务处理,权限处理,缓存处理等等。如图-2所示:
思考:现有一业务,在没有AOP编程时,如何基于OCP原则实现功能扩展?
实现对象功能扩展如图所示:
1.1.3 AOP 应用原理分析(先了解)?
Spring AOP底层基于代理机制实现功能扩展:
- 假如目标对象(被代理对象)实现接口,则底层可以采用JDK动态代理机制为目标对象创建代理对象(目标类和代理类会实现共同接口)。
- 假如目标对象(被代理对象)没有实现接口,则底层可以采用CGLIB代理机制为目标对象创建代理对象(默认创建的代理类会继承目标对象类型)。
Spring AOP 原理分析,如图-3所示:

说明:Spring boot2.x版本中AOP现在默认使用的CGLIB代理,假如需要使用JDK动态代理可以在配置文件(applicatiion.properties)中进行如下配置:
spring.aop.proxy-target-class=false1.2 AOP 相关术语分析
- 切面(aspect): 横切面对象,一般为一个具体类对象(可以借助@Aspect声明)。
- 通知(Advice):在切面的某个特定连接点上执行的动作(扩展功能),例如around,before,after等。
- 连接点(joinpoint):程序执行过程中某个特定的点,一般指被拦截到的的方法。
- 切入点(pointcut):对多个连接点(Joinpoint)一种定义,一般可以理解为多个连接点的集合。
连接点与切入点定义如图-4所示:
说明:我们可以简单的将机场的一个安检口理解为连接点,多个安检口为切入点,安全检查过程看成是通知。总之,概念很晦涩难懂,多做例子,做完就会清晰。先可以按白话去理解。
2 Spring AOP快速实践
2.1 业务描述
基于项目中的核心业务,添加简单的日志操作,借助SLF4J日志API输出目标方法的执行时长。(前提,不能修改目标方法代码-遵循OCP原则)
2.2 项目创建及配置
创建maven项目或在已有项目基础上添加AOP启动依赖:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-aop</artifactId>
</dependency>说明:基于此依赖spring可以整合AspectJ框架快速完成AOP的基本实现。AspectJ 是一个面向切面的框架,他定义了AOP的一些语法,有一个专门的字节码生成器来生成遵守java规范的class文件。
2.3 扩展业务分析及实现
2.3.1 创建日志切面类对象
将此日志切面类作为核心业务增强(一个横切面对象)类,用于输出业务执行时长,其关键代码如下:
package com.cy.pj.common.aspect;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
/**
* @Aspect 注解,描述的类为spring容器中一个切面对象类型(此类型中封装切入点与通知方法)
* 1)切入点:要执行扩展业务的方法的集合
* 2)通知方法:封装了在切入点方法上要执行的扩展业务方法
*/
@Order(1)//@Order注解用于描述切面的优先级,数字越小优先级越高,默认优先级比较低
@Aspect
@Slf4j
@Component
public class SysLogAspect {
// private static final Logger log=LoggerFactory.getLogger(SysLogAspect.class); //这句代码等效于@Slf4j注解
/**
* @Pointcut 注解用于描述切入点(在哪些点上执行扩展业务)
* bean(bean对象名字 默认为类名首字母小写):为一种切入点表达式(这个表达式中定义了哪个或哪些bean对象的方法要进行功能扩展).
* 例如,bean(sysUserServiceImpl)表达式表示名字为sysUserServiceImpl的bean对象中所有方法的集合为切入点,
* 也就是说这个sysUserServiceImpl对象中的任意方法执行时都要进行功能扩展.
*/
@Pointcut("bean(sysUserServiceImpl)")
public void doLogPointCut() {}//此方法内部不需要写具体实现,方法的方法名也是任意的
/**
* @Around 注解描述的方法为一个通知方法(即是一个服务增益方法),此方法内部可以做服务增益(扩展业务),@Around注解
* 内部要指定切入点表达式,在此切入点表达式对应的切入点方法上做功能扩展
* @param jp 表示连接点,连接点是动态确定的,用于封装正在执行的切入点方法(目标方法)信息.
* @return 目标方法的执行结果
* @throws Throwable 通知方法中执行过程出现的异常
*/
@Around("doLogPointCut()")
public Object around(ProceedingJoinPoint jp) throws Throwable {
try {
//1.记录方法开始执行时间
long start = System.currentTimeMillis();
log.info("start:{}",start);
//2.执行目标方法
Object result=jp.proceed();//最终(中间还可以调用本类其它通知或其它切面的通知)会调用目标方法
//3.记录方法结束执行时间
long after = System.currentTimeMillis();
log.info("after:{}",after);
String targetClassMethod=getTargetClassMethod(jp);
log.info("{}目标方法的执行耗时:{}",targetClassMethod,(after-start));
//4.返回目标方法的执行结果
return result;//目标方法的执行结果
}catch(Throwable e) {
log.error("目标方法执行时出现了异常:{}",e.getMessage());
throw e;
}
}
/**获取目标方法的全限定名(目标类全名(包名+类名)+方法名)*/
private String getTargetClassMethod(ProceedingJoinPoint jp) {
//1.获取目标对象的类型
Class<?> targetCls = jp.getTarget().getClass();
//2.获取目标对象的类全名(包名+类名)
String targetClsName = targetCls.getName();
//3.火球目标对象的方法名
//3.1 获取方法签名(方法签名对象中封装了方法相关信息)
MethodSignature ms = (MethodSignature)jp.getSignature();
//3.2 基于方法签名获取方法名
String methodName=ms.getName();
//4.构建方法的全限定名并返回
return targetClsName+"."+methodName;
}
}
说明:
- @Aspect 注解用于标识或者描述AOP中的切面类型,基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
- @Pointcut注解用于描述切面中的方法,并定义切面中的切入点(基于特定表达式的方式进行描述),在本案例中切入点表达式用的是bean表达式,这个表达式以bean开头,bean括号中的内容为一个spring管理的某个bean对象的名字。
- @Around注解用于描述切面中方法,这样的方法会被认为是一个环绕通知(核心业务方法执行之前和之后要执行的一个动作),@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
- ProceedingJoinPoint类为一个连接点类型,此类型的对象用于封装要执行的目标方法相关的一些信息。只能用于@Around注解描述的方法参数。
2.3.1 业务切面测试实现
启动项目测试或者进行单元测试,其中Spring Boot项目中的单元测试代码如下:
@SpringBootTest
public class AopTests {
@Autowired
private SysUserService userService;
@Test
public void testSysUserService() {
PageObject<SysUserDeptVo> po\=
userService.findPageObjects("admin",1);
System.out.println("rowCount:"+po.getRowCount());
}
}对于测试类中的userService对象而言,它有可能指向JDK代理,也有可能指向CGLIB代理,具体是什么类型的代理对象,要看application.yml配置文件中的配置。
aop:
proxy-target-class: false #false表示系统底层会基于JDK方式为目标对象创建代理对象。默认为true,表示系统底层会基于CGLIB方式为目标对象创建代理对象2.3.2 应用总结分析
在业务应用,AOP相关对象分析,如图-5所示:
2.4 扩展业务织入增强分析
2.4.1 基于JDK代理方式实现
假如目标对象有实现接口,则可以基于JDK为目标对象创建代理对象,然后为目标对象进行功能扩展,如图-6所示:
2.4.2 基于CGLIB代理方式实现
假如目标对象没有实现接口(当然实现了接口也是可以的),可以基于CGLIB代理方式为目标对象织入功能扩展,如图-7所示:
说明:目标对象实现了接口也可以基于CGLIB为目标对象创建代理对象。
3 Spring AOP编程增强
3.1切面通知应用增强
3.1.1 通知类型
在基于Spring AOP编程的过程中,基于AspectJ框架标准,spring中定义了五种类型的通知(通知描述的是一种扩展业务),它们分别是:
- @Before。
- @AfterReturning。
- @AfterThrowing。
- @After。
- @Around.重点掌握(优先级最高)
说明:在切面类中使用什么通知,由业务决定,并不是说,在切面中要把所有通知都写上。3.1.2 通知执行顺序
假如五种类型的通知全部写到一个切面对象中,其执行顺序及过程,如图-8所示:
说明:实际项目中可能不会在切面中定义所有的通知,具体定义哪些通知要结合业务进行实现。
3.1.3 通知实践过程分析
代码实践分析如下:
package com.cy.pj.common.aspect;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class SysTimeAspect {
@Pointcut("bean(sysUserServiceImpl)")
public void doTime() {
//不写具体内容
}
@Before("doTime()")
public void doBefore(JoinPoint jp){
System.out.println("@Before");
}
@After("doTime()")
public void doAfter(){
System.out.println("@After");
}
/**核心业务正常结束时执行* 说明:假如有after,先执行after,再执行returning*/
@AfterReturning("doTime()")
public void doAfterReturning(){
System.out.println("@AfterReturning");
}
/**核心业务出现异常时执行说明:假如有after,先执行after,再执行Throwing*/
@AfterThrowing("doTime()")
public void doAfterThrowing(){
System.out.println("@AfterThrowing");
}
@Around("doTime()")
public Object doAround(ProceedingJoinPoint jp)
throws Throwable{
System.out.println("@Around.before");
try{
Object obj=jp.proceed(); //执行目标方法
System.out.println("@Around.after");
return obj;
}catch(Throwable e){
//e.printStackTrace();
System.out.println(e.getMessage());
System.out.println("@Around.throwing");
throw e;
}
}
}
说明:对于@AfterThrowing通知只有在出现异常时才会执行,所以当做一些异常监控时可在此方法中进行代码实现。
课堂练习:定义一个异常监控切面,对目标页面方法进行异常监控,并以日志信息的形式输出异常
package com.cy.pj.common.aspect;
import lombok.extern.slf4j.Slf4j;
@Slf4j
@Aspect
@Component
public class SysExceptionAspect {
@AfterThrowing(pointcut="bean(\*ServiceImpl)",throwing = "e")
public void doHandleException(JoinPoint jp,Throwable e) {
MethodSignature ms\=(MethodSignature)jp.getSignature();
log.error("{}'exception msg is
{}",ms.getName(),e.getMessage());
}
}说明:AfterThrowing中throwing属性的值,需要与它描述的方法的异常参数名相同。
3.2 切入点表达式增强
Spring中通过切入点表达式定义具体切入点,其常用AOP切入点表达式定义及说明:
表-1 Spring AOP 中切入点表达式说明
| 指示符 | 作用 |
|bean| 用于匹配指定bean对象的所有方法|
| within | 用于匹配指定包下所有类内的所有方法|
|execution | 用于按指定语法规则匹配到具体方法 |
| @annotation | 用于匹配指定注解修饰的方法 |
3.2.4 bean表达式(重点)
bean表达式一般应用于类级别,实现粗粒度的切入点定义,案例分析:
- bean("userServiceImpl")指定一个userServiceImpl类中所有方法。
- bean("*ServiceImpl")指定所有后缀为ServiceImpl的类中所有方法。
说明:bean表达式内部的对象是由spring容器管理的一个bean对象,表达式内部的名字应该是spring容器中某个bean的name。
3.2.5 within表达式(了解)
within表达式应用于类级别,实现粗粒度的切入点表达式定义,案例分析:
- within("aop.service.UserServiceImpl")指定当前包中这个类内部的所有方法。
- within("aop.service.*") 指定当前目录下的所有类的所有方法。
- within("aop.service..*") 指定当前目录以及子目录中类的所有方法。
within表达式应用场景分析:
1)对所有业务bean都要进行功能增强,但是bean名字又没有规则。
2)按业务模块(不同包下的业务)对bean对象进行业务功能增强。
3.2.6 execution表达式(了解)
execution表达式应用于方法级别,实现细粒度的切入点表达式定义,案例分析:
语法:execution(返回值类型 包名.类名.方法名(参数列表))。
- execution(void aop.service.UserServiceImpl.addUser())匹配addUser方法。
- execution(void aop.service.PersonServiceImpl.addUser(String)) 方法参数必须为String的addUser方法。
- execution(* aop.service..*.*(..)) 万能配置。
3.2.7 @annotation表达式(重点)
@annotaion表达式应用于方法级别,实现细粒度的切入点表达式定义,案例分析
- @annotation(anno.RequiredLog) 匹配有此注解描述的方法。
- @annotation(anno.RequiredCache) 匹配有此注解描述的方法。
其中:RequiredLog为我们自己定义的注解,当我们使用@RequiredLog注解修饰业务层方法时,系统底层会在执行此方法时进行日志扩展操作。
课堂练习:定义一Cache相关切面,使用注解表达式定义切入点,并使用此注解对需要使用cache的业务方法进行描述,代码分析如下:
第一步:定义注解RequiredCache
package com.cy.pj.common.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* 自定义注解,一个特殊的类,所有注解都默认继承Annotation接口
* @Retention注解用于定义注解何时生效
* @Target注解用于定义注解可以描述对象
* @Documented 将注解中的文档注释在提取时也要生存API文档
* @author Administrator
*
*/
@Retention(RetentionPolicy.RUNTIME)//@Retention注解用于定义注解何时生效
@Target(ElementType.METHOD) //@Target注解用于定义注解可以描述对象
@Documented //将注解中的文档注释在提取也要生存API文档
public @interface RequiredCache {
String key() default "";
}
第二步:定义SysCacheAspect切面对象
package com.cy.pj.common.aspect;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class SysCacheAspect {
//假设这个容器就是cache(当然这个cache还需要进行更好的设计)
// private Map<Object,Object> cache=new HashMap<>();//此map为线程不安全的hashMap
private Map<Object,Object> cache=new ConcurrentHashMap<>(); //此map为线程安全的hashMap<>();//此map为线程不安全的hashMap
/**
* 基于@annotation(注解类全名 )表达式定义切入点(这种切入点通常理解为细粒度的切入点)
*/
@Pointcut("@annotation(com.cy.pj.common.annotation.RequiredCache)") //自定义注解
public void doCache() {}
@Pointcut("@annotation(com.cy.pj.common.annotation.ClearCache)") //自定义注解
public void doClearCache() {}
//FAQ分析 假如我现在需要一个清楚chache的通知方法,我们该写在哪个通知方法中?写在@AfterReturning通知方法中
@AfterReturning("doClearCache()")
public void doAfterReturing() {
cache.clear();
}
@Around("doCache()")
public Object around(ProceedingJoinPoint jp)throws Throwable{
//1.从cache中获取数据,假如cache中有我们需要的数据集则直接返回,不需要在查询数据,这样可以确保更好的性能
System.out.println("Get data from cahce");
Object result = cache.get("dept");//这个key的名字是自己随意指定的(将来可以写得更加灵活)
//FAQ分析? 如何将cache中的key定义的更加灵活(在描述切入点的方法注解中直指定)
//FAQ分析?如何获取切入点方法上注解中的key?(向获取目标方法,然后基于目标方法获取方法上的注解,再通过注解提取key的值)
if(result!=null)return result;
//2.假如cache中没有,则从数据库中去查询
result = jp.proceed();
System.out.println("Put data to cache");
//3.将查询的结果存储到cache中,便于下次查询使用
cache.put("dept", result);
return result;
}
}
第三步:使用@RequiredCache注解对特定业务目标对象中的查询方法进行描述。
@RequiredCache
@Override
public List<Map<String, Object\>> findObjects() {
….
return list;
}3.3 切面优先级设置实现
切面的优先级需要借助@Order注解进行描述,数字越小优先级越高,默认优先级比较低。例如:
定义日志切面并指定优先级。
@Order(1)
@Aspect
@Component
public class SysLogAspect {
…
}
定义缓存切面并指定优先级:
@Order(2)
@Aspect
@Component
public class SysCacheAspect {
…
}说明:当多个切面作用于同一个目标对象方法时,这些切面会构建成一个切面链,类似过滤器链、拦截器链,其执行分析如图-9所示:

3.4 关键对象与术语总结
Spring 基于AspectJ框架实现AOP设计的关键对象概览,如图-10所示:
3.5用户行为日志记录实现(实践)
以AOP方式记录项目中的用户行为信息,并将其存储到数据库
4.Spring AOP事务处理
4.1 Spring 中事务简介
4.1.1事务定义(什么是事务?)
事务(Transaction)是一个业务,是一个不可分割的逻辑工作单元,基于事务可以更好的保证业务的正确性。
4.1.2 事务特性
事务具备ACID特性,分别是:
- 原子性(Atomicity):一个事务中的多个操作要么都成功要么都失败。
- 一致性(Consistency): 例如存钱操作,存之前和存之后的总钱数应该是一致的。
- 隔离性(Isolation):事务与事务应该是相互隔离的。
- 持久性(Durability):事务一旦提交,数据要持久保存。
说明:目前市场上在事务一致性方面,通常会做一定的优化,比方说只要最终一致就可以了,这样的事务我们通常会称之为柔性事务(只要最终一致就可以了).
4.2 Spring 中事务管理
4.2.1 Spring 中事务方式概述
Spring框架中提供了一种声明式事务的处理方式,此方式基于AOP代理,可以将具体业务逻辑与事务处理进行解耦。也就是让我们的业务代码逻辑不受污染或少量污染,就可以实现事务控制。
在SpringBoot项目中,其内部提供了事务的自动配置,当我们在项目中添加了指定依赖spring-boot-starter-jdbc时,框架会自动为我们的项目注入事务管理器对象,最常用的为DataSourceTransactionManager对象。
4.2.2 Spring 中事务管理实现
本小节重点讲解实际项目中最常用的注解方式的事务管理,以注解@Transactional配置方式为例,进行实践分析。
基于@Transactional 注解进行声明式事务管理的实现步骤分为两步:
- 启用声明式事务管理,在项目启动类上添加@EnableTransactionManagement,新版本中也可不添加(例如新版Spring Boot项目)。
- 将@Transactional注解添加到合适的业务类或方法上,并设置合适的属性信息。
其代码示例如下:
@Transactional(timeout = 30,
readOnly = false,
isolation = Isolation.READ\_COMMITTED,
rollbackFor = Throwable.class,
propagation = Propagation.REQUIRED)
@Service
public class implements SysUserService {
@Transactional(readOnly = true)
@Override
public PageObject<SysUserDeptVo> findPageObjects(
String username, Integer pageCurrent) {
…
}
}其中,代码中的@Transactional注解用于描述类或方法,告诉spring框架我们要在此类的方法执行时进行事务控制,其具体说明如下:。
- 当@Transactional注解应用在类上时表示类中所有方法启动事务管理,并且一般用于事务共性的定义。
- 当@Transactional描述方法时表示此方法要进行事务管理,假如类和方法上都有@Transactional注解,则方法上的注解一般用于事务特性的定义。
@Transactional 常用属性应用说明:
- timeout:事务的超时时间,默认值为-1,表示没有超时显示。如果配置了具体时间,则超过该时间限制但事务还没有完成,则自动回滚事务。这个时间的记录方式是在事务开启以后到sql语句执行之前。
- read-only:指定事务是否为只读事务,默认值为 false;为了忽略那些不需要事务的方法,比如读取数据,可以设置read-only为true。对添加,修改,删除业务read-only的值应该为false。
- rollback-for:用于指定能够触发事务回滚的异常类型,如果有多个异常类型需要指定,各类型之间可以通过逗号分隔。
- no-rollback- for: 抛出no-rollback-for 指定的异常类型,不回滚事务。
- isolation事务的隔离级别,默认值采用 DEFAULT。当多个事务并发执行时,可能会出现脏读,不可重复读,幻读等现象时,但假如不希望出现这些现象可考虑修改事务的隔离级别(但隔离级别越高并发就会越小,性能就会越差)
Spring 中事务控制过程分析,如图-11所示:
Spring事务管理是基于接口代理(JDK)或动态字节码(CGLIB)技术,然后通过AOP实施事务增强的。当我们执行添加了事务特性的目标方式时,系统会通过目标对象的代理对象调用DataSourceTransactionManager对象,在事务开始的时,执行doBegin方法,事务结束时执行doCommit或doRollback方法。
4.2.3Spring 中事务传播特性
事务传播(Propagation)特性指"不同业务(service)对象"中的事务方法之间相互调用时,事务的传播方式,如图-12所示:
其中,常用事务传播方式如下:
- @Transactional(propagation=Propagation.REQUIRED) 。
如果没有事务创建新事务, 如果当前有事务参与当前事务, Spring 默认的事务传播行为是PROPAGATION_REQUIRED,它适合于绝大多数的情况。假设 ServiveX#methodX() 都工作在事务环境下(即都被 Spring 事务增强了),假设程序中存在如下的调用链:
Service1#method1()->Service2#method2()->Service3#method3(),那么这 3 个服务类的 3 个方法通过 Spring 的事务传播机制都工作在同一个事务中。如图-13所示:
代码示例如下:
@Transactional(propagation = Propagation.REQUIRED)
@Override
public List<Node> findZtreeMenuNodes() {
return sysMenuDao.findZtreeMenuNodes();
}当有一个业务对象调用如上方法时,此方法始终工作在一个已经存在的事务方法,或者是由调用者创建的一个事务方法中。
@Transactional(propagation=Propagation.REQUIRES_NEW)。
必须是新事务, 如果有当前事务, 挂起当前事务并且开启新事务,如图-14所示:
代码示例如下:
@Transactional(propagation = Propagation.REQUIRES\_NEW)
@Override
public void saveObject(SysLog entity) {
sysLogDao.insertObject(entity);
}当有一个业务对象调用如上业务方法时,此业务方法会始终运行在一个新的事务中。
4.3 Spring 中事务管理小结
pring 声明式事务是 Spring 最核心,最常用的功能。由于 Spring 通过 IOC 和 AOP的功能非常透明地实现了声明式事务的功能,对于一般的开发者基本上无须了解 Spring声明式事务的内部细节,仅需要懂得如何配置就可以了。但对于中高端开发者还需要了解其内部机制。
5. Spring AOP 异步操作实现
5.1异步场景分析
在开发系统的过程中,通常会考虑到系统的性能问题,提升系统性能的一个重要思想就是“串行”改“并行”。说起“并行”自然离不开“异步”,今天我们就来聊聊如何使用Spring的@Async的异步注解。
5.2 Spring 业务的异步实现
5.2.1启动异步配置
在基于注解方式的配置中,借助@EnableAsync注解进行异步启动声明,Spring Boot版的项目中,将@EnableAsync注解应用到启动类上,代码示例如下:
/**
*
@EnableAsync 注解表示进行异步启动声明(启动异步任务) spring容器启动时会创建线程池
*
*/
@EnableAsync//启动异步任务
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}5.2.2 Spring中@Async注解应用
在需要异步执行的业务方法上,使用@Async方法进行异步声明。
//@Async注解描述的方法为一个异步切入点方法(此方法会运行在spring框架提供的一个线程中)
@Async //@Async 描述的方法表示要运行在一个独立线程中(这个线程由spring内置的线程池来提供)
@Transactional(propagation = Propagation.REQUIRES_NEW) //让saveObject方法始终运行在一个自己独立的事务中
@Override
public void saveObject(SysLog entity) {
System.out.println("SysLogServiceImpl.saveObject.thread->"+Thread.currentThread().getName());
//模拟耗时操作(假设写日志是耗时的)
try {Thread.sleep(5000);} catch (Exception e) {}
sysLogDao.insertObject(entity);
}假如需要获取业务层异步方法的执行结果,可参考如下代码设计进行实现:
@Transactional(propagation = Propagation.REQUIRES\_NEW)
@Async
@Override
public Future<Integer> saveObject(SysLog entity) {
System.out.println("SysLogServiceImpl.save:"+
Thread.currentThread().getName());
int rows\=sysLogDao.insertObject(entity);
//try{Thread.sleep(5000);}catch(Exception e) {}
return new AsyncResult<Integer>(rows);
}其中,AsyncResult对象可以对异步方法的执行结果进行封装,假如外界需要异步方法结果时,可以通过Future对象的get方法获取结果。
当我们需要自己对spring框架提供的连接池进行一些简易配置,可以参考如下代码:
当我们需要自己对spring框架提供的连接池进行一些简易配置,可以参考如下代码:
spring:
task:
execution:
pool:
core-size: 3 #定义核心线程数,当池中线程没有达到这个值时,每来一个任务都会创建一个新的线程.
queue-capacity: 1 #当来了新的任务,核心线程都在忙,假如队列还没有满,则将任务先扔到队列
max-size: 256 #当核心线程数都在忙,任务队列也满了,再来新的任务在创建新的线程,最多可以创建多少个由这个参数决定
keep-alive: 60000 #当并发访问高峰期过后,有些线程可能会空闲下来,超出一定的时间,线程要被释放,这个时间的指定由这个参数决定
thread-name-prefix: cgb-db-thread- #为池中的线程起个名字的前缀说明:对于@Async注解默认会基于ThreadPoolTaskExecutor对象获取工作线程,然后调用由@Async描述的方法,让方法运行于一个工作线程,以实现异步操作。但是假如系统中的默认拒绝处理策略,任务执行过程的异常处理不能满足我们自身业务需求的话,我可以对异步线程池进行自定义.(SpringBoot中默认的异步配置可以参考自动配置对象TaskExecutionAutoConfiguration).
5.2.3Spring 自定义异步池的实现(拓展)
为了让Spring中的异步池更好的服务于我们的业务,同时也尽量避免OOM(Out Of Memory:内存溢出 ),可以自定义线程池优化设计如下:关键代码如下:
package com.cy.pj.common.config
@Slf4j
@Setter
@Configuration
@ConfigurationProperties("async-thread-pool")
public class SpringAsyncConfig implements AsyncConfigurer{
/\*\*核心线程数\*/
private int corePoolSize\=20;
/\*\*最大线程数\*/
private int maximumPoolSize=1000;
/\*\*线程空闲时间\*/
private int keepAliveTime\=30;
/\*\*阻塞队列容量\*/
private int queueCapacity\=200;
/\*\*构建线程工厂\*/
private ThreadFactory threadFactory\=new ThreadFactory() {
//CAS算法
private AtomicInteger at\=new AtomicInteger(1000);
@Override
public Thread newThread(Runnable r) {
return new Thread(r,
"db-async-thread-"+at.getAndIncrement());
}
};
@Override
public Executor getAsyncExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maximumPoolSize);
executor.setKeepAliveSeconds(keepAliveTime);
executor.setQueueCapacity(queueCapacity);
executor.setRejectedExecutionHandler((Runnable r,
ThreadPoolExecutor exe) -> {
log.warn("当前任务线程池队列已满.");
});
executor.initialize();
return executor;
}
@Override
public AsyncUncaughtExceptionHandler
getAsyncUncaughtExceptionHandler() {
return new AsyncUncaughtExceptionHandler() {
@Override
public void handleUncaughtException(Throwable ex ,
Method method , Object... params) {
log.error("线程池执行任务发生未知异常.", ex);
}
};
}}其中:@ConfigurationProperties("async-thread-pool")的含义是读取application.yml配置文件中以"async-thread-pool"名为前缀的配置信息,并通过所描述类的set方法赋值给对应的属性,在application.yml中连接器池的关键配置如下:
async-thread-pool:
corePoolSize: 20
maxPoolSize: 1000
keepAliveSeconds: 30
queueCapacity: 1000后续在业务类中,假如我们使用@Async注解描述业务方法,默认会使用ThreadPoolTaskExecutor池对象中的线程执行异步任务
6 Spring AOP中Cache操作实现(拓展)
6.1缓存场景分析
在业务方法中我们可能调用数据层方法获取数据库中数据,假如访问数据的频率比较高,为了提高的查询效率,降低数据库的访问压力,可以在业务层对数据进行缓存.
6.2Spring 中业务缓存应用实现
6.2.1启动缓存配置
在项目(SpringBoot项目)的启动类上添加@EnableCaching注解,以启动缓存配置。关键代码如下:
/\*\*
\* 异步的自动配置生效).
\* @EnableCaching 注解表示启动缓存配置
\*/
@EnableCaching
@SpringBootApplication
public class Application {
public static void main(String\[\] args) {
SpringApplication.run(Application.class, args);
}
}6.2.2业务方法上应用缓存配置
在需要进行缓存的业务方法上通过@Cacheable注解对方法进行相关描述.表示方法的返回值要存储到Cache中,假如在更新操作时需要将cache中的数据移除,可以在更新方法上使用@CacheEvict注解对方法进行描述。例如:
第一步:在相关模块查询相关业务方法中,使用缓存,关键代码如下:
/**@Cacheable 注解描述的方法为一个缓存切入点方法,此方法在执行之前首先会从缓存中取数据,缓存中没有数据,则从数据库查询*/
@Cacheable(value = "menuCache")
@Transactional(readOnly = true)
public List<Map<String,Object>> findObjects() {
....
}其中,value属性的值表示要使用的缓存对象,名字自己指定,其中底层为一个map对象,当向cache中添加数据时,key默认为方法实际参数的组合。
第二步:在相关模块更新时,清除指定缓存数据,关键代码如下:
/**@CacheEvict 注解描述的方法也是一个缓存切入点方法,此方法在执行之前首先会从缓存中取数据,缓存中没有数据,则从数据库查询
* 1) value 属性用于指定缓存对象的名称
* 2) allEntries 用于指定是否清除缓存所有数据,true表示清除缓存所有数据
* 3) beforeInvocation用于指定清楚缓存的动作在目标方法执行之前还是之后执行.这里的false表示之后
*/
@CacheEvict(value="menuCache",allEntries\=true)
@Override
public int saveObject(SysDept entity) {...}其中,allEntries表示清除所有。
说明:spring中的缓存应用原理,如图-15所示:
6.2.3Spring中自定义缓存的实现(拓展)
在Spring中默认cache底层实现是一个Map对象,假如此map对象不能满足我们实际需要,在实际项目中我们可以将数据存储到第三方缓存系统中.
Spring AOP原生方式实现(拓展)
7.1概述
Spring 整合AspectJ框架实现AOP只是Spring框架中AOP的一种实现方式,此方式相对比较简单,实现方便。但此方式底层还是要转换为Spring原生AOP的实现,Spring AOP原生方式实现的核心有三大部分构成,分别是:
- JDK代理。
- CGLIB代理。
- org.aopalliance包下的拦截体系。
7.1案例架构分析
本小节以Spring中一种原生AOP架构的基本实现为例进行原理分析和说明,其简易架构如图-16所示:
其中DefaultAdvisorAutoProxyCreator这个类功能更为强大,这个类的奇妙之处是他实现BeanPostProcessor接口,当ApplicationContext读取所有的Bean配置信息后,这个类将扫描上下文,寻找所有的Advisor对象(一个Advisor由切入点和通知组成),将这些Advisor应用到所有符合切入点的Bean中。
7.2案例业务实现
7.2.1业务描述
创建SpringBoot项目,并基于Spring原生AOP的实现为特定业务对象添加简易日志实现。
7.2.2核心业务接口定义及实现
定义RequiredLog注解,用于描述目标业务对象
package com.cy.spring.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredLog {
}
定义搜索业务接口,用于定义搜索业务规范
package com.cy.spring.aop;
public interface SearchService {
Object search(String key);
}定义搜索业务接口实现,并使用requiredLog注解描述
package com.cy.spring.aop;
import org.springframework.stereotype.Service;
import com.cy.spring.annotation.RequiredLog;
@Service
public class DefaultSearchService implements SearchService {
@RequiredLog
@Override
public Object search(String key) {
System.out.println("search by "+key);
return null;
}
}7.2.3日志Advice对象定义
定义LogAdvice对象,基于此对象为目标业务对象做日志增强。
package com.cy.spring.advisor;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class LogAdvice implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation)
throws Throwable {
System.out.println("start:"+System.currentTimeMillis());
Object result=invocation.proceed();
System.out.println("after:"+System.currentTimeMillis());
return result;
}
}其中,MethodInterceptor对象继承Advice对象,基于此对象方法可以对目标方法进行拦截。
7.2.4日志Advisor对象定义及实现
创建日志Advisor对象,在对象内部定义要切入扩展功能的点以及要应用的通知(Advice)对象。
package com.cy.spring.advisor;
import java.lang.reflect.Method;
import org.springframework.stereotype.Component;
import com.cy.spring.annotation.RequiredLog;
@Component
public class LogAdvisor extends StaticMethodMatcherPointcutAdvisor {
private static final long serialVersionUID = 7022316764822635205L;
public LogMethodMatcher() {
//在特定切入点上要执行的通知
setAdvice(new LogAdvice());
}
//Pointcut
//方法返回值为true时,则可以为目标方法对象创建代理对象
@Override
public boolean matches(Method method,Class<?> targetClass) {
try {
Method targetMethod=
targetClass.getMethod(method.getName(),
method.getParameterTypes());
return targetMethod.isAnnotationPresent(RequiredLog.class);
}catch(Exception e) {
return false;
}
}
}其中,StaticMethodMatcherPointcutAdvisor类为Spring框架中定义的一种Advisor,我们自己写的Advisor可以直接继承此类进行资源整合。
7.2.5日志业务单元测试实现
基于Spring boot项目进行单元测试:
package com.cy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.cy.spring.aop.SearchService;
@SpringBootTest
public class CgbSbootAop01ApplicationTests {
@Autowired
private SearchService searchService;
@Test
public void testSearch() {
//System.out.println(searchService);
searchService.search("tedu");
}
}说明:在spring 框架中,很多功能都是原生AOP进行了功能的扩展和实现。
8 Spirng AOP总结
8.1重难点分析
- AOP 是什么,解决了什么问题,实现原理,应用场景。
AOP(Aspect Orient Programming)是一种设计思想,是软件设计领域中的面向切面编程,
解决的问题: 它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式,实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。
AOP实现原理:Spring AOP底层基于代理机制实现功能扩展:
(1). 假如目标对象(被代理对象)实现接口,则底层可以采用JDK动态代理机制为目标对象创建代理对象(目标类和代理类会实现共同接口)。
(2). 假如目标对象(被代理对象)没有实现接口,则底层可以采用CGLIB代理机制为目标对象创建代理对象(默认创建的代理类会继承目标对象类型)
应用场景:AOP就是要基于OCP(开闭原则),在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以"控制"对象的执行。例如AOP应用于项目中的日志处理,事务处理,权限处理,缓存处理等等
- AOP 编程基本步骤及实现过程(以基于AspectJ框架实现为例)。
- AOP 编程中的核心对象及应用关系。
- AOP 思想在Spring中的实现原理分析。
- AOP 编程中基于注解方式的配置实现。(@Aspect,@PointCut,@Around,...)
- AOP 编程中基于注解方式的事务控制。(@Transactional)
- AOP 编程中异步操作的实现?(@EnableAsync,@Async)
- AOP 编程中的缓存应用?(@EnableCaching,@Cacheable,@CacheEvict)
8.1FAQ分析
- 什么是OCP原则(开闭原则)?
- 什么是DIP原则 (依赖倒置)?
- 什么是单一职责原则(SRP)?
- Spring 中AOP的有哪些配置方式?(XML,注解)
- Spring 中AOP 的通知有哪些基本类型?(5种)
@Before。
@AfterReturning。
@AfterThrowing。
@After。
@Around.重点掌握(优先级最高) - Spring 中AOP是如何为Bean对象创建代理对象的?(JDK,CGLIB)
- Spring 中AOP切面的执行顺序如何指定?(@Order)
- Spring 单体架构项目中事务的控制要通过Connection对象实现,?
- Spring 如何保证一个线程一个Connection对象?借助ThreadLocal实现.?
- 多个事务并发执行时可能会出现什么问题?(脏读,不可重复读,幻影读,又叫幻读)
what's 脏读(dirty read)?
在一个事务中,读取到另一个事务未提交更新的数据,即读取到了脏 数据。提示:需要将数据库的事务隔离级别设置为最低,才能够看到脏读现象。
what's 不可重复读(unrepeatable read)?
对同一记录的两次读取结果不一致,因为在两次查询期间,有另一事务对该记录做了修改(是针对修改操作),这个过程叫做不可重复读。
what's 幻读(虚读)(phantom read)?
对同一张表的两次查询结果不一致,因为在两次查询期间,有另一事务进行了插入或者是删除操作(是针对插入或删除操作);这个过程叫做幻读。
注意:mysql默认的是不允许出现脏读和不可重复读 - 如何理解数据库中的的悲观锁和乐观锁?
- 你了解事务的隔离级别吗?知道具体的应用场景吗?
- 事务隔离级别分四个等级,在相同数据环境下,对数据执行相同的操作,设置不同的隔离级别,可能导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力也是不同的。
1、READ UNCOMMITTED(读未提交数据)
安全性最差,可能出现任何事务并发问题(比如脏读、不可以重复读、幻读等)
但性能最好(不使用!!)
2、READ COMMITTED(读已提交数据)(Oracle默认)
安全性较差
性能较好
可以防止脏读,但不能防止不可重复读,也不能防止幻读;
3、REPEATABLE READ(可重复读)(MySQL默认)
安全性较高
性能较差
可以防止脏读和不可重复读,但不能防止幻读问题;
4、SERIALIZABLE(串行化)
安全性最高,不会出现任何并发问题,因为它对同一数据的访问是串行的,非并发访问;
性能最差;(不使用!!)
MySQL的默认隔离级别为REPEATABLE READ,即可以防止脏读和不可重复读
评论
登录后参与技术讨论,分享你的经验与见解。
登录 / 注册暂无评论