Spring AOP 学习总结

最新推荐文章于 2024-07-11 14:56:13 发布

m0_46525448

最新推荐文章于 2024-07-11 14:56:13 发布

阅读量159

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/m0_46525448/article/details/109398086

版权

1.1 AOP 概述

1.1.1 AOP 是什么？

AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。如图-1所示：
在这里插入图片描述
AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切面的运行期代理方式，理解为一个动态过程，可以在对象运行时动态织入一些扩展功能或控制对象执行。

1.1.2 AOP 应用场景分析？

实际项目中通常会将系统分为两大部分，一部分是核心业务，一部分是非核业务。在编程实现时我们首先要完成的是核心业务的实现，非核心业务一般是通过特定方式切入到系统中，这种特定方式一般就是借助AOP进行实现。
AOP就是要基于OCP(开闭原则)，在不改变原有系统核心业务代码的基础上动态添加一些扩展功能并可以"控制"对象的执行。例如AOP应用于项目中的日志处理，事务处理，权限处理，缓存处理等等。如图-2所示：
在这里插入图片描述

1.1.3 Spring AOP 应用原理分析(先了解)？

Spring AOP底层基于代理机制(动态方式)实现功能扩展：

假如目标对象(被代理对象)实现接口，则底层可以采用JDK动态代理机制为目标对象创建代理对象（目标类和代理类会实现共同接口）。
假如目标对象(被代理对象)没有实现接口，则底层可以采用CGLIB代理机制为目标对象创建代理对象（默认创建的代理类会继承目标对象类型）。
Spring AOP 原理分析，如图-3所示：

1.2 Spring 中AOP 相关术语分析

▪ 切面(aspect): 横切面对象,一般为一个具体类对象(可以借助@Aspect声明)。
▪ 通知(Advice):在切面的某个特定连接点上执行的动作(扩展功能)，例如around,before,after等。
▪ 连接点(joinpoint):程序执行过程中某个特定的点，一般指向被拦截到的目标方法。
▪ 切入点(pointcut):对多个连接点(Joinpoint)一种定义,一般可以理解为多个连接点的集合。
连接点与切入点定义如图-4所示：
在这里插入图片描述

2 Spring AOP快速实践

2.1 业务描述

基于项目中的核心业务，添加简单的日志操作，借助SLF4J日志API输出目标方法的执行时长。(前提，不能修改目标方法代码-遵循OCP原则)

2.3 扩展业务分析及实现

2.3.1 创建日志切面类对象

将此日志切面类作为核心业务增强（一个横切面对象）类，用于输出业务执行时长，其关键代码如下：
package com.cy.pj.common.aspect;
@Aspect
@Slf4j
@Component
public class SysLogAspect {
@Pointcut(“bean(sysUserServiceImpl)”)
public void doLogPointCut() {}

 @Around("doLogPointCut()")
 public Object around(ProceedingJoinPoint jp)
 throws Throwable{
	 try {
	   log.info("start:{}"+System.currentTimeMillis());
	   Object result=jp.proceed();//最终会调用目标方法
	   log.info("after:{}"+System.currentTimeMillis());
	   return result;
	 }catch(Throwable e) {
	   log.error("after:{}",e.getMessage());
	   throw e;
	 }
 }

}
说明：
▪ @Aspect 注解用于标识或者描述AOP中的切面类型，基于切面类型构建的对象用于为目标对象进行功能扩展或控制目标对象的执行。
▪ @Pointcut注解用于描述切面中的方法，并定义切面中的切入点（基于特定表达式的方式进行描述），在本案例中切入点表达式用的是bean表达式，这个表达式以bean开头，bean括号中的内容为一个spring管理的某个bean对象的名字。
▪ @Around注解用于描述切面中方法，这样的方法会被认为是一个环绕通知（核心业务方法执行之前和之后要执行的一个动作），@Aournd注解内部value属性的值为一个切入点表达式或者是切入点表达式的一个引用(这个引用为一个@PointCut注解描述的方法的方法名)。
▪ ProceedingJoinPoint类为一个连接点类型，此类型的对象用于封装要执行的目标方法相关的一些信息。只能用于@Around注解描述的方法参数。

2.3.3 应用总结分析

在业务应用,AOP相关对象分析,如图-5所示:
在这里插入图片描述

2.4 扩展业务织入增强分析

2.4.1 基于JDK代理方式实现

假如目标对象有实现接口,则可以基于JDK为目标对象创建代理对象,然后为目标对象进行功能扩展,如图-6所示：
在这里插入图片描述
说明：假如目标对象类型没有实现接口，则不允许使用JDK代理。

2.4.2 基于CGLIB代理方式实现

假如目标对象没有实现接口(当然实现了接口也是可以的)，可以基于CGLIB代理方式为目标对象织入功能扩展，如图-7所示：
在这里插入图片描述
说明：目标对象实现了接口也可以基于CGLIB为目标对象创建代理对象。但是目标对象类型假如使用了final修饰，则不可以使用CGBLIB。

3 Spring AOP编程增强

3.1.1 通知类型

在基于Spring AOP编程的过程中，基于AspectJ框架标准，spring中定义了五种类型的通知(通知-Advice描述的是一种扩展业务)，它们分别是：
▪ @Before。
▪ @AfterReturning。
▪ @AfterThrowing。
▪ @After。
▪ @Around.重点掌握（优先级最高）
说明：在切面类中使用什么通知，由业务决定，并不是说，在切面中要把所有通知都写上。

3.1.2 通知执行顺序

假如这些通知全部写到一个切面对象中，其执行顺序及过程，如图-8所示（但是这个顺序现在在springboot工程的不同版本中可能会有一些不同）：
在这里插入图片描述
说明：实际项目中可能不会在切面中定义所有的通知，具体定义哪些通知要结合业务进行实现。
3.1.3 通知实践过程分析
代码实践分析如下：

package com.cy.pj.common.aspect;
@Component
@Aspect
public class SysTimeAspect {
	@Pointcut("bean(sysUserServiceImpl)")
	public void doTime(){}

	@Before("doTime()")
	public void doBefore(){
		System.out.println("time doBefore()");
	}
	@After("doTime()")
	public void doAfter(){
		System.out.println("time doAfter()");
	}
	/**核心业务正常结束时执行* 说明：假如有after，先执行after,再执行returning*/
	@AfterReturning("doTime()")
	public void doAfterReturning(){
		System.out.println("time doAfterReturning");
	}
	/**核心业务出现异常时执行说明：假如有after，先执行after,再执行Throwing*/
	@AfterThrowing("doTime()")
	public void doAfterThrowing(){
		System.out.println("time doAfterThrowing");
	}
	@Around("doTime()")
	public Object doAround(ProceedingJoinPoint jp)
			throws Throwable{
		System.out.println("doAround.before");
         try{
		 Object obj=jp.proceed();
           System.out.println("doAround.after");
          return obj;
		 }catch(Throwable e){
          System.out.println(e.getMessage());
          throw e;
         }
		
	}
}

3.2 切入点表达式增强

Spring中通过切入点表达式定义具体切入点，其常用AOP切入点表达式定义及说明：
表-1 Spring AOP 中切入点表达式说明

指示符	作用
bean	用于匹配指定bean对象的所有方法
within	用于匹配指定包下所有类内的所有方法
execution	用于按指定语法规则匹配到具体方法
@annotation	用于匹配指定注解修饰的方法

3.2.1 bean表达式（重点）

bean表达式一般应用于类级别，实现粗粒度的切入点定义，案例分析：
▪ bean(“userServiceImpl”)指定一个userServiceImpl类中所有方法。
▪ bean("*ServiceImpl")指定所有后缀为ServiceImpl的类中所有方法。
说明:bean表达式内部的对象是由spring容器管理的一个bean对象,表达式内部的名字应该是spring容器中某个bean的name。

3.2.4 @annotation表达式（重点）

@annotaion表达式应用于方法级别，实现细粒度的切入点表达式定义，案例分析
▪ @annotation(anno.RequiredLog) 匹配有此注解描述的方法。
▪ @annotation(anno.RequiredCache) 匹配有此注解描述的方法。
其中:RequiredLog为我们自己定义的注解,当我们使用@RequiredLog注解修饰业务层方法时,系统底层会在执行此方法时进行日扩展操作。
课堂练习:定义一Cache相关切面,使用注解表达式定义切入点,并使用此注解对需要使用cache的业务方法进行描述,代码分析如下:
第一步:定义注解RequiredCache

package com.cy.pj.common.annotation;
/**
 * 自定义注解,一个特殊的类,所有注解都默认继承Annotation接口
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiredCache {
   //...
}

第二步:定义SysCacheAspect切面对象。

package com.cy.pj.common.aspect;
@Aspect
@Component
public class SysCacheAspect {
	    @Pointcut("@annotation(com.cy.pj.common.annotation.RequiredCache)")
	  public void doCache() {}

	  @Around("doCache()")
	  public Object around(ProceedingJoinPoint jp)
    throws Throwable{
		  System.out.println("Get data from cache");
		  Object obj=jp.proceed();
		  System.out.println("Put data to cache");
		  return obj;
	  }
    
}

第三步:使用@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所示：

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。当多个事务并发执行时，可能会出现脏读，不可重复读，幻读等现象时，但假如不希望出现这些现象可考虑修改事务的隔离级别(但隔离级别越高并发就会越小，性能就会越差)

脏读（Dirty Read）
A事务执行过程中，B事务读取了A事务的修改。但是由于某些原因，A事务可能没有完成提交，发生RollBack了操作，则B事务所读取的数据就会是不正确的。这个未提交数据就是脏读（Dirty Read）。
不可重复读（Nonrepeatable Read）
B事务读取了两次数据，在这两次的读取过程中A事务修改了数据，B事务的这两次读取出来的数据不一样。B事务这种读取的结果，即为不可重复读（Nonrepeatable
Read）。
幻读（Phantom Read） B事务读取了两次数据，在这两次的读取过程中A事务添加了数据，B事务的这两次读取出来的集合不一样。

Spring 中事务控制过程分析,如图-11所示:
在这里插入图片描述
Spring事务管理是基于接口代理（JDK）或动态字节码（CGLIB）技术，然后通过AOP实施事务增强的。当我们执行添加了事务特性的目标方式时，系统会通过目标对象的代理对象调用DataSourceTransactionManager对象，在事务开始的时，执行doBegin方法，事务结束时执行doCommit或doRollback方法。

4.2.3 Spring 中事务传播特性

事务传播(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 中事务管理小结

Spring 声明式事务是 Spring 最核心，最常用的功能。由于 Spring 通过 IOC 和 AOP的功能非常透明地实现了声明式事务的功能，对于一般的开发者基本上无须了解 Spring声明式事务的内部细节，仅需要懂得如何配置就可以了。但对于中高端开发者还需要了解其内部机制。

5 Spring AOP 异步操作实现

5.1 异步场景分析

在开发系统的过程中，通常会考虑到系统的性能问题，提升系统性能的一个重要思想就是“串行”改“并行”。说起“并行”自然离不开“异步”，今天我们就来聊聊如何使用Spring的@Async的异步注解。

5.2 Spring 业务的异步实现

5.2.1 启动异步配置

在基于注解方式的配置中，借助@EnableAsync注解进行异步启动声明，Spring Boot版的项目中，将@EnableAsync注解应用到启动类上，代码示例如下：

   @EnableAsync //spring容器启动时会创建线程池
   @SpringBootApplication
   public class Application {
	public static void main(String[] args) {
		SpringApplication.run(Application.class, args);
	}
}

5.2.2 Spring中@Async注解应用

在需要异步执行的业务方法上，使用@Async方法进行异步声明。

@Async
	@Transactional(propagation = Propagation.REQUIRES_NEW)
	@Override
	public void saveObject(SysLog entity) {
      System.out.println("SysLogServiceImpl.save:"+
Thread.currentThread().getName());
	  sysLogDao.insertObject(entity);
	  //try{Thread.sleep(5000);}catch(Exception e) {}
	}

假如需要获取业务层异步方法的执行结果，可参考如下代码设计进行实现：

	@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:
  task:
    execution:
      pool:
        queue-capacity: 128
        core-size: 5
        max-size: 128
        keep-alive: 60000
      thread-name-prefix: db-service-task-

对于spring框架中线程池配置参数的涵义，可以参考ThreadPoolExecutor对象中的解释。
说明：对于@Async注解默认会基于ThreadPoolTaskExecutor对象获取工作线程，然后调用由@Async描述的方法，让方法运行于一个工作线程，以实现异步操作。但是假如系统中的默认拒绝处理策略,任务执行过程的异常处理不能满足我们自身业务需求的话,我可以对异步线程池进行自定义.(SpringBoot中默认的异步配置可以参考自动配置对象TaskExecutionAutoConfiguration).

m0_46525448

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Spring AOP 学习总结

1.1 AOP 概述1.1.1 AOP 是什么？AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善。它以通过预编译方式和运行期动态代理方式，实现在不修改源代码的情况下给程序动态统一添加额外功能的一种技术。如图-1所示：AOP与OOP字面意思相近，但其实两者完全是面向不同领域的设计思想。实际项目中我们通常将面向对象理解为一个静态过程(例如一个系统有多少个模块，一个模块有哪些对象，对象有哪些属性)，面向切
复制链接

扫一扫