【Java 中级】一文带你学习Spring AOP

川长思鸟来 2024-05-04 08:07 60阅读 0赞

![在这里插入图片描述][b7a7bfb437bc4f2abf6d9b6ef0986077.png]

> ?**博主介绍**： 博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家，WEB架构师，阿里云专家博主，华为云云享专家，51CTO 专家博主

⛪️ 个人社区：[个人社区][Link 1]  
? 个人主页：[个人主页][Link 2]  
? 专栏地址： ✅ [Java 高阶][Java]  
?八股文专题：[剑指大厂，手撕 Java 八股文][Java 1]

#### 文章目录 ####

*   *   *  1. 什么是 AOP
         *  2. AOP 的优缺点
         *  3. AOP 的应用场景
         *  4. AOP 的注解使用
         *   *  4.1. @Before
             *  4.2. @After
             *  4.3. @AfterReturning
             *  4.4. @AfterThrowing
             *  4.5. @Around
         *  5. JDK 动态代理
         *   *  5.1. JDK 动态代理的工作原理
             *  5.2. JDK 动态代理的优点
             *  5.3. JDK 动态代理的缺点
             *  6.4. JDK 动态代理使用方法
         *  6. Cglib 动态代理
         *   *  6.1. 特点
             *  6.2. Cglib 动态代理的步骤
             *  6.2. 使用方法
         *  7. AOP 切点表达式
         *   *  7.1. 切点使用案例
         *  8. 通知方法的执行顺序

#### 1. 什么是 AOP ####

AOP（面向切面编程）是一种编程范式，用于将横切关注点从主要业务逻辑中分离出来。在传统的面向对象编程中，我们将功能划分为对象，并在对象之间建立关系。然而，有些功能在多个对象中重复出现，例如日志记录、事务管理等。AOP的目标是通过将这些横切关注点从对象中提取出来，以便更好地管理和维护代码。

AOP通过使用切面、连接点和通知来实现。切面定义了横切关注点，连接点是在应用程序中可以插入切面的点，而通知是在连接点上执行的代码。使用AOP，我们可以将通用的横切关注点（如日志记录）应用于多个对象，而不必在每个对象中重复实现。

AOP可以提供更清晰和模块化的代码结构，减少代码冗余，并提高代码的可维护性和可重用性。它被广泛应用于许多领域，如日志记录、安全性、事务管理等。

#### 2. AOP 的优缺点 ####

AOP的优点包括：

1.  横切关注点的分离：AOP允许将横切关注点（如日志记录、事务管理）从主要业务逻辑中分离出来，使代码更加清晰和模块化。
2.  代码重用性：通过将通用的横切关注点应用于多个对象，AOP可以减少代码重复，提高代码的可维护性和可重用性。
3.  非侵入性：AOP可以在不修改原始代码的情况下，通过将切面织入到连接点上，实现对横切关注点的处理。
4.  提高可维护性：将横切关注点从主要业务逻辑中分离出来，使代码更易于理解、测试和维护。

AOP的缺点包括：

1.  学习曲线：理解和使用AOP的概念可能需要一定的学习曲线，特别是对于初学者来说。
2.  运行时性能开销：AOP在运行时会对代码进行增强和织入，可能会引入一定的性能开销。
3.  难以调试：由于AOP将横切关注点分离出来，因此在调试过程中可能会增加一定的复杂性。
4.  滥用可能导致代码混乱：如果过度使用AOP，将过多的关注点分离出来，可能会导致代码变得混乱和难以理解。

#### 3. AOP 的应用场景 ####

AOP的应用场景包括但不限于以下几个方面：

1.  日志记录：通过AOP可以在方法执行前后插入日志记录的切面，方便记录系统的运行状态、错误信息等，便于排查问题和监控系统运行情况。
2.  事务管理：AOP可以用于管理事务的切面，将事务的开始、提交或回滚等操作封装到切面中，简化了事务管理的代码和逻辑。
3.  安全性控制：AOP可以用于实现安全性控制的切面，例如在方法执行前进行身份验证、权限检查等，确保只有具备相应权限的用户才能执行敏感操作。
4.  性能监控：通过AOP可以在方法执行前后插入性能监控的切面，用于统计方法的执行时间、资源消耗等指标，以便优化系统性能。
5.  异常处理：AOP可以用于处理异常的切面，捕获方法执行过程中抛出的异常，并进行相应的处理，例如记录日志、发送通知等。
6.  缓存管理：AOP可以用于缓存管理的切面，通过在方法执行前检查缓存中是否存在结果，避免重复计算或查询数据库，提高系统的性能和响应速度。
7.  分布式追踪：AOP可以用于实现分布式追踪的切面，记录请求的跟踪信息，方便在分布式系统中进行故障排查和性能优化。

#### 4. AOP 的注解使用 ####

AOP的注解有以下几个常用的：

1.  @Aspect: 用于定义切面，通常与其他注解一起使用。
2.  @Before: 在目标方法执行之前执行的通知。
3.  @After: 在目标方法执行之后执行的通知，无论方法是否抛出异常。
4.  @AfterReturning: 在目标方法执行之后执行的通知，仅当方法成功返回时执行。
5.  @AfterThrowing: 在目标方法抛出异常时执行的通知。
6.  @Around: 包围目标方法的通知，可以在方法执行前后都执行自定义的逻辑。
7.  @Pointcut: 定义切点，用于指定哪些方法应该被织入切面。
8.  @Order: 指定切面的执行顺序，数值越小优先级越高。
9.  @DeclareParents: 引入新的接口并将其实现类织入到目标对象中。
10. @EnableAspectJAutoProxy: 启用自动代理，用于自动创建代理对象并将切面织入到目标对象中。

##### 4.1. @Before #####

@Before 是一个在目标方法执行之前执行的通知注解。使用 @Before 注解可以定义一个切面的前置通知，即在目标方法执行之前执行一些自定义的逻辑。

@Before 注解可以应用于切面类的方法上，用于指定在哪些连接点（方法）之前应用该通知。通常，可以通过定义一个切点表达式来选择目标方法。

@Before 注解的使用示例：

@Aspect
    public class LoggingAspect {
        
        @Before("execution(* com.jiliu.MyClass.myMethod(..))")
        public void beforeAdvice() {
        
            // 在目标方法执行之前执行的逻辑
            System.out.println("Before advice executed.");
        }
    }

@Before 注解应用于 LoggingAspect 类中的 beforeAdvice() 方法。通过切点表达式 `execution(* com.jiliu.MyClass.myMethod(..))` ，指定了在 com.example.MyClass 类中的 myMethod 方法执行之前执行该前置通知。

在实际应用中，可以根据需要在 @Before 注解的方法中编写自定义的逻辑，例如记录日志、进行参数验证等操作。这些逻辑将在目标方法执行之前被执行。

##### 4.2. @After #####

@After 是一个在目标方法执行之后执行的通知注解。使用 @After 注解可以定义一个切面的后置通知，即在目标方法执行之后执行一些自定义的逻辑。

@After 注解可以应用于切面类的方法上，用于指定在哪些连接点（方法）之后应用该通知。通常，可以通过定义一个切点表达式来选择目标方法。

@After 注解的使用示例：

@Aspect
    public class LoggingAspect {
        
        @After("execution(* com.jiliu.MyClass.myMethod(..))")
        public void afterAdvice() {
        
            // 在目标方法执行之后执行的逻辑
            System.out.println("After advice executed.");
        }
    }

@After 注解应用于 LoggingAspect 类中的 afterAdvice() 方法。通过切点表达式 `execution(* com.jiliu.MyClass.myMethod(..))` ，指定了在 com.example.MyClass 类中的 myMethod 方法执行之后执行该后置通知。

##### 4.3. @AfterReturning #####

@AfterReturning 是一个在目标方法成功返回后执行的通知注解。使用 @AfterReturning 注解可以定义一个切面的返回通知，即在目标方法成功返回结果后执行一些自定义的逻辑。

@AfterReturning 注解可以应用于切面类的方法上，用于指定在哪些连接点（方法）成功返回后应用该通知。通常，可以通过定义一个切点表达式来选择目标方法。

@AfterReturning 注解的使用示例：

@Aspect
    public class LoggingAspect {
        
        
        @AfterReturning(pointcut = "execution(* com.jiliu.MyClass.myMethod(..))", returning = "result")
        public void afterReturningAdvice(Object result) {
        
            // 在目标方法成功返回后执行的逻辑
            System.out.println("After returning advice executed. Result: " + result);
        }
    }

上述示例中，@AfterReturning 注解应用于 LoggingAspect 类中的 afterReturningAdvice() 方法。通过切点表达式 `execution(* com.jiliu.MyClass.myMethod(..))` ，指定了在 com.example.MyClass 类中的 myMethod 方法成功返回后执行该返回通知。同时，通过 `returning` 属性指定了返回值的名称为 `result` 。

##### 4.4. @AfterThrowing #####

@AfterThrowing 是一个在目标方法抛出异常时执行的通知注解。使用 @AfterThrowing 注解可以定义一个切面的异常通知，即在目标方法抛出异常后执行一些自定义的逻辑。

@AfterThrowing 注解可以应用于切面类的方法上，用于指定在哪些连接点（方法）抛出异常后应用该通知。通常，可以通过定义一个切点表达式来选择目标方法。

@AfterThrowing 注解的使用示例：

@Aspect
    public class LoggingAspect {
        
        @AfterThrowing(pointcut = "execution(* com.jiliu.MyClass.myMethod(..))", throwing = "ex")
        public void afterThrowingAdvice(Exception ex) {
        
            // 在目标方法抛出异常后执行的逻辑
            System.out.println("After throwing advice executed. Exception: " + ex.getMessage());
        }
    }

上述示例中，@AfterThrowing 注解应用于 LoggingAspect 类中的 afterThrowingAdvice() 方法。通过切点表达式 `execution(* com.jiliu.MyClass.myMethod(..))` ，指定了在 com.example.MyClass 类中的 myMethod 方法抛出异常后执行该异常通知。同时，通过 `throwing` 属性指定了异常对象的名称为 `ex` 。  
。

##### 4.5. @Around #####

@Around 是一个在目标方法执行前后包围执行的通知注解。使用 @Around 注解可以定义一个切面的环绕通知，即在目标方法执行前后执行一些自定义的逻辑。

@Around 注解可以应用于切面类的方法上，用于指定在哪些连接点（方法）前后应用该通知。通常，可以通过定义一个切点表达式来选择目标方法。

@Around 注解的使用示例：

@Aspect
    public class LoggingAspect {
        
        @Around("execution(* com.jiliu.MyClass.myMethod(..))")
        public Object aroundAdvice(ProceedingJoinPoint joinPoint) throws Throwable {
        
            // 在目标方法执行前的逻辑
            System.out.println("Before advice executed.");
             // 执行目标方法
            Object result = joinPoint.proceed();
             // 在目标方法执行后的逻辑
            System.out.println("After advice executed.");
             return result;
        }
    }

上述示例中，@Around 注解应用于 LoggingAspect 类中的 aroundAdvice() 方法。通过切点表达式 `execution(* com.example.MyClass.myMethod(..))` ，指定了在 com.jiliu.MyClass 类中的 myMethod 方法前后执行该环绕通知。

#### 5. JDK 动态代理 ####

JDK 动态代理是 Java 提供的一种实现代理模式的机制。它允许在运行时动态地创建代理类和代理对象，以实现对目标对象的代理访问和控制。

##### 5.1. JDK 动态代理的工作原理 #####

1.  定义一个接口：首先需要定义一个接口，作为代理类和目标类的公共接口，以便代理类能够代理目标类的方法。
2.  实现 InvocationHandler 接口：创建一个实现 InvocationHandler 接口的类，该类负责实现代理类的具体逻辑。
3.  创建代理对象：使用 Proxy 类的静态方法 `newProxyInstance()` 创建代理对象。该方法接受三个参数：类加载器、代理类实现的接口数组和 InvocationHandler 对象。
4.  调用代理对象方法：通过代理对象调用方法时，会触发 InvocationHandler 的 invoke() 方法，从而执行代理类的逻辑。

##### 5.2. JDK 动态代理的优点 #####

1.  简化代理类的编写：相比于静态代理，动态代理可以根据接口动态生成代理类，避免了手动编写大量的代理类。
2.  灵活性：动态代理可以在运行时决定代理的行为，可以根据需要动态地添加、修改或删除代理逻辑。
3.  代码复用性：多个目标对象可以共享同一个代理对象，避免了重复创建代理类的开销。

##### 5.3. JDK 动态代理的缺点 #####

1.  仅支持接口代理：JDK 动态代理只能代理接口，无法直接代理类。
2.  基于接口的代理限制：由于 JDK 动态代理是基于接口的，因此只能代理实现了接口的方法，无法代理类中的非接口方法。
3.  运行时性能开销：相比于静态代理，动态代理在运行时需要进行额外的方法调用和反射操作，可能会引入一定的性能开销。

##### 6.4. JDK 动态代理使用方法 #####

JDK 动态代理是 Java 提供的一种动态代理技术，它通过在运行时生成代理对象来拦截方法调用。使用 JDK 动态代理，需要按照以下步骤进行操作：

1.  创建一个实现 InvocationHandler 接口的类，该类将作为代理对象的调用处理程序。在该类中，可以实现在方法调用前后添加自定义逻辑的逻辑。
2.  使用 Proxy 类的静态方法 `newProxyInstance()` 创建代理对象。该方法接受三个参数：ClassLoader、代理对象要实现的接口数组和 InvocationHandler 对象。
3.  使用生成的代理对象调用方法，实际上会触发 InvocationHandler 中的 `invoke()` 方法。

下面是一个简单的示例代码，演示了如何使用 JDK 动态代理：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    
    public class JdkDynamicProxyExample {
        
        public static void main(String[] args) {
        
            // 创建目标对象
            RealObject realObject = new RealObject();
             // 创建代理对象
            MyInvocationHandler handler = new MyInvocationHandler(realObject);
            MyInterface proxy = (MyInterface) Proxy.newProxyInstance(
                    MyInterface.class.getClassLoader(),
                    new Class[]{
        MyInterface.class},
                    handler
            );
             // 使用代理对象调用方法
            proxy.doSomething();
        }
    }
    
    interface MyInterface {
        
        void doSomething();
    }
    
    class RealObject implements MyInterface {
        
        public void doSomething() {
        
            System.out.println("RealObject doSomething()");
        }
    }
    
    class MyInvocationHandler implements InvocationHandler {
        
        private Object target;
        
        public MyInvocationHandler(Object target) {
        
            this.target = target;
        }
        
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
            System.out.println("Before method invocation");
            Object result = method.invoke(target, args);
            System.out.println("After method invocation");
            return result;
        }
    }

我们创建了一个实现 `InvocationHandler` 接口的 `MyInvocationHandler` 类，用于处理代理对象的方法调用。然后，使用 `Proxy` 类的 `newProxyInstance()` 方法创建了代理对象，并传入目标对象、接口和调用处理程序。最后，使用代理对象调用方法，实际上会触发 `MyInvocationHandler` 中的 `invoke()` 方法，在方法调用前后添加了自定义逻辑。

#### 6. Cglib 动态代理 ####

Cglib 动态代理是一种基于字节码生成的动态代理技术。它使用了一个开源的字节码处理框架，可以在运行时动态地生成目标类的子类，并重写其中的方法。这使得 Cglib 能够代理那些没有实现接口的类。

##### 6.1. 特点 #####

相对于 JDK 的动态代理，Cglib 动态代理具有以下特点：

1.  无需实现接口：Cglib 可以代理没有实现接口的类，这使得它更加灵活。
2.  高性能：Cglib 使用了底层的字节码生成技术，生成的代理类是目标类的子类，因此方法调用的性能比 JDK 动态代理更高。
3.  功能丰富：Cglib 可以代理目标类的所有方法，包括 final 方法。

##### 6.2. Cglib 动态代理的步骤 #####

使用 Cglib 动态代理的步骤如下：

1.  引入 Cglib 库：在项目中引入 Cglib 的相关依赖。
2.  创建 Enhancer 对象：Enhancer 是 Cglib 的核心类，用于生成代理类。
3.  设置父类和回调方法：通过 Enhancer 对象的 setSuperclass() 方法设置目标类作为父类，然后通过 setCallback() 方法设置回调方法。
4.  创建代理对象：调用 Enhancer 对象的 create() 方法生成代理对象。
5.  使用代理对象：通过代理对象调用目标类的方法，实际上会触发回调方法的执行。

##### 6.2. 使用方法 #####

如何使用Cglib动态代理：

1.  将Cglib库添加到项目的依赖中。可以在Maven中央仓库中找到它，或者从官方Cglib网站下载JAR文件。
2.  确定要代理的类。Cglib可以代理没有实现任何接口的类。
3.  创建一个MethodInterceptor实现。这个接口类似于JDK动态代理中的InvocationHandler，它拦截对代理对象的方法调用。
4.  使用Cglib的Enhancer类创建代理对象。Enhancer类负责生成充当代理的目标类的子类。

以下是一个示例代码片段，演示了如何使用Cglib动态代理：

import net.sf.cglib.proxy.Enhancer;
    import net.sf.cglib.proxy.MethodInterceptor;
    import net.sf.cglib.proxy.MethodProxy;
    import java.lang.reflect.Method;
    
    public class CglibProxyExample {
        
        public static void main(String[] args) {
        
            // 第一步：创建MethodInterceptor实现
            MethodInterceptor interceptor = new MethodInterceptor() {
        
                
                @Override
                public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        
                    // 在方法调用之前和/或之后添加自定义逻辑
                    System.out.println("方法调用之前");
                    Object result = proxy.invokeSuper(obj, args);
                    System.out.println("方法调用之后");
                    return result;
                }
            };
             // 第二步：使用Enhancer创建代理对象
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(TargetClass.class);
            enhancer.setCallback(interceptor);
            TargetClass proxy = (TargetClass) enhancer.create();
             // 第三步：使用代理对象
            proxy.methodToBeIntercepted();
        }
    }
    
    class TargetClass {
        
        public void methodToBeIntercepted() {
        
            System.out.println("目标方法被调用");
        }
    }

`MethodInterceptor` 实现拦截了对代理对象的方法调用，并在方法调用之前和之后添加了自定义逻辑。使用 `Enhancer` 类创建代理对象时，指定了目标类和拦截器。最后，使用代理对象调用目标方法。

#### 7. AOP 切点表达式 ####

AOP（面向切面编程）是一种编程范式，它允许在应用程序中以声明方式定义横切关注点，并将其模块化。在 AOP 中，切点表达式用于指定在何处应用横切关注点。

切点表达式是一个字符串，用于匹配目标方法的签名和执行位置。它可以使用不同的语法和通配符来定义切点。下面是一些常用的切点表达式语法：

1.  方法名匹配：

*  `execution(public * com.example.service.*.*(..))` ：匹配 com.example.service 包下所有公共方法。
 *  `execution(* *Service.*(..))` ：匹配任何以 “Service” 结尾的类中的所有方法。

1.  参数匹配：

*  `args(java.lang.String)` ：匹配接受一个 String 类型参数的方法。
 *  `args(java.lang.String, ..)` ：匹配接受至少一个 String 类型参数的方法。

1.  注解匹配：

*  `@annotation(org.springframework.transaction.annotation.Transactional)` ：匹配使用 @Transactional 注解的方法。

1.  类型匹配：

*  `within(com.example.service.*)` ：匹配 com.example.service 包中的所有方法。
 *  `within(com.example.service..*)` ：匹配 com.example.service 包及其子包中的所有方法。

1.  组合匹配：

*  `execution(public * com.example.service.*.*(..)) && @annotation(org.springframework.transaction.annotation.Transactional)` ：同时匹配方法名以及使用 @Transactional 注解的方法。

这只是一些常见的切点表达式示例，实际上，可以根据需要组合和定制切点表达式。切点表达式是使用 AspectJ 语言编写的，它是 AOP 的一种实现方式。在 Spring 框架中，可以使用 AspectJ 的切点表达式语法来定义切点，并将其与通知（Advice）结合使用，实现横切关注点的织入。

##### 7.1. 切点使用案例 #####

假设我们有一个简单的电子商务应用，其中有一个订单服务类 `OrderService` ，它包含了一些方法，我们想在某些方法执行前后添加日志记录的功能。

首先，我们定义一个切点表达式来匹配所有的 `OrderService` 类中的方法：

execution(* com.example.service.OrderService.*(..))

然后，我们创建一个切面类 `LoggingAspect` ，其中包含了一个前置通知和一个后置通知，用于在方法执行前后添加日志记录的逻辑：

import org.aspectj.lang.JoinPoint;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.AfterReturning;
    
    @Aspect
    public class LoggingAspect {
        
        @Before("execution(* com.example.service.OrderService.*(..))")
        public void beforeMethodExecution(JoinPoint joinPoint) {
        
            String methodName = joinPoint.getSignature().getName();
            System.out.println("Before executing method: " + methodName);
        }
         
        @AfterReturning(pointcut = "execution(* com.example.service.OrderService.*(..))", returning = "result")
        public void afterMethodExecution(JoinPoint joinPoint, Object result) {
        
            String methodName = joinPoint.getSignature().getName();
            System.out.println("After executing method: " + methodName);
            System.out.println("Returned value: " + result);
        }
    }

`@Before` 注解表示前置通知，它会在切点匹配的方法执行前被调用。 `@AfterReturning` 注解表示后置通知，它会在切点匹配的方法执行后被调用，并且可以获取方法的返回值。

最后，我们需要在配置文件中声明这个切面，并将其与目标类 `OrderService` 关联起来：

<aop:aspectj-autoproxy/>
    <bean id="orderService" class="com.example.service.OrderService"/>
    <bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/>

现在，当我们调用 `OrderService` 中的方法时，切面中的前置通知和后置通知将会被触发，从而实现了日志记录的功能。

#### 8. 通知方法的执行顺序 ####

在AOP中，通知方法的执行顺序取决于其类型和连接点的类型。以下是常见的通知方法执行顺序：

1.  前置通知（Before advice）：在目标方法执行之前执行。多个前置通知按照声明的顺序依次执行。
2.  环绕通知（Around advice）：在目标方法执行前后都可以执行。环绕通知可以控制目标方法的执行，可以选择在目标方法执行前、后或两者都执行。
3.  后置通知（After advice）：在目标方法执行之后（无论是否抛出异常）执行。多个后置通知按照声明的顺序依次执行。
4.  返回通知（After returning advice）：在目标方法成功执行并返回结果后执行。可以获取目标方法的返回值。
5.  异常通知（After throwing advice）：在目标方法抛出异常时执行。可以捕获并处理目标方法抛出的异常。

通知方法的执行顺序还受到连接点类型的影响。连接点是在应用程序中可以插入通知的特定位置，例如方法调用或异常抛出等。通常，通知方法的执行顺序遵循以下规则：

*  环绕通知优先于其他通知执行，在目标方法执行前后都会执行。
 *  前置通知在目标方法之前执行。
 *  后置通知在目标方法之后执行，无论目标方法是否抛出异常。
 *  返回通知在目标方法成功执行并返回结果后执行。
 *  异常通知在目标方法抛出异常时执行。  
    需要注意的是，如果在同一个切面中定义了多个通知方法，并且它们都适用于相同的连接点，那么它们的执行顺序将按照通知类型的优先级进行执行。

通知方法的执行顺序取决于其类型（如前置、后置、环绕、返回、异常）以及连接点的类型。

>  精彩专栏推荐订阅：在下方专栏??  
>  ✅ [2023年华为OD机试真题（A卷&B卷）+ 面试指导 ][2023_OD_A_B_ _]  
>  ✅ [ 精选100套 Java 项目案例 ][_100_ Java _]  
>  ✅ [面试需要避开的坑（活动）][Link 3]  
>  ✅ [你找不到的核心代码][Link 4]  
>  ✅ [带你手撕 Spring][Spring]  
>  ✅ [Java 初阶][Java 2]

![在这里插入图片描述][7b7478e55aa24a948b358051ef941b6a.webp_pic_center]

[b7a7bfb437bc4f2abf6d9b6ef0986077.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/05/04/058631ae26d349b08cf46e689ece48f9.png
[Link 1]: https://bbs.csdn.net/forums/45c04d3f41cc4dadaf312be1d1379b45?category=10003
[Link 2]: https://jiliu.blog.csdn.net/
[Java]: https://blog.csdn.net/qq_37967783/category_12399402.html
[Java 1]: https://blog.csdn.net/qq_37967783/article/details/130940512
[2023_OD_A_B_ _]: https://blog.csdn.net/qq_37967783/category_12389634.html
[_100_ Java _]: https://blog.csdn.net/qq_37967783/category_12388267.html
[Link 3]: https://blog.csdn.net/qq_37967783/category_12380337.html
[Link 4]: https://blog.csdn.net/qq_37967783/category_12391346.html
[Spring]: https://blog.csdn.net/qq_37967783/category_12391987.html
[Java 2]: https://blog.csdn.net/qq_37967783/category_9902143.html
[7b7478e55aa24a948b358051ef941b6a.webp_pic_center]: https://img-blog.csdnimg.cn/7b7478e55aa24a948b358051ef941b6a.webp#pic_center