【Spring】3.深入浅出Spring AOP的使用及优化

已于 2024-04-30 22:01:50 修改
阅读量396 收藏 8
点赞数 29
分类专栏： Spring系列 文章标签： spring java 后端
于 2024-04-30 17:42:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37519752/article/details/138349806
版权

一.AOP是什么

面向切面编程（AOP）是一种编程技术，用于将横切关注点（如日志记录、事务管理等）与业务逻辑分离，以提高代码的模块化和可重用性。以下是AOP中一些核心概念的解释，以及相应的Spring AOP代码示例。

1. 切面（Aspect）

切面是封装横切关注点的模块。在Spring AOP中，切面通常由带有@Aspect注解的类定义。

@Aspect
@Component
public class LoggingAspect {
    // 通知方法将在这里定义
}

2. 连接点（Join point）

连接点是程序执行的特定点，如方法的调用或属性的访问。在Spring AOP中，连接点通常是方法的执行。

// 这是一个连接点的示例，但Spring AOP不直接操作连接点，而是通过切点来匹配连接点
public void someBusinessMethod() {
    // 方法体
}

3. 切点（Pointcut）

切点用于匹配连接点，它定义了通知应该应用到哪些连接点上。在Spring AOP中，切点通过表达式定义。

@Pointcut("execution(* com.example.service.*.*(..))")
public void anyMethodInServicePackage() {
    // 切点定义，匹配com.example.service包下的所有方法
}

4. 通知（Advice）

通知是在匹配到的连接点上执行的代码。Spring AOP支持五种类型的通知：before、after、around、after-returning和after-throwing。

@Before("anyMethodInServicePackage()")
public void logBefore(JoinPoint joinPoint) {
    System.out.println("Before method: " + joinPoint.getSignature().getName());
}

5. 织入（Weaving）

织入是将切面应用到目标对象以创建新对象的过程。在Spring AOP中，这通常是在运行时通过代理工厂完成的。

// 织入过程由Spring容器在创建代理时自动完成，通常不需要显式编码

6. 代理（Proxy）

代理是AOP框架创建的，用于在执行目标对象的方法前后应用通知的对象。Spring AOP可以创建两种类型的代理：JDK动态代理和CGLIB代理。

@Service
public class ServiceProxy {
    public void performAction() {
        // 业务逻辑
    }
}

// 在Spring配置中，无需显式创建代理，容器会自动处理

在Spring AOP中，代理的创建通常是自动的，只需要定义切面和通知，然后Spring容器会为你创建代理对象。当注入Service接口的实现并调用其方法时，实际上是在调用代理对象，而不是直接调用目标对象。

二.工作原理

AOP（面向切面编程）允许开发者把一些通用的功能（比如日志记录、错误处理等）单独抽离出来，然后在程序运行时，自动将这些功能插入到指定的程序位置（如方法调用前后）。Spring AOP使用代理对象来实现这一点，它会在程序运行过程中动态地创建这些代理，并在代理中执行额外的逻辑，而不影响原有业务逻辑的执行。这样，开发者可以集中精力编写业务代码，同时通过配置来轻松实现如日志记录、事务管理等跨多个功能的通用任务。

三.工作流程

AOP的工作流程可以用以下简化的步骤来描述：

  1. 定义目标对象：首先，你需要有一个目标对象，它的某些方法需要被增强或修改。

  2. 创建切面和通知：定义一个切面（@Aspect注解的类），并在其中创建通知。通知是一组在特定时机运行的代码，比如在目标对象的方法执行前后。

  3. 编写切点表达式：切点表达式定义了通知应该应用到哪些方法上。它类似于一个规则，Spring AOP会根据这个规则来匹配目标对象中的方法。

  4. 配置Spring AOP环境：在Spring配置中启用AOP，并声明你的切面和通知。

  5. 动态代理的创建：

    • JDK代理：如果目标对象实现了接口，Spring AOP会使用JDK的Proxy类来创建一个代理对象。
    • CGLIB代理：如果目标对象没有实现接口，Spring AOP会使用CGLIB库来创建目标类的子类作为代理。

  6. 织入过程：在Spring容器启动时，AOP框架会将切面织入到目标对象中。这意味着在目标对象的方法执行路径中，会插入通知代码。

  7. 执行通知：当代理对象的方法被调用时，Spring AOP会根据定义的通知类型执行相应的通知：

    • @Before：在方法执行前运行的通知。
    • @After：在方法执行后运行的通知。
    • @Around：围绕方法执行的通知，可以控制方法的调用时机。
    • @AfterReturning：在方法成功返回后运行的通知。
    • @AfterThrowing：在方法抛出异常后运行的通知。

  8. 方法调用和返回：在通知执行完毕后，目标对象的方法会被调用，并返回结果。如果在执行过程中发生异常，相应的异常处理通知也会被触发。

通过这个流程，AOP允许开发者在不修改业务逻辑代码的情况下，控制和扩展方法的行为，实现代码的模块化和重用。

示例

下面是一个完整的Spring AOP示例，展示了AOP的工作流程，包括动态代理、切点表达式、通知类型以及织入过程。代码中的注释详细解释了每一步的作用。

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
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.JoinPoint;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.Ordered;

// 目标对象，将被AOP代理
public class MathService {
    public int divide(int a, int b) {
        // 简单的除法操作
        return a / b;
    }
}

// 定义切面，包含横切关注点
@Aspect
public class LoggingAspect implements Ordered {

    // 切点表达式，匹配MathService类中的所有方法
    @Pointcut("execution(* com.example.MathService.*(..))")
    public void mathServiceMethods() {}

    // 在方法执行前运行的通知
    @Before("mathServiceMethods()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before the method: " + joinPoint.getSignature().getName());
    }

    // 在方法执行后运行的通知
    @After("mathServiceMethods()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After the method: " + joinPoint.getSignature().getName());
    }

    // 在方法成功返回后运行的通知
    @AfterReturning(
        pointcut = "mathServiceMethods()",
        returning = "result"
    )
    public void afterReturningAdvice(Object result) {
        System.out.println("Method returned: " + result);
    }

    // 在方法抛出异常后运行的通知
    @AfterThrowing(
        pointcut = "mathServiceMethods()",
        throwing = "error"
    )
    public void afterThrowingAdvice(Throwable error) {
        System.out.println("Method threw exception: " + error);
    }

    // 环绕通知，可以控制方法的执行流程
    @Around("mathServiceMethods()")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("Before invoking method");
        Object result = pjp.proceed(); // 继续执行方法
        System.out.println("After invoking method");
        return result;
    }

    // 实现Ordered接口，可以指定切面的顺序
    @Override
    public int getOrder() {
        return 0;
    }
}

// Spring配置类，用于配置AOP和其他Bean
@EnableAspectJAutoProxy
public class AppConfig {

    public static void main(String[] args) {
        // 创建Spring应用上下文
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
        // 注册配置类
        context.register(AppConfig.class);
        // 启动Spring应用上下文
        context.refresh();

        // 获取MathService的代理对象
        MathService mathService = context.getBean(MathService.class);
        // 调用方法，会触发AOP代理和通知
        System.out.println("10 / 5 = " + mathService.divide(10, 5));

        // 关闭Spring应用上下文
        context.close();
    }

    @Bean
    public MathService mathService() {
        // 实例化目标对象
        return new MathService();
    }

    @Bean
    public LoggingAspect loggingAspect() {
        // 实例化切面对象
        return new LoggingAspect();
    }
}

在这个示例中：

  1. MathService 类是业务逻辑的代表，它包含一个简单的除法方法。

  2. LoggingAspect 类是一个切面，它定义了多个通知：

    • @Before 通知在方法执行前打印信息。
    • @After 通知在方法执行后打印信息。
    • @AfterReturning 通知在方法成功返回后打印返回值。
    • @AfterThrowing 通知在方法抛出异常后打印异常信息。
    • @Around 通知包围了方法的执行，可以在方法调用前后执行代码。

  3. AppConfig 类是Spring配置类，它使用 @EnableAspectJAutoProxy 注解来启用AOP功能，并声明了 MathService 和 LoggingAspect 作为Spring容器管理的bean。

  4. 在 AppConfig 的 main 方法中，我们启动Spring应用上下文，获取 MathService 的代理对象，并调用其 divide 方法。由于AOP的织入，实际上调用的是代理对象，会按照定义的顺序执行相关的AOP通知。

四.优缺点

AOP的核心优势在于它能够提高代码的模块化和可维护性，主要体现在：

  1. 减少重复代码：将日志、事务、安全性等横切关注点从业务逻辑中分离，避免代码重复。

  2. 增强模块化：通过切面封装横切关注点，使得业务逻辑更加集中，易于管理和维护。

  3. 提高可读性：业务逻辑代码更简洁，因为非业务逻辑的代码被移除。

  4. 易于维护和扩展：对横切关注点的修改只需在一个地方进行，简化了维护工作。

  5. 动态行为定制：可以在运行时动态添加或修改应用程序的行为。

然而，AOP也存在一些缺点：

  1. 增加复杂性：对于不熟悉AOP的开发者，可能会提高学习的难度。

  2. 调试困难：由于代码和行为分离，调试时可能更难以定位问题。

  3. 潜在性能影响：动态代理和织入可能会对性能产生一定影响。

  4. 事务管理风险：不当使用可能导致事务管理不当，如事务失效或过长。

AOP通过关注点分离解决了代码重复和模块化问题，但也需要合理使用，以避免引入新的问题。

五.与Spring其他模块集成

Spring AOP 可以与Spring框架的多个模块无缝集成，以提供声明式事务管理、安全性控制、数据访问等强大功能。以下是Spring AOP与其他Spring模块集成的一些常见方式：

集成方式：

  • 配置AOP环境：在Spring配置中启用AOP，并声明切面和通知。
  • 定义切面和通知：创建切面类，并定义通知方法，使用切点表达式来匹配需要增强的方法。
  • 声明式事务管理：使用Spring AOP和@Transactional注解来实现声明式事务管理。
  • 安全注解：使用Spring Security提供的注解，如@Secured或@PreAuthorize，结合AOP实现方法级别的安全性控制。
  • 异常处理：通过AOP捕获和处理Spring MVC或Spring Data层抛出的异常。

1. Spring MVC

Spring MVC是一个构建Web应用程序的模块，它使用控制器来处理用户的HTTP请求。通过Spring AOP，你可以为控制器层添加日志记录、事务管理、性能监控等横切关注点，而无需在每个控制器中重复编写相关代码。

// 使用AOP为Spring MVC的控制器添加事务管理
@Aspect
@Component
public class ControllerAdvice {
    @Around("execution(* com.example.web.controller.*.*(..)) && @annotation(org.springframework.web.bind.annotation.RequestMapping)")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
        // 事务开始前的逻辑
        Object result = pjp.proceed(); // 调用实际的方法
        // 事务结束后的逻辑
        return result;
    }
}

2. Spring Data

Spring Data提供了对各种数据库的简化访问，包括关系型数据库和NoSQL数据库。结合Spring AOP，可以在数据访问层实现缓存策略、延迟加载、查询优化等。

// 使用AOP为Spring Data的查询方法添加缓存逻辑
@Aspect
@Component
public class DataAccessAdvice {
    @Before("execution(* com.example.repository.*.find*(..))")
    public void cacheableAdvice(JoinPoint joinPoint) {
        // 实现缓存逻辑
    }
}

3. Spring Security

Spring Security是一个功能强大的安全模块，提供了认证和授权功能。通过Spring AOP，可以为安全控制添加更细粒度的访问控制、记录安全事件、实现方法级别的安全性等。

// 使用AOP为Spring Security的方法添加额外的安全检查
@Aspect
@Component
public class SecurityAdvice {
    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "exception")
    public void handleSecurityException(Throwable exception) {
        // 记录安全事件或执行其他安全相关的逻辑
    }
}

通过这种方式，Spring AOP作为一个横切关注点的框架，可以与Spring的其他模块紧密结合，提供一种灵活、声明式的方法来处理那些跨越多个模块的通用任务。

六.APO的优化

在Spring AOP中，优化性能主要涉及到合理地使用AOP特性，避免不必要的代理和织入，以及编写高效的切点表达式。以下是一些代码示例，展示如何在Spring AOP中实现这些优化策略：

1. 仅对需要的方法使用AOP

避免对所有方法都使用AOP，只对那些真正需要增强的方法应用AOP。

@Aspect
@Component
public class PerformanceAspect {

    // 仅匹配特定的方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void specificMethods() {}

    @Before("specificMethods()")
    public void beforeAdvice(JoinPoint joinPoint) {
        // 性能无关紧要的日志记录
    }
}

2. 使用合适的通知类型

选择最合适的通知类型来减少不必要的执行路径。

@Around("specificMethods()")
public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
    // 仅在必要时使用环绕通知
    long startTime = System.currentTimeMillis();
    try {
        return pjp.proceed(); // 调用实际的方法
    } finally {
        long endTime = System.currentTimeMillis();
        System.out.println("Execution time: " + (endTime - startTime) + " ms");
    }
}

3. 优化切点表达式

编写高效的切点表达式，避免匹配过多的方法。

@Pointcut("execution(public * com.example.service.*.*(..)) && !within(com.example.service.InternalService)")
public void performanceCriticalMethods() {}

4. 避免在循环中使用AOP

避免在循环内部调用被AOP增强的方法，以减少通知的执行次数。

public void someMethod() {
    for (int i = 0; i < 1000; i++) {
        // 循环内部不要调用AOP增强的方法
    }
}

5. 使用异步处理

对于可以异步执行的横切关注点，使用异步处理来避免阻塞主业务逻辑。

@Around("specificMethods()")
public Object asyncAdvice(ProceedingJoinPoint pjp) throws Throwable {
    // 异步执行通知逻辑
    CompletableFuture.runAsync(() -> {
        // 执行一些异步任务，如日志记录
    });
    
    return pjp.proceed(); // 继续执行业务逻辑
}

6. 监控和分析

使用Spring的监控工具来分析应用程序的性能，找出可能的性能瓶颈。

public void somePerformanceCriticalMethod() {
    // 性能关键的方法
}

然后在切面中添加监控逻辑：

@Around("performanceCriticalMethods()")
public Object monitorPerformance(ProceedingJoinPoint pjp) throws Throwable {
    long start = System.currentTimeMillis();
    try {
        return pjp.proceed(); // 执行方法
    } finally {
        long end = System.currentTimeMillis();
        // 记录或报告性能指标
        System.out.println("Method " + pjp.getSignature().getName() + " took " + (end - start) + " ms");
    }
}

通过上述代码可以对Spring AOP的性能进行优化。这些策略包括合理使用AOP通知、优化切点表达式、避免在循环中使用AOP、使用异步处理，以及监控和分析性能。通过这些方法，可以在享受AOP带来的便利的同时，最大限度地减少其对性能的影响。

七.AOP的工具和库

AOP（面向切面编程）领域中有几个流行的工具和库，每个都有其特定的应用场景和优缺点。以下是一些常用的AOP工具和库，以及它们的集成方法和代码示例。

1. AspectJ

优点：

  • 功能强大，提供复杂的切点表达式。
  • 支持编译时织入，减少运行时性能开销。

缺点：

  • 学习曲线较陡峭。
  • 可能引入额外的复杂性。

集成：
在Maven项目中的pom.xml文件中添加AspectJ依赖：

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.7</version>
</dependency>

在Spring配置中启用AspectJ：

@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 其他配置...
}

2. Spring AOP

优点：

  • 与Spring框架集成良好。
  • 提供声明式事务管理等特性。

缺点：

  • 功能相对于AspectJ有所限制。

集成：
作为Spring框架的一部分，无需额外集成代码。

3. Javassist

优点：

  • 用于字节码操作，可以在运行时修改类。

缺点：

  • 使用较为复杂，需要理解字节码。

集成：
添加Javassist依赖到项目：

<dependency>
    <groupId>javassist</groupId>
    <artifactId>javassist</artifactId>
    <version>3.27.0-GA</version>
</dependency>

使用Javassist创建代理：

// Javassist通常用于自定义代理工厂中，而不是直接集成到Spring AOP中。

4. CGLIB

优点：

  • 用于动态生成和修改类，是Spring AOP的底层实现之一。

缺点：

  • 主要用于创建代理，不提供完整的AOP解决方案。

集成：
作为Spring AOP的一部分，无需额外集成代码。

5. Byte Buddy

优点：

  • 用于创建Java字节码操作，是CGLIB的现代替代品。

缺点：

  • 专业性强，不适合初学者。

集成：
添加Byte Buddy依赖到项目：

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.11.0</version>
</dependency>

使用Byte Buddy创建代理：

// Byte Buddy通常用于自定义代理工厂中，而不是直接集成到Spring AOP中。

6. Proxies-java

优点：

  • 提供多种代理类型的实现。

缺点：

  • 主要用于代理的创建。

集成：
添加Proxies-java依赖到项目：

<dependency>
    <groupId>io.github.proxies-java</groupId>
    <artifactId>proxies</artifactId>
    <version>1.0.0</version>
</dependency>

集成代码注释：

  • AspectJ：通过Maven依赖添加到项目，并使用Spring的@EnableAspectJAutoProxy注解启用。
  • Spring AOP：作为Spring框架的一部分，无需单独集成。
  • Javassist、CGLIB、Byte Buddy：这些库通常用于自定义代理工厂，而不是直接集成到Spring AOP中。它们可以通过添加相应的Maven依赖来集成，并在自定义代码中使用。
  • Proxies-java：添加Maven依赖后，可以根据项目需求在自定义代码中使用。

选择哪个AOP工具或库取决于项目的具体需求、团队的技术栈以及对性能和复杂性的考量。在集成这些工具和库时，务必遵循它们各自的最佳实践和文档指南。

夹娃小能手
关注
  • 29
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
《深入浅出Spring》SpringAOP 详解AspectJ
ysj_2021的博客
07-22 542
Spring AOP AspectJ
《深入浅出Spring》Spring AOP 详解
ysj_2021的博客
07-19 385
Spring AOP
深入浅出 Spring Boot 3.x：从原理到实战，全面解锁 Java 后端开发新潮流
努力是为了站在万人之中，成为别人的光
04-25 3万+
Spring框架是Java EE开发的强有力的工具和事实标准，而Spring Boot采用“约定优于配置”的原则简化 Spring的开发，成为业界流行的微服务开发框架，被越来越多的企业采用。为了适应新潮流，本书对Spring Boot 3.x技术进行深入讲解。
【Spring-AOP基础】深入浅出Spring-AOP（从动态代理到Spring AOP）
热门推荐
ATFWUS的博客
04-22 11万+
AOP（Aspect Oriented Programming） 1.概念 AOP：全称是 Aspect Oriented Programming即：面向切面编程。
《深入浅出 Spring Boot 3.x》预计3月份发版
ykzhen2015的专栏
02-22 1024
各位，目前本来新书《深入浅出 Spring Boot 3.x》已经到了最后编辑排版阶段，即将在3月份发布。
JavaSpring-AOP详解（Maven导入 深入浅出）
Garson的博客
10-07 2681
在CSDN上看了很多关于配置AOP的文章，不是很复杂就是省略了很多步骤。本文用最简单并且最清晰的方法从导入依赖到AOP底层原理。逐步讲解SpringAOP的相关操作帮你快速了解AOP。
深入浅出SpringSecurity
-
04-11 4580
SpringSecurity学习 SpringSecurity简介 安全框架的概述 什么是安全框架？是为了解决安全问题的框架。如果没有安全框架，我们需要手动处理每个资源的访问控制，非常麻烦。使用安全框架，我们可以通过的配置方式实现对资源的访问控制。 常用的安全框架概述 SpringSecurity：Spring家族的一员，是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方...
《深入浅出Spring》SpringAOP 详解 ProxyFactoryBean
ysj_2021的博客
07-21 439
SpringAOP
《深入浅出Spring Boot 3.x》已经交稿，目前在编写《Spring Cloud Alibaba微服务实践》
ykzhen2015的专栏
06-20 2611
最近基于《深入浅出Spring Boot 2.x》升级为《深入浅出Spring Boot 3.x》已经完成，预计双11前可以出版，我先贴出目录给大家看看。预计今年11月左右可以出版，因为最近国家对出版社要求高，所以出书速度很慢。安全——Spring Security。Spring Boot 3.x的来临。开始约定编程——Spring AOP。打包、测试、监控、AOT和容器部署。文档数据库——MongoDB。使用性能利器——Redis。学点Spring其他的技术。构建REST风格网站。实践一下——抢购商品。
开发工具 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...
SpringAOP.rar_springAOP
09-23
springAOP面向切面编程，动态的实现业务方法的分离。提高代码重用性。
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.docx
12-14
Spring aop 学习资料
spring-nested-aop.zip_aop_spring aop
09-23
Spring AOP演示程序，实现Spring AOP的嵌套式事务处理。是个绝好的演示程序。
(三)Spring教程——依赖注入与控制反转
05-14 561
Spring有两个重要的接口：BeanFactory和ApplicationContext，所谓的容器就是实现了BeanFactory接口或者是ApplicationContext接口的类的实例，BeanFactory是最顶层、最基本的接口，它描述了容器需要实现的最基本的功能，比如对象的注册、获取等。在编写传统的Java应用代码时，我们一般是直接在对象内部通过new来创建对象，让程序主动去创建依赖对象，这就是一个“谁使用，谁创建”的过程，创建依赖对象的主动权和创建时机都是由自己来把控。
spring 循环依赖
weixin_45849726的博客
05-14 442
先创建ABean1.0. 记录正在创建ABean singletonCurrentlyInCreation<1.1.实例化ABean–>得到一个对象–>存入singletonFactories1.2. 填充BBean属性–>去单例池找BBean–>没有就创建1.3. 进行其他依赖注入1.4. 初始化前，初始化1.5. 初始化后1.6. 放入单例池创建BBean2.1. 实例化BBean–>得到一个对象。
java云his系统源码 一站式诊所SaaS系统Java+Spring+Angular+Nginx 云HIS系统八大特点
zmm201453的博客
05-15 1214
HIS系统采用面向技术架构的分析与设计方法，应用多层次应用体系架构设计，运用基于构件技术的系统搭建模式与基于组件模式的系统内核结构。通过建立统一接口标准，实现数据交换和集成共享，通过统一身份认证和授权控制，实现业务集成、界面集成。
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器
最新发布
shijialeya
05-18 377
解决 SpringBoot 的 Date、LocalDateTime 变成时间戳和数组的问题，创建自定义对象消息转换器进行数据格式化。
springioc和aop的理解例子
08-26
- *1* [SpringIOC和AOP理解之深入浅出（建议收藏）](https://blog.csdn.net/weixin_45105261/article/details/112004029)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值