Spring的AOP

最新推荐文章于 2025-12-07 09:58:49 发布
原创 最新推荐文章于 2025-12-07 09:58:49 发布 · 155 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring #java #后端

本文介绍了Spring框架中的AOP（面向切面编程）概念，包括连接点、切入点、通知等核心概念，并通过XML配置和注解方式展示了如何进行AOP配置，以实现如事务管理、日志记录等功能。文章还提供了具体的代码示例，展示了在方法执行前后插入增强逻辑的过程。

一、AOP

1.概念

AOP：全称 Aspect Oriented Programming，即：面向切面编程。 AOP是OOP（面向对象编程）的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。 把我们程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对我们的已有方法进行增强。

AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码 经典应用：事务管理、性能监视、安全检查、缓存 、日志等

2.作用及优势

在程序运行期间，不修改源码对已有方法进行增强

3.实现方式

aop底层将采用代理机制进行实现。

  • 接口 + 实现类：spring采用 jdk 的动态代理Proxy。
  • 实现类：spring 采用 cglib字节码增强。

4.AOP相关概念

①Joinpoint( 连接点): 被拦截到的点。在 spring 中,这些点指的是方法,因为 spring 只支持方法类型的连接点。

②Pointcut( 切入点): 要对哪些 Joinpoint 进行拦截，即被增强的连接点。

③Advice( 通知/ 增强): 拦截到 Joinpoint 之后所要做的事情，及增强代码。 通知的类型：

  • 前置通知org.springframework.aop.MethodBeforeAdvice：在目标方法执行前实施增强
  • 后置通知org.springframework.aop.AfterReturningAdvice：在目标方法执行后实施增强
  • 异常通知org.springframework.aop.ThrowsAdvice： 在方法抛出异常后实施增强
  • 最终通知org.springframework.aop.AfterAdvice：无论切入点方法是否执行，都会在其后执行
  • 环绕通知org.aopalliance.intercept.MethodInterceptor： 在目标方法执行前后实施增强
  • 引介通知org.springframework.aop.IntroductionInterceptor：在目标类中添加一些新的方法和属性

④Introduction(引介): 引介是一种特殊的通知在不修改类代码的前提下, Introduction 可以在运行期为类动态地添加一些方 法或 Field。

⑤Target(目标对象): 目标类，需要被代理的类

⑥Weaving(织入): 是指把增强应用到目标对象来创建新的代理对象的过程。 spring 采用动态代理织入，而 AspectJ 采用编译期织入和类装载期织入。

⑦Proxy（代理）: 代理类，一个类被 AOP 织入增强后，就产生一个结果代理类。

⑧Aspect( 切面): 是切入点和通知（引介）的结合。

二、基于xml的AOP配置

AccountService：

java

复制代码

public interface AccountService { void saveAccount(); void updateAccount(int accountId); int deleteAccount(); }

AccountServiceImpl:

java

复制代码

public class AccountServiceImpl implements AccountService{ public void saveAccount() { System.out.println("保存账户"); } public void updateAccount(int accountId) { System.out.println("更新账户"); } public int deleteAccount() { System.out.println("删除账户"); return 0; } }

LoggerUtil:

java

复制代码

public class LoggerUtil { public void printLog(){ System.out.println("printLog方法执行"); } }

beans.xml:

xml

复制代码

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"> <!-- 告知 spring 创建容器时要扫描的包 --> <!--<context:component-scan base-package="com.hcx"></context:component-scan>--> <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype"> <constructor-arg name="ds" ref="dataSource"></constructor-arg> </bean> <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource"> <property name="driverClass" value="com.mysql.jdbc.Driver"></property> <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/springdemo"></property> <property name="user" value="root"></property> <property name="password" value="root"></property> </bean> <!--要增强的类--> <bean id="accountService" class="com.hcx.service.impl.AccountServiceImpl"></bean> <!--通知类--> <bean id="loggerUtil" class="com.hcx.utils.LoggerUtil"></bean> <!--配置AOP--> <aop:config> <!--配置切面 --> <aop:aspect id="loggerAdvice" ref="loggerUtil"> <!-- 配置通知的类型，并且建立通知方法和切入点方法的关联--> <!--只对com.hcx.service.impl.AccountServiceImpl下的saveAccount()方法增强--> <aop:before method="printLog" pointcut="execution(public void com.hcx.service.impl.AccountServiceImpl.saveAccount())"></aop:before> <!--省略访问修饰符--> <aop:before method="printLog" pointcut="execution(void com.hcx.service.impl.AccountServiceImpl.saveAccount())"></aop:before> <!--返回值使用通配符：表示任意返回值--> <aop:before method="printLog" pointcut="execution(* com.hcx.service.impl.AccountServiceImpl.saveAccount())"></aop:before> <!--包名使用通配符表示任意包，有几级包写几个*--> <aop:before method="printLog" pointcut="execution(* *.*.*.*.AccountServiceImpl.saveAccount())"></aop:before> <!--包名使用..表示当前包及其子包--> <aop:before method="printLog" pointcut="execution(* *..AccountServiceImpl.saveAccount())"></aop:before> <!--类名使用通配符--> <aop:before method="printLog" pointcut="execution(* *..*.saveAccount())"></aop:before> <!--方法名使用通配符--> <aop:before method="printLog" pointcut="execution(* *..*.*())"></aop:before> <!--全通配--> <aop:before method="printLog" pointcut="execution(* *..*.*(..))"></aop:before> <!--指定int类型参数的执行--> <aop:before method="printLog" pointcut="execution(* *..*.*(int))"></aop:before> <!--使用通配符表示任意类型参数（需要有参数）--> <aop:before method="printLog" pointcut="execution(* *..*.*(*))"></aop:before> <!--..有无参数均可--> <aop:before method="printLog" pointcut="execution(* *..*.*(..))"></aop:before> </aop:aspect> </aop:config> </beans>

AOPTest：

java

复制代码

public class AOPTest { public static void main(String[] args) { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml"); AccountService accountService = (AccountService)applicationContext.getBean("accountService"); accountService.saveAccount(); accountService.updateAccount(1); accountService.deleteAccount(); } }

AOP配置：

  • 使用aop:config标签表明开始AOP的配置
  • 使用aop:aspect标签表明配置切面 id属性：是给切面提供一个唯一标识 ref属性：是指定通知类bean的Id。
  • 在aop:aspect标签的内部使用对应标签来配置通知的类型 示例是让printLog方法在切入点方法执行之前执行：为前置通知： aop:before：表示配置前置通知 method属性：指定LoggerUtil类中哪个方法是前置通知（即增强的代码） pointcut属性：指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强

切入点表达式： 关键字：execution(表达式) 表达式：访问修饰符 返回值 包名.包名.包名...类名.方法名(参数列表)

  • 标准的表达式写法：public void com.hcx.service.impl.AccountServiceImpl.saveAccount()
  • 省略访问修饰符：void com.hcx.service.impl.AccountServiceImpl.saveAccount()
  • 返回值使用通配符:表示任意返回值：* com.hcx.service.impl.AccountServiceImpl.saveAccount()
  • 包名使用通配符:表示任意包。有几级包，就需要写几个：** *.*.*.*.AccountServiceImpl.saveAccount())
  • 包名使用..表示当前包及其子包：* *..AccountServiceImpl.saveAccount()
  • 类名和方法名使用*来实现通配：* *..*.*()

参数列表：

  • 直接写数据类型: 基本类型直接写名称：int 引用类型写包名.类名的方式 java.lang.String
  • 使用通配符表示任意类型，但是必须有参数
  • 使用..表示有无参数均可，有参数可以是任意类型
  • 全通配写法：* *..*.*(..)

实际开发中切入点表达式的通常写法：切到业务层实现类下的所有方法：* com.hcx.service.impl.*.*(..)

通知类型：

环绕通知：可以在代码中手动控制增强方法何时执行。 ProceedingJoinPoint接口中的proceed()方法可以调用切入点方法，该接口可以作为环绕通知的方法参数。

LoggerUtil：

java

复制代码

package com.hcx.utils; import org.aspectj.lang.ProceedingJoinPoint; /** * Created by hongcaixia on 2019/12/17. */ public class LoggerUtil { /** * 前置 */ public void methodBeforeAdvice(){ System.out.println("前置通知"); } /** * 后置 */ public void afterReturningAdvice(){ System.out.println("后置通知"); } /** * 异常 */ public void throwsAdvice(){ System.out.println("异常通知"); } /** * 最终 */ public void afterAdvice(){ System.out.println("最终通知"); } /** * 环绕 */ public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){ try { Object[] args = proceedingJoinPoint.getArgs(); //前置通知：proceed方法之前 System.out.println("环绕通知"); //调用切入点方法 Object proceed = proceedingJoinPoint.proceed(args); //后置通知：proceed方法之后 System.out.println("环绕通知"); return proceed; } catch (Throwable throwable) { //异常通知 System.out.println("环绕通知"); throwable.printStackTrace(); }finally{ System.out.println("环绕通知"); } return null; } /** * 引介 */ public void introductionInterceptor(){ System.out.println("引介通知"); } }

beans.xml：

xml

复制代码

<!--配置AOP--> <aop:config> <aop:pointcut id="pointcut" expression="execution(* com.hcx.service.impl.*.*(..)))"></aop:pointcut> <!--配置切面 --> <aop:aspect id="loggerAdvice" ref="loggerUtil"> <!--前置--> <aop:before method="methodBeforeAdvice" pointcut-ref="pointcut"></aop:before> <!--后置--> <aop:after-returning method="afterReturningAdvice" pointcut-ref="pointcut"></aop:after-returning> <!--异常--> <aop:after-throwing method="throwsAdvice" pointcut-ref="pointcut"></aop:after-throwing> <!--最终--> <aop:after method="afterAdvice" pointcut-ref="pointcut"></aop:after> <!--环绕通知--> <aop:around method="aroundAdvice" pointcut-ref="pointcut"></aop:around> </aop:aspect> </aop:config>

其他通知可以通过配置的方式指定增强的代码的执行时机，而环绕通知则可以编码的方式指定。

三、基于注解的AOP配置

@Aspect：指定当前类为切面类 @Pointcut：配置切入点表达式 @Before("切入点方法名")：前置通知 @AfterReturning("切入点方法名")：后置通知 @AfterThrowing("切入点方法名")：异常通知 @After("切入点方法名")：最终通知 @Around("切入点方法名")：环绕通知

配置文件中需要做两件事： 1.配置spring组件扫描包 2.配置开启注解AOP的支持

beans.xml:

xml

复制代码

<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 告知 spring 创建容器时要扫描的包 --> <context:component-scan base-package="com.hcx"></context:component-scan> <!-- 配置spring开启注解AOP的支持 --> <aop:aspectj-autoproxy></aop:aspectj-autoproxy> </beans>

LoggerUtil：

java

复制代码

package com.hcx.utils; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.*; import org.springframework.stereotype.Component; /** * Created by hongcaixia on 2019/12/17. */ @Component("loggerUtil") @Aspect//表示当前类是一个切面类 public class LoggerUtil { @Pointcut("execution(* com.hcx.service.impl.*.*(..))") public void pointcut(){ } /** * 前置 */ @Before("pointcut()") public void methodBeforeAdvice(){ System.out.println("前置通知"); } /** * 后置 */ @AfterReturning("pointcut()") public void afterReturningAdvice(){ System.out.println("后置通知"); } /** * 异常 */ @AfterThrowing("pointcut()") public void throwsAdvice(){ System.out.println("异常通知"); } /** * 最终 */ @After("pointcut()") public void afterAdvice(){ System.out.println("最终通知"); } /** * 环绕 */ // @Around("pointcut()") public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){ try { Object[] args = proceedingJoinPoint.getArgs(); //前置通知：proceed方法之前 System.out.println("环绕通知"); //调用切入点方法 Object proceed = proceedingJoinPoint.proceed(args); //后置通知：proceed方法之后 System.out.println("环绕通知"); return proceed; } catch (Throwable throwable) { //异常通知 System.out.println("环绕通知"); throwable.printStackTrace(); }finally{ System.out.println("环绕通知"); } return null; } /** * 引介 */ public void introductionInterceptor(){ System.out.println("引介通知"); } }

打印结果：

复制代码

有异常时： 前置通知 保存账户 最终通知 异常通知 没有异常时： 前置通知 保存账户 最终通知 后置通知

此时顺序有问题，可以使用环绕通知：

java

复制代码

/** * 环绕 */ @Around("pointcut()") public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint){ try { Object[] args = proceedingJoinPoint.getArgs(); //前置通知：proceed方法之前 System.out.println("前置通知"); //调用切入点方法 Object proceed = proceedingJoinPoint.proceed(args); //后置通知：proceed方法之后 System.out.println("后置通知"); return proceed; } catch (Throwable throwable) { //异常通知 System.out.println("异常通知"); throwable.printStackTrace(); }finally{ System.out.println("最终通知"); } return null; }

打印顺序：

复制代码

前置通知 保存账户 后置通知 最终通知

使用纯注解的话（没有beans.xml），只需在配置类中添加@EnableAspectJAutoProxy

四、使用SpringAOP记录日志

需求：记录用户操作系统的每个步骤的详细信息

编写切面类：LogAop

java

复制代码

package com.hcx.controller; import com.hcx.domain.SysLog; import com.hcx.service.SysLogService; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.security.core.context.SecurityContext; import org.springframework.security.core.context.SecurityContextHolder; import org.springframework.security.core.userdetails.User; import org.springframework.stereotype.Component; import org.springframework.web.bind.annotation.RequestMapping; import javax.servlet.http.HttpServletRequest; import java.lang.annotation.Annotation; import java.lang.reflect.Method; import java.util.Date; /** * Created by hongcaixia on 2020/1/29. */ @Component @Aspect public class LogAop { @Autowired private SysLogService sysLogService; //需要配置一个listener @Autowired private HttpServletRequest request; //开始时间 private Date visitTime; //访问的类 private Class clazz; //访问的方法 private Method method; /** * 前置通知：获取开始时间，执行的类和方法 * * @param joinPoint */ @Before("execution(* com.hcx.controller.*.*(..))") public void doBefore(JoinPoint joinPoint) throws Exception { visitTime = new Date(); clazz = joinPoint.getTarget().getClass(); String methodName = joinPoint.getSignature().getName(); //获取访问的方法的参数 Object[] args = joinPoint.getArgs(); if (args == null || args.length == 0) { //获取无参数的方法 method = clazz.getMethod(methodName); } else { Class[] classArgs = new Class[args.length]; for (int i = 0; i < args.length; i++) { classArgs[i] = args[i].getClass(); } method = clazz.getMethod(methodName, classArgs); } } /** * 后置通知 * * @param joinPoint */ @After("execution(* com.hcx.controller.*.*(..))") public void doAfter(JoinPoint joinPoint) { //访问时长 long time = new Date().getTime() - visitTime.getTime(); String url = ""; //URL if (clazz != null && method != null && clazz != LogAop.class) { //获取类上的注解：@RequestMapping("") RequestMapping clazzAnnotation = (RequestMapping) clazz.getAnnotation(RequestMapping.class); if (clazzAnnotation != null) { String[] clazzValue = clazzAnnotation.value(); //获取方法上的@RequestMapping("") RequestMapping methodAnnotation = method.getAnnotation(RequestMapping.class); if (methodAnnotation != null) { String[] methodValue = methodAnnotation.value(); url = clazzValue[0] + methodValue[0]; //获取访问的ip String remoteAddr = request.getRemoteAddr(); //从上下文中获取当前登录的用户 SecurityContext context = SecurityContextHolder.getContext(); User user = (User) context.getAuthentication().getPrincipal(); String username = user.getUsername(); //将日志信息封装到SysLog对象 SysLog sysLog = new SysLog(); sysLog.setVisitTime(visitTime); sysLog.setUsername(username); sysLog.setIp(remoteAddr); sysLog.setUrl(url); sysLog.setExecutionTime(time); sysLog.setMethod("类名：" + clazz.getName() + " 方法名：" + method.getName()); //调用service完成保存操作 sysLogService.save(sysLog); } } } } }

Spring AOP 16道面试题及答案.docx
06-29
Spring AOP，全称为Aspect Oriented Programming，是面向切面编程的一种编程范式，它是对传统的面向对象编程（OOP）的一种补充。在OOP中，核心是对象，而在AOP中，核心则是切面。切面是关注点的模块化，即程序中的...
精选资源
SpringAOP:Spring AOP示例
05-06
SpringAOP Spring AOP（面向方面​​的编程）用于模块化“横截面”服务。 用一种简单的方式，我们可以说它是一个旨在拦截某些进程的组件，例如，在执行某个方法时，Spring AOP可以审核该执行方法，并在该方法执行...
Spring AOP 详解
2301_80035594的博客
10-19 6531
Spring AOP（Aspect-Oriented Programming，面向切面编程）是Spring框架提供的一种编程范式，它允许开发者将横切关注点（如日志、事务管理、权限检查等）与业务逻辑分离，从而提高代码的模块化和可维护性。Spring AOP 基于代理机制实现，它为Spring应用提供了声明式事务管理等功能。
Spring AOP
2301_81096101的博客
03-22 1528
AOP（Aspect-Oriented Programming）即面向切面编程，是一种通过预编译或动态代理技术，将横切关注点（如日志、安全校验）与业务逻辑分离的编程范式。
Spring Aop
会写Bug的攻城狮
08-30 2024
Spring MVC：需要在XML配置中手动添加来启用AOP。：通过引入依赖，启用AOP功能，简化了配置过程。这种设计让Spring Boot提供了一种更为简便和现代的开发体验，减轻了开发者的负担。每种方案都有其适用的场景和优劣所在。大部分情况下，将方法拆分到不同的 Service 中是最佳实践，它能够保持代码的清晰性和可维护性。在复杂的应用中，可以根据具体的需求考虑其他方法，但在选择方案时要注意事务管理的影响。
spring AOP详解
是程序喵呀
11-07 4020
AOP（Aspect Orient Programming）是一种设计思想，是软件设计领域中的面向切面编程，它是面向对象编程(OOP)的一种补充和完善；
【JavaEE】Spring AOP的注解实现
yj20040627的博客
05-25 1万+
基于注解@annotation 和 execution 的方式实现SPring AOP
Spring AOP详解
2302_77758423的博客
07-21 1883
AOP英文全称：Aspect Oriented Programming（面向切面编程、面向方面编程），其实说白了，面向切面编程就是面向特定方法编程。使用场景（记录操作日志、权限控制、事务管理）。AOP的优势：减少重复代码、提高开发效率、维护方便、代码无侵入。案例某部分功能运行较慢，定位执行耗时较长的业务方法，此时需要统计每一个业务的执行耗时。我们可以在方法开始前，获取方法开始时间，方法结束后获取结束时间，由此计算执行耗时。这个思路是正确的，但是过于繁琐。动态代理是面向切面编程最主流的实现。
SpringAOP(图文详解)
lhj520cb的博客
07-16 5万+
Spring实现的AOP是代理模式，给调用者使用的实际是已经过加工的对象，你编程时方法体里只写了A，但调用者拿到的对象的方法体却是xAy。x和y总还是需要你来写的，这就是增强。x和y具体在什么时候被调用总还是需要你来规定的，虽然是基于约定的声明这种简单的规定，这就是切点。
SpringAOP学习--SpringAOP简介及原理
热门推荐
u012098021的博客
05-15 6万+
前文对AOP做了介绍，实际项目中，一般不会直接上手手动实现aop，而是使用一些高级封装的aop实现，如SpringAOP。 Spring是一个广泛应用的框架，SpringAOP则是Spring提供的一个标准易用的aop框架，依托Spring的IOC容器，提供了极强的AOP扩展增强能力，对项目开发提供了极大地便利。 前文提到AOP的实现有AspectJ、JDK动态代理、CGLIB动态代理，SpringAOP不是一种新的AOP实现，其底层采用的是JDK/CGLIB动态代理。 JDK动态代理回顾 上一篇简单介绍了
Spring AOP术语
yuehua00的专栏
11-11 1805
Spring AOP 中的核心术语和概念包括切面、通知、切入点、连接点、引介、目标对象、代理对象、织入、通知方法、切点表达式、切面优先级、织入器、AOP 代理和 AOP 框架。理解这些术语有助于更好地掌握 Spring AOP 的使用和原理，从而在实际开发中有效地应用 AOP 技术。通过合理使用 AOP，可以提高代码的模块化程度和可维护性，减少重复代码，提高开发效率。
Spring AOP 使用详解
lzz的博客
11-14 1702
Spring AOP 使用详解。核心概念+实现示例+注意事项
Spring aop失效的几种解决方案
08-19
Spring AOP失效解决方案详解 作为一名IT行业大师，我将从给定的文件中生成相关知识点，主要介绍Spring AOP失效的几种解决方案。 标题解释 Spring AOP失效的几种解决方案是指在使用Spring框架时，Aspect Oriented ...
Spring源码最难问题：当Spring AOP遇上循环依赖.docx
06-15
Spring源码最难问题：当Spring AOP遇上循环依赖 Spring源码中最难的问题之一是循环依赖问题，当Spring AOP遇上循环依赖时，该如何解决？ Spring通过三级缓存机制解决循环依赖的问题。 在Spring中，bean的实例化...
死磕Spring之AOP篇 - Spring AOP两种代理对象的拦截处理（csdn）————程序.pdf
12-05
Spring AOP 是一种面向切面编程的技术，它允许我们在不修改源代码的情况下，对应用程序的特定部分（如方法调用）进行增强。在 Spring 中，AOP 的实现主要依赖于代理模式，有两种代理方式：JDK 动态代理和 CGLIB 动态...
计算机毕业设计|基于springboot + vue在线考试管理系统(源码+数据库+文档)
最新发布
12-07 726
本文介绍了一个基于SpringBoot+Vue的在线考试管理系统。系统采用前后端分离架构，后端使用SpringBoot框架简化开发流程，前端采用Vue.js实现响应式界面，数据库选用MySQL存储数据。文章详细说明了系统设计原则、技术选型理由，并提供了功能演示视频、代码示例和测试用例。此外，还包含毕业设计选题推荐和源码获取方式。该系统具有用户友好的界面设计、完善的安全机制和良好的扩展性，适合作为计算机相关专业的毕业设计项目参考。
SpringBoot ThreadLocal 父子线程传值的几种实现方式
风象南的专栏
12-04 587
Spring提供了TaskDecorator接口，允许我们对Runnable任务进行装饰@Override// 设置自定义装饰器@Override// 获取父线程的ThreadLocal上下文try {// 在子线程中复制上下文// 收集当前线程的ThreadLocal值// 例如：从自定义的ThreadLocal中获取= null) {= null) {// 在子线程中设置上下文// 清理上下文，防止内存泄漏。
《已调试》SpringBoot景区寄存管理系统源码 - 免费JavaWeb项目下载 | 幽络源
幽络源
12-03 730
幽络源免费提供《已调试》SpringBoot景区寄存管理系统源码，支持用户寄存、取物、通知公告、柜位管理等功能，适用于景区、车站等场所的智能化管理。代码结构清晰，含完整数据库设计与部署说明，适合JavaWeb学习与项目实战。立即下载，获取高质量开源源码！
计算机毕业设计|基于springboot + vue零食商城管理系统(源码+数据库+文档)
12-03 375
本文介绍了一个基于SpringBoot+Vue的零食商城管理系统。系统采用前后端分离架构，后端使用SpringBoot框架简化开发流程，前端采用Vue.js实现响应式界面，数据库选用MySQL存储数据。文章详细阐述了系统设计原则、技术选型理由，并提供了代码片段和测试用例参考。此外还包含毕设选题推荐和源码获取方式，适合作为计算机专业毕业设计的参考项目。系统功能完善，技术栈主流，具有实际应用价值。
Spring aop
06-28
###Spring AOP 的概念 AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，旨在通过分离横切关注点来提高模块化程度。在 Spring 框架中，AOP 被广泛用于实现诸如日志记录、事务管理、安全性等通用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值