spring--AOP

最新推荐文章于 2024-11-03 11:01:20 发布
最新推荐文章于 2024-11-03 11:01:20 发布
阅读量351 收藏
点赞数
分类专栏： spring分析 文章标签： java aop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43470725/article/details/121829839
版权

参考：
https://www.cnblogs.com/bqh10086/p/10125391.html
https://zhuanlan.zhihu.com/p/355520208

AOP核心概念

1、横切关注点
对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点

2、切面（aspect）
类是对物体特征的抽象，切面就是对横切关注点的抽象

3、连接点（joinpoint）
被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器

4、切入点（pointcut）
对连接点进行拦截的定义

5、通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

6、目标对象
代理的目标对象

7、织入（weave）
将切面应用到目标对象并导致代理对象创建的过程

8、引入（introduction）
在不修改代码的前提下，引入可以在运行期为类动态地添加一些方法或字段

AOP作用：打补丁

AOP注解理解：

@Aspect：

用在类上面，定义该类是aop的切面类，在该类里面实现切面操作，还需要被spring管理，一般和@Component连用。

@Pointcut：切入点

定义一个切入点表达式,用来确定哪些类需要代理，有两种用法：

1、使用路径定义：
execution(* aopdemo..(…))代表aopdemo包下所有类的所有方法都会被代理

eg1：@Pointcut(“execution(* aopdemo..(…))”)

eg2 ： @Pointcut(value =
“execution(public * cn.org.emcs.userbasecloud…Controller.*(…))”)

具体使用：

2、使用注解定义：@Pointcut("@annotation(com.example.dtest.aop.MyAopAnnotation)")
表示添加了该注解的都是要执行该切面的类：

@Pointcut("@annotation(com.example.dtest.aop.MyAopAnnotation)")
  public void MypointCut(){

    }

注解类：

package com.example.dtest.aop;

import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented//说明该注解将被包含在javadoc中
//@Retention: 定义注解的保留策略,
@Retention(RUNTIME)// 注解会在class字节码文件中存在，在运行时可以通过反射获取到
//@Target：定义注解的作用目标
@Target({METHOD,PARAMETER})// 方法和方法参数
@Inherited//说明子类可以继承父类中的该注解
public @interface MyAopAnnotation {


}

通知（advice）
所谓通知指的就是指拦截到连接点之后要执行的代码，通知分为前置、后置、异常、最终、环绕通知五类

前置：就是在目标切面方法前执行
@Before(value = “MypointCut()”) ----这里的MypointCut()方法就是前面切入点@Pointcut配置的方法，通过它去找到要执行类的所有方法：

@Before(value = "MypointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("注解测试方法执行前");

// 首先获取方法的签名，joinPoint中有相应的签名信息
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        // 通过方法的签名可以获取方法本身
        Method method = signature.getMethod();
        // 获取方法的参数列表，注意此方法需JDK8+
        Parameter[] parameters = method.getParameters();
        // 获取参数列表的实际的值
        Object[] args = joinPoint.getArgs();
        // 建立参数列表和实际的值的对应关系
//        Pair<Parameter, Object>[] parameterObjectPairs = new Pair[parameters.length];
//        for(int i = 0; i < parameters.length; i++) {
//            parameterObjectPairs[i] = new Pair<>(parameters[i], args[i]);
//        }
//        // 对参数进行遍历
//        for(int i = 0; i < parameterObjectPairs.length; i++) {
//            Pair<Parameter, Object> pair = parameterObjectPairs[i];
//
//        }


    }

后置：就是在目标切面方法后执行

@After(value = "MypointCut()")
    public void after(JoinPoint joinPoint){
        System.out.println("注解测试方法执行后");

        /*拿到请求头：*/
        ServletRequestAttributes attributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest req = attributes.getRequest();
        String token = req.getHeader("token");


    }

异常、最终：

    @AfterThrowing(value = "MypointCut()")
    public void throwMethod(JoinPoint joinPoint){
        System.out.println("注解测试方法异常尝试后执行");
    }
   @AfterReturning(value = "MypointCut()")
    public void returnMehtod(JoinPoint joinPoint){
        System.out.println("注解测试方法返回后执行");
    }

@Around环绕：可自定义目标方法执行的时机

joinPoint.proceed();//执行目标方法
//用新的参数值执行目标方法
result = pjd.proceed(new Object[]{“newSpring”,“newAop”});

 @Around(value = "MypointCut()")
    public void aroundMethod(ProceedingJoinPoint joinPoint){

        System.out.println("注解测试方法环绕方法执行前");
        try{
            joinPoint.proceed();
            System.out.println("注解测试方法环绕方法执行后");
        }catch(Throwable throwable){
            throwable.printStackTrace();
        }

    }

JoinPoint和ProceedingJoinPoint区别：

JoinPoint

JoinPoint对象封装了SpringAop中切面方法的信息,在切面方法中添加JoinPoint参数,就可以获取到封装了该方法信息的JoinPoint对象,常用api:

在这里插入图片描述

ProceedingJoinPoint

ProceedingJoinPoint对象是JoinPoint的子接口,该对象只用在@Around的切面方法中, 添加了两个方法.

在这里插入图片描述

Spring AOP 切入点@Pointcut – execution表达式

execution(* com.sample.service.impl..*.*(..))

详述：

  • execution()，表达式的主体
  • 第一个“*”符号，表示返回值类型任意；
  • com.sample.service.impl，AOP所切的服务的包名，即我们的业务部分
  • 包名后面的“…”，表示当前包及子包
  • 第二个“*”，表示类名，*即所有类
  • .*(…)，表示任何方法名，括号表示参数，两个点表示任何参数类型

案例1：用path作切面路径：

切面类：

package com.example.dtest.aop;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * 把这个类声明为一个切面：
 * 1. 使用注解“@Component”把该类放入到IOC容器中
 * 2. 使用注解“@Aspect”把该类声明为一个切面
 *
 * 设置切面的优先级:
 * 3. 使用注解“@Order(number)”指定前面的优先级，值越小，优先级越高
 */
@Order(1)
@Aspect
@Component
public class MyAspectByPath {

    /**
     * Pointcut 切入点
     * 匹配
     * cn.huanzi.qch.baseadmin.sys.*.controller、
     * cn.huanzi.qch.baseadmin.*.controller包下面的所有方法
     *
     * 参考：https://blog.csdn.net/weixin_49930191/article/details/108360340
     * execution()，表达式的主体
     * 第一个“*”符号，表示返回值类型任意；
     * com.sample.service.impl，AOP所切的服务的包名，即我们的业务部分
     * 包名后面的“…”，表示当前包及子包
     * 第二个“*”，表示类名，*即所有类
     * .*(…)，表示任何方法名，括号表示参数，两个点表示任何参数类型
     * ————————————————
     * 版权声明：本文为CSDN博主「张同学最帅」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
     * 原文链接：https://blog.csdn.net/weixin_49930191/article/details/108360340
     *execution(* com.sample.service.impl..*.*(..))
     */
    @Pointcut(value = "execution(public * com.example.dtest.controller..*.*(..))")
    public void MypointCut(){

    }

    /**
     * 定义一个切入点表达式,用来确定哪些类需要代理
     * execution(* com.*.*(..))com
     */
//    @Pointcut("execution(* com.*.*(..))")
//    public void MypointCut(){
//
//    }



    @Before(value = "MypointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("path---注解测试方法执行前");

// 首先获取方法的签名，joinPoint中有相应的签名信息
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        // 通过方法的签名可以获取方法本身
        Method method = signature.getMethod();
        // 获取方法的参数列表，注意此方法需JDK8+
        Parameter[] parameters = method.getParameters();
        // 获取参数列表的实际的值
        Object[] args = joinPoint.getArgs();
        // 建立参数列表和实际的值的对应关系
//        Pair<Parameter, Object>[] parameterObjectPairs = new Pair[parameters.length];
//        for(int i = 0; i < parameters.length; i++) {
//            parameterObjectPairs[i] = new Pair<>(parameters[i], args[i]);
//        }
//        // 对参数进行遍历
//        for(int i = 0; i < parameterObjectPairs.length; i++) {
//            Pair<Parameter, Object> pair = parameterObjectPairs[i];
//
//        }


    }

    @After(value = "MypointCut()")
    public void after(JoinPoint joinPoint){
        System.out.println("path---注解测试方法执行后");

        /*拿到请求头：*/
        ServletRequestAttributes attributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest req = attributes.getRequest();
        String token = req.getHeader("token");


    }

    @AfterReturning(value = "MypointCut()")
    public void returnMehtod(JoinPoint joinPoint){
        System.out.println("path---注解测试方法返回后执行");
    }

    @AfterThrowing(value = "MypointCut()")
    public void throwMethod(JoinPoint joinPoint){
        System.out.println("path---注解测试方法异常尝试后执行");
    }

    @Around(value = "MypointCut()")
    public void aroundMethod(ProceedingJoinPoint joinPoint){

        System.out.println("path---注解测试方法环绕方法执行前");
        try{
            joinPoint.proceed();
            System.out.println("path---注解测试方法环绕方法执行后");
        }catch(Throwable throwable){
            throwable.printStackTrace();
        }

    }

}

目录结构：
在这里插入图片描述

执行测试类：

package com.example.dtest.controller;

import com.example.vo.Res;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/Aop")
public class AopTestController {

//    @MyAopAnnotation
    @PostMapping("/test")
    public Res testAop(){

        return Res.success(1, "yes");

    }


}

结果：
在这里插入图片描述
在这里插入图片描述

案例1：用注解作切面路径：

注解类：

package com.example.dtest.aop;

import java.lang.annotation.Documented;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Documented//说明该注解将被包含在javadoc中
//@Retention: 定义注解的保留策略,
@Retention(RUNTIME)// 注解会在class字节码文件中存在，在运行时可以通过反射获取到
//@Target：定义注解的作用目标
@Target({METHOD,PARAMETER})// 方法和方法参数
@Inherited//说明子类可以继承父类中的该注解
public @interface MyAopAnnotation {


}

切面类：

package com.example.dtest.aop;


import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;

/**
 * 把这个类声明为一个切面：
 * 1. 使用注解“@Component”把该类放入到IOC容器中
 * 2. 使用注解“@Aspect”把该类声明为一个切面
 *
 * 设置切面的优先级:
 * 3. 使用注解“@Order(number)”指定前面的优先级，值越小，优先级越高
 */
@Order(1)
@Aspect
@Component
public class MyAspect {

    //将切入点换成了自己定义的注解：在加入注解的地方切入
    @Pointcut("@annotation(com.example.dtest.aop.MyAopAnnotation)")
    public void MypointCut(){

    }






    @Before(value = "MypointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("annotation---注解测试方法执行前");

// 首先获取方法的签名，joinPoint中有相应的签名信息
        MethodSignature signature = (MethodSignature)joinPoint.getSignature();
        // 通过方法的签名可以获取方法本身
        Method method = signature.getMethod();
        // 获取方法的参数列表，注意此方法需JDK8+
        Parameter[] parameters = method.getParameters();
        // 获取参数列表的实际的值
        Object[] args = joinPoint.getArgs();
        // 建立参数列表和实际的值的对应关系
//        Pair<Parameter, Object>[] parameterObjectPairs = new Pair[parameters.length];
//        for(int i = 0; i < parameters.length; i++) {
//            parameterObjectPairs[i] = new Pair<>(parameters[i], args[i]);
//        }
//        // 对参数进行遍历
//        for(int i = 0; i < parameterObjectPairs.length; i++) {
//            Pair<Parameter, Object> pair = parameterObjectPairs[i];
//
//        }


    }

    @After(value = "MypointCut()")
    public void after(JoinPoint joinPoint){
        System.out.println("annotation---注解测试方法执行后");

        /*拿到请求头：*/
        ServletRequestAttributes attributes =
                (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest req = attributes.getRequest();
        String token = req.getHeader("token");


    }

    @AfterReturning(value = "MypointCut()")
    public void returnMehtod(JoinPoint joinPoint){
        System.out.println("annotation---注解测试方法返回后执行");
    }

    @AfterThrowing(value = "MypointCut()")
    public void throwMethod(JoinPoint joinPoint){
        System.out.println("annotation---注解测试方法异常尝试后执行");
    }

    @Around(value = "MypointCut()")
    public void aroundMethod(ProceedingJoinPoint joinPoint){

        System.out.println("annotation---注解测试方法环绕方法执行前");
        try{
            joinPoint.proceed();
            System.out.println("annotation---注解测试方法环绕方法执行后");
        }catch(Throwable throwable){
            throwable.printStackTrace();
        }

    }



}

测试实现类：

package com.example.dtest.controller;

import com.example.dtest.aop.MyAopAnnotation;
import com.example.vo.Res;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/Aop")
public class AopTestController {

    @MyAopAnnotation
    @PostMapping("/test")
    public Res testAop(){

        return Res.success(1, "yes");

    }


}

测试结果：
在这里插入图片描述

春风霓裳
关注
专栏目录
Javaweb学习笔记（Spring AOP）
qq_50834939的博客
03-18 866
Javaweb学习笔记（Spring AOP）SpringAOP简介什么是AOPAOP术语 SpringAOP简介 什么是AOP AOP是面向切面编程，他是面向对象的一种补充。AOP的使用使开发人员在编写业务逻辑时可以专业与核心业务么人不用过多地赶住其他业务的实现，提高了开发效率，增强了代码的可维护性。 最流行的AOP框架有两个分别为Spring AOP和AspectJ。 AOP术语 1.Aspect（切面）：在实际应用中，切面通常是指封装的用于荷香插入系统功能（如事务、日志等）的类。需要在配置文件<
spring，spring-aop-5.3.22.jar+aop+IDEA本地包
09-09
spring-aop-5.3.22.jar Spring AOP provides an Alliance-compliant aspect-oriented programming implementation allowing you to define method interceptors and pointcuts to cleanly decouple code that ...
spring(AOP详解)
限定私语的博客
06-29 1138
1. 动态代理 1.1 动态代理的特点 字节码随用随创建，随用随加载。 它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。 装饰者模式就是静态代理的一种体现。 1.2 动态代理常用的两种方式 基于接口的动态代理 使用JDK 官方的 Proxy 类创建代理对象 此处我们使用的是一个演员的例子：在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。 public interf
切点、切面：@Aspect、@PointCut相关的个人总结
weixin_34110749的博客
04-13 424
最近写的项目里面都用到了很多切面，切点的知识，写完以后，来自我总结一下： 举个例子：一个类（Show）里面有一个表演（display）的方法，在表演之前，应该有致辞（say）的方法，在表演之后，应该有鼓掌（hand）的方法。为了高内聚低耦合，表演的方法应该单独封装在一个类里面，致辞和鼓掌的方法应该另外封装，但在调用时必须按照顺序来调用执行。这时候就需要设置切面和切点了！ 切面应该设置在致辞（say...
AOP的术语的介绍
为猫的博客
12-09 350
AOP的术语介绍： 1、横切关注点 对哪些方法进行拦截，拦截后怎么处理，这些关注点称之为横切关注点 2、切面（aspect） 类是对物体特征的抽象，切面就是对横切关注点的抽象 3、连接点（joinpoint） 被拦截到的点，因为Spring只支持方法类型的连接点，所以在Spring中连接点指的就是被拦截到的方法，实际上连接点还可以是字段或者构造器 4、切入点（pointcut） 对...
AOP的主要概念和术语
Tomson Xu
04-24 2939
 ====关注点(Concern)====关注点就是我们要考察或解决的问题。如订单的处理，用户的验证、用户日志记录等都属于关注点。 关注点中的核心关注点(Core Concerns)，是指系统中的核心功能，即真正的商业逻辑。如在一个电子商务系统中，订单处理、客户管理、库存及物流管理都是属于系统中的核心关注点。 还有一种关注点叫横切关注点 (Crosscutting Co
spring AoP学习 -----AoP织入器
dixiu0932的博客
07-25 113
　　在spring AoP中，使用类aop.framework.ProxyFactory作为织入器，使用ProxyFactory作为织入器，使用ProxyFactory来进行横切逻辑的织入很简单，spring AoP是基于代理模式的AoP实现，织入过程实现完成后，会返回织入了横切逻辑的目标对象的代理对象，ProxyFactory就会返回那个织入完成的代理对象。 　　使用ProxyFac...
Spring-AOP详解
qq_42861526的博客
10-27 1374
一、Spring-AOP的作用 在实际开发中，我们往往会遇到对已有功能做扩展的情况，我们需要在不对源码进行修改的情况下扩展功能，在没有spring-aop的情况下我们应该这么做： 情景1：我们现在要对AServiceImpl(实现了AService接口)中的login方法进行扩展，这种情形我们可以使用代理模式来做，过程如下：创建一个BServiceImpl类并实现AService接口，并重现doLogin方法。 class BServiceImpl implements AService{ private
spring-aop-5.2.0.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-aop-5.2.0.RELEASE.jar； 赠送原API文档：spring-aop-5.2.0.RELEASE-javadoc.jar； 赠送源代码：spring-aop-5.2.0.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-aop-5.2.0.RELEASE.pom；...
开发工具 spring-aop-4.3.6.RELEASE
05-31
开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE开发工具 spring-aop-4.3.6.RELEASE...
spring-aop-6.0.2.jar
10-25
spring-aop-6.0.2.jar
spring-aop-5.1.0.RELEASE.jar
03-09
spring-**core**-4.3.6.RELEASE.jar ：包含spring框架基本的核心工具类，spring其他组件都要用到这个包里的类，其他组件的基本核心 spring-**beans**-4.3.6.RELEASE.jar：所有应用都要用到的jar包，它包含访问配置...
AOP中的一些术语
lxw665的博客
11-13 352
AOP术语 class User { add(); update(); select(); delete(); } 1、连接点 类中那些方法可以被增强，这些方法就被称为连接点。在User类中其中四个方法都可以被增强，所以他们都是连接点。 2、切入点 实际上被增强的方法被称为切入点。 3、通知（增强） 实际增强的逻辑部分被称为通知（增强），就是加强发放的代码 通知有多种类型 前置通知 后置通知 环绕通知 异常通知 最终通知 4.、切面 把通知应用到切入点的过程就叫做切面，是一个动作。 ...
AOP常用术语
张铎
09-26 532
Aop中常用的基本术语
qq_41134324的博客
10-17 623
术语 连接点：一个类中的哪些方法可以被增强，那这些方法就称为连接点（可以被增强的方法称为连接点），比如上面的 add()、update()、select()、delete()都可以成为连接点 切入点：实际上被增强的方法称为切入点，比如说只增强了add(),那么add()就可以称为切入点 通知（增强）：实际增强的逻辑部分称为通知（增强），比如说要给add()加一个日志功能，那这个日志功能就可以称为通知（增强） 切面：是一个动作，指的是把通知应用到切入点的过程 通知（增强）有五种类型： 1.前置通知 2.后
Spring之Spring AOP
liu289747235的专栏
12-30 235
AOP(Aspect-Oriented Programming, 面向切面编程) Aspect(切面):指对横切关注点的抽象即为切面。 Joinpoint(连接点):被拦截到的点，一般是方法的调用。连接点由两个信息确定：方法表示的程序执行点；相对点表示的方位。例如 ArithmethicCalculator#add() 方法执行前的连接点，执行点为 ArithmethicCalculator#...
分享：aop 相关术语介绍之 本人通俗易懂大白话介绍
immort.L 的博客
07-03 1173
文章目录1. 前言2. aop 相关术语介绍2.1 AOP 的理解2.2 Joinpoint(连接点)2.2.1 spring 官方文档解释2.2.2 个人理解2.3 Pointcut(切入点)2.3.1 spring 解释2.3.2 个人理解2.4 Advice(通知/增强)2.4.1 spring 官方文档解释2.4.2 个人理解2.5 Introduction2.5.1 spring 官方文档解释2.5.2 个人理解2.6 Weaving(织入)2.6.1 spring 官方文档解释2.6.2 个人理
Spring AOP中的专业术语介绍
热门推荐
咔咔学长
06-14 1万+
一、AOP简介 AOP(Aspect-Oriented Programming, 面向切面编程): 是一种新的方法论, 是对传统 OOP(Object-Oriented Programming, 面向对象编程) 的补充。 AOP 的主要编程对象是切面(aspect), 而切面是把横切关注点模块化! 在应用 AOP 编程时, 需要定义公共功能, 但可以明确的定义这个功能在哪里应用, 并且不必修改需要使用公共功能的类。 这样以来横切关注点就被模块化到特殊的对象(切面)里. 二、AOP 的好处 每个事物逻辑位于一
HashMap为什么线程不安全？
最新发布
rnnf_yyds的博客
11-03 340
HashMap底层是基于数组 + 链表（在 Java 8 以后，当链表长度超过一定阈值时会转换为红黑树）的数据结构。在多线程环境下，当多个线程同时对HashMap进行put操作时，可下面这种情况：假设两个线程 A 和 B 同时执行put操作，它们计算出的插入位置相同（假设为index线程 A 先获取到了当前index位置的节点，在它还没来得及将新节点插入链表（或树）时，线程 B 也获取到了这个位置的节点。
spring-aop与spring-boot-starter-aop的区别
09-22
spring-aop与spring-boot-starter-aop的区别在于配置的简化程度和依赖的引入方式。spring-aop是基于Spring框架的AOP实现方式，需要通过XML配置文件来定义切面和通知。而spring-boot-starter-aop是针对Spring Boot...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值