AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

【面试必问】Spring核心之面向切面编程(AOP)

2023-06-14 134
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
日志服务 SLS，月写入数据量 50GB 1个月
简介： AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。

博主介绍： ✌博主从事应用安全和大数据领域，有8年研发经验，5年面试官经验，Java技术专家✌

Java知识图谱点击链接：体系化学习Java（Java面试专题）

💕💕 感兴趣的同学可以收藏关注下 ，不然下次找不到哟💕💕

1686547256994.jpg

1、什么是 AOP

1.1、概述

AOP（面向切面编程）是一种编程范式，用于将横切关注点（如日志记录、性能统计等）从主要业务逻辑中分离出来。通过将这些横切关注点与业务逻辑分离开来，可以提高代码的可重用性、可维护性和可扩展性。在AOP中，切面是一个模块化的单元，它封装了与横切关注点相关的行为，并可以在多个不同的应用程序中重用。切面可以通过一种称为“织入”的过程将其与主要业务逻辑相结合，从而创建一个完整的应用程序。

1.2、AOP 的作用

AOP 的作用主要有以下几个方面：

1. 代码复用：AOP 可以将一些通用的功能，如日志记录、安全控制等，抽象出来形成切面，这些切面可以被多个模块或应用程序共享，从而避免了代码重复。

2. 降低耦合度：AOP 可以将一些横跨多个模块的关注点从业务逻辑中解耦出来，使得应用程序更加模块化，降低了各个模块之间的耦合度。

3. 提高代码可维护性：AOP 可以将一些非核心的功能从主要业务逻辑中分离出来，使得代码更加清晰、易于维护。

4. 提高代码可扩展性：AOP 可以在不修改主要业务逻辑的情况下，通过增加新的切面来扩展应用程序的功能。

5. 提高代码的灵活性：AOP 可以在运行时动态地将切面织入到主要业务逻辑中，从而可以根据不同的需求对应用程序进行配置和定制。

1.3、AOP 的应用场景

AOP 的应用场景比较广泛，以下是一些常见的应用场景：

  1. 日志记录：通过 AOP 可以在方法执行前后记录日志，方便开发人员对系统进行调试和问题排查。

  2. 安全控制：通过 AOP 可以在方法执行前进行权限校验，从而保证系统的安全性。

  3. 缓存管理：通过 AOP 可以在方法执行前后对数据进行缓存，从而提高系统的性能。

  4. 事务管理：通过 AOP 可以在方法执行前后进行事务管理，从而保证系统的数据一致性。

  5. 性能统计：通过 AOP 可以在方法执行前后进行性能统计，从而方便开发人员对系统进行性能优化。

  6. 异常处理：通过 AOP 可以在方法执行过程中捕获异常，并进行统一的处理，从而提高系统的健壮性和稳定性。

  7. 分布式追踪：通过 AOP 可以在方法执行前后进行分布式追踪，从而方便开发人员对系统进行分布式调试和问题排查。

2、AOP 的配置方式

AOP 的配置方式主要有两种：基于 XML 的配置和基于注解的配置。

2.1、基于 XML 的配置方式

基于 XML 的配置方式需要在 Spring 的配置文件中定义切面、切点、通知等元素，并使用 元素将它们组合起来。以下是一个基于 XML 的 AOP 配置的示例：

<!-- 定义切面 -->
<bean id="loggingAspect" class="com.example.LoggingAspect"/>
 <!-- 定义切点 -->
<aop:pointcut id="serviceMethod" expression="execution(* com.example.Service.*(..))"/>
 <!-- 定义通知 -->
<aop:advisor advice-ref="loggingAdvice" pointcut-ref="serviceMethod"/>
 <!-- 定义通知实现类 -->
<bean id="loggingAdvice" class="org.springframework.aop.interceptor.CustomizableTraceInterceptor">
    <property name="enterMessage" value="Entering $[methodName]($[arguments])"/>
    <property name="exitMessage" value="Leaving $[methodName](): $[returnValue]"/>
</bean>
 <!-- 启用 AOP -->
<aop:config/>

上述配置文件定义了一个名为 loggingAspect 的切面，一个名为 serviceMethod 的切点，一个名为 loggingAdvice 的通知实现类，并将通知绑定到切点上。这个示例的作用是在 com.example.Service 包下的所有方法执行前后打印日志。

2.2、基于注解的配置方式

基于注解的配置方式需要在 Java 类中使用注解来标记切面、切点、通知等元素。以下是一个基于注解的 AOP 配置的示例：

@Aspect
@Component
public class LoggingAspect {
   

    @Pointcut("execution(* com.example.Service.*(..))")
    public void serviceMethod() {
   }

    @Before("serviceMethod()")
    public void beforeAdvice() {
   
        System.out.println("Entering method...");
    }

    @AfterReturning("serviceMethod()")
    public void afterAdvice() {
   
        System.out.println("Leaving method...");
    }
}

上述代码定义了一个名为 LoggingAspect 的切面，使用 @Pointcut 注解定义了一个名为 serviceMethod 的切点，并使用 @Before 和 @AfterReturning 注解定义了两个通知方法。这个示例的作用与前面的示例相同，都是在 com.example.Service 包下的所有方法执行前后打印日志。

3、AOP 实现原理

AOP 的实现原理主要是基于动态代理和字节码操作。Spring AOP 使用了 JDK 动态代理和 CGLIB 字节码操作两种方式来实现 AOP。

JDK 动态代理是通过反射机制在运行时动态地创建代理对象，代理对象与目标对象实现了相同的接口，并在代理对象中增加了切面逻辑。以下是一个使用 JDK 动态代理实现 AOP 的示例代码：

public interface UserService {
   
    void addUser(String name);
}

public class UserServiceImpl implements UserService {
   
    public void addUser(String name) {
   
        System.out.println("addUser: " + name);
    }
}

public class UserServiceProxy implements InvocationHandler {
   

    private Object target;

    public UserServiceProxy(Object target) {
   
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("before addUser");
        Object result = method.invoke(target, args);
        System.out.println("after addUser");
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        UserService userService = new UserServiceImpl();
        UserService proxy = (UserService) Proxy.newProxyInstance(
                userService.getClass().getClassLoader(),
                userService.getClass().getInterfaces(),
                new UserServiceProxy(userService));
        proxy.addUser("John");
    }
}

上述代码中， UserService 接口定义了一个 addUser 方法， UserServiceImpl 类是 UserService 接口的实现类。 UserServiceProxy 类是代理类，实现了 InvocationHandler 接口，用于在代理对象的方法执行前后增加切面逻辑。 Main 类中使用 Proxy.newProxyInstance 方法创建代理对象，并调用 addUser 方法。

CGLIB 字节码操作是通过继承目标对象并重写目标方法的方式来实现 AOP，因此目标对象不需要实现接口。以下是一个使用 CGLIB 实现 AOP 的示例代码：

public class UserService {
   
    public void addUser(String name) {
   
        System.out.println("addUser: " + name);
    }
}

public class UserServiceInterceptor implements MethodInterceptor {
   
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   
        System.out.println("before addUser");
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("after addUser");
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UserService.class);
        enhancer.setCallback(new UserServiceInterceptor());
        UserService userService = (UserService) enhancer.create();
        userService.addUser("John");
    }
}

上述代码中， UserService 类是目标对象， UserServiceInterceptor 类是拦截器类，实现了 MethodInterceptor 接口，用于在目标方法执行前后增加切面逻辑。 Main 类中使用 Enhancer 类创建代理对象，并调用 addUser 方法。

无论是使用 JDK 动态代理还是 CGLIB 字节码操作，AOP 的实现原理都是基于代理模式和字节码操作。通过在代理对象中增加切面逻辑，实现了对目标对象的增强。

4、什么是动态代理

动态代理是一种在运行时动态生成代理类的技术，可以在不修改原始代码的情况下，为类或对象添加一些额外的功能。动态代理通常用于实现 AOP（面向切面编程）和远程方法调用等场景。

动态代理的实现原理是通过 Java 反射机制，在运行时动态生成代理类。代理类实现了与目标类相同的接口，并在代理类中增加了额外的逻辑，例如记录日志、性能监控等。当调用代理对象的方法时，实际上是调用了代理类中的方法，代理类再调用目标对象的方法，并在方法执行前后执行额外的逻辑。

Java 中有两种动态代理方式：JDK 动态代理和 CGLIB 动态代理。JDK 动态代理是基于接口的代理，只能代理实现了接口的类。而 CGLIB 动态代理是基于继承的代理，可以代理任何类，但代理的类不能声明为 final 类型。

4.1、JDK 动态代理

JDK 动态代理是 Java 标准库中提供的一种动态代理实现方式，它可以在运行时动态生成代理类，并实现被代理接口的所有方法。JDK 动态代理主要依赖于 Java 的反射机制和 InvocationHandler 接口。

下面是一个简单的 JDK 动态代理的示例代码：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 定义一个接口
interface Hello {
   
    void sayHello();
}

// 实现接口的类
class HelloImpl implements Hello {
   
    public void sayHello() {
   
        System.out.println("Hello, world!");
    }
}

// 实现 InvocationHandler 接口的代理类
class HelloProxy implements InvocationHandler {
   
    private Object target;
     public HelloProxy(Object target) {
   
        this.target = target;
    }
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
   
        System.out.println("Before method " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After method " + method.getName());
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        // 创建被代理对象
        Hello hello = new HelloImpl();
         // 创建代理对象
        Hello proxy = (Hello) Proxy.newProxyInstance(
            hello.getClass().getClassLoader(),
            hello.getClass().getInterfaces(),
            new HelloProxy(hello)
        );
         // 调用代理对象的方法
        proxy.sayHello();
    }
}

在上面的代码中，我们定义了一个接口 Hello 和一个实现该接口的类 HelloImpl 。接着我们定义了一个实现 InvocationHandler 接口的代理类 HelloProxy ，它的作用是在调用被代理对象的方法前后输出日志。最后我们在 main 函数中创建了被代理对象 HelloImpl 和代理对象 HelloProxy ，并通过 Proxy.newProxyInstance 方法生成了代理对象实例。当我们调用代理对象的 sayHello 方法时，实际上是调用了 HelloProxy 中的 invoke 方法，该方法会在调用被代理对象的 sayHello 方法前后输出日志。

JDK 动态代理的原理是通过反射机制在运行时动态生成代理类，并实现被代理接口的所有方法。当调用代理对象的方法时，实际上是调用了代理类中的方法，代理类再调用目标对象的方法，并在方法执行前后执行额外的逻辑。

4.2、CGLIB 动态代理

CGLIB 动态代理是一种基于继承的代理实现方式，它可以在运行时动态生成代理类，并继承被代理类。CGLIB 动态代理主要依赖于 ASM（一个 Java 字节码操作库）。

下面是一个简单的 CGLIB 动态代理的示例代码：

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

// 被代理类
class Hello {
   
    public void sayHello() {
   
        System.out.println("Hello, world!");
    }
}

// 实现 MethodInterceptor 接口的代理类
class HelloProxy implements MethodInterceptor {
   
     public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
   
        System.out.println("Before method " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("After method " + method.getName());
        return result;
    }
}

public class Main {
   
    public static void main(String[] args) {
   
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();
        // 设置被代理类为父类
        enhancer.setSuperclass(Hello.class);
        // 设置回调函数
        enhancer.setCallback(new HelloProxy());
        // 创建代理对象
        Hello proxy = (Hello) enhancer.create();
        // 调用代理对象的方法
        proxy.sayHello();
    }
}

6、AOP 在项目中的应用

AOP（面向切面编程）是一种编程思想，它可以通过将横切关注点（如日志记录、性能统计、事务管理等）与业务逻辑分离，使得代码更加模块化、易于维护和扩展。在项目中，AOP 可以应用于很多场景，下面举例说明几个常见的应用场景。

  1. 日志记录
    在项目中，我们通常需要记录一些关键操作的日志，以便于后续排查问题。使用 AOP 可以很方便地实现日志记录，例如使用 Spring AOP，我们可以定义一个切面，通过在切面中定义一个方法，在方法中记录日志，并将该切面织入到需要记录日志的方法中。
  2. 安全控制
    在项目中，我们通常需要对一些敏感操作进行安全控制，例如需要登录才能访问某些页面或执行某些操作。使用 AOP 可以很方便地实现安全控制，例如使用 Spring Security，我们可以定义一个切面，在切面中判断用户是否已经登录，并根据需要进行权限控制。
  3. 性能统计
    在项目中，我们通常需要对一些关键操作进行性能统计，以便于优化系统性能。使用 AOP 可以很方便地实现性能统计，例如使用 Spring AOP，我们可以定义一个切面，在切面中记录方法的执行时间，并将该切面织入到需要进行性能统计的方法中。
  4. 事务管理
    在项目中，我们通常需要对一些关键操作进行事务管理，以保证数据的一致性和完整性。使用 AOP 可以很方便地实现事务管理，例如使用 Spring AOP，我们可以定义一个切面，在切面中开启事务、提交事务或回滚事务，并将该切面织入到需要进行事务管理的方法中。
    总之，AOP 在项目中的应用非常广泛，可以帮助我们更好地实现代码的分离和模块化，提高代码的可维护性和可扩展性。

    5、实践-手写一个 AOP 的案例

以下是一个基于Spring AOP实现日志记录的示例代码：

  1. 创建一个切面类：
@Aspect
@Component
public class LogAspect {
   
     private static final Logger LOGGER = LoggerFactory.getLogger(LogAspect.class);
     @Around("execution(* com.example.demo.controller.*.*(..))")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
   
        long startTime = System.currentTimeMillis();
        Object result = joinPoint.proceed();
        long endTime = System.currentTimeMillis();
        LOGGER.info("Method {} execution time: {}ms", joinPoint.getSignature().getName(), endTime - startTime);
        return result;
    }
     @Before("execution(* com.example.demo.controller.*.*(..)) && args(request,..)")
    public void logBefore(JoinPoint joinPoint, HttpServletRequest request) {
   
        LOGGER.info("Request URL: {} {}", request.getMethod(), request.getRequestURL());
        LOGGER.info("Request parameters: {}", request.getParameterMap());
    }
}

这里定义了两个切点，一个是 @Around ，用于记录方法的执行时间，另一个是 @Before ，用于记录请求的参数。

  1. 在Spring Boot主类中添加 @EnableAspectJAutoProxy 注解：
@SpringBootApplication
@EnableAspectJAutoProxy
public class DemoApplication {
   
     public static void main(String[] args) {
   
        SpringApplication.run(DemoApplication.class, args);
    }
 }
  1. 测试

编写一个简单的Controller：

@RestController
public class HelloController {
   
     @GetMapping("/hello")
    public String hello(@RequestParam("name") String name) {
   
        return "Hello, " + name;
    }
}

启动应用，访问 http://localhost:8080/hello?name=world，可以在控制台看到类似如下的日志：

2021-09-23 16:53:11.453  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Request URL: GET http://localhost:8080/hello
2021-09-23 16:53:11.454  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Request parameters: {
   name=[world]}
2021-09-23 16:53:11.454  INFO 12345 --- [nio-8080-exec-1] c.e.d.aop.LogAspect                     : Method hello execution time: 4ms

可以看到，请求的参数和方法的执行时间都被记录下来了。

1686494501743.jpg

💕💕 本文由激流创作，原创不易，感谢支持！！！
💕💕喜欢的话记得点赞收藏啊！！！

文章标签：
日志服务
Java
知识图谱
监控
数据安全/隐私保护
Spring
安全
数据格式
缓存
大数据
XML
关键词：
面试spring
Spring AOP
编程aop
Spring编程
Spring面试
相关实践学习
日志服务之使用Nginx模式采集日志
本文介绍如何通过日志服务控制台创建Nginx模式的Logtail配置快速采集Nginx日志并进行多维度分析。
激流丶
目录
相关文章
喜欢猪猪
|
8天前
|
监控 Java 应用服务中间件
高级java面试---spring.factories文件的解析源码API机制
【11月更文挑战第20天】Spring Boot是一个用于快速构建基于Spring框架的应用程序的开源框架。它通过自动配置、起步依赖和内嵌服务器等特性，极大地简化了Spring应用的开发和部署过程。本文将深入探讨Spring Boot的背景历史、业务场景、功能点以及底层原理，并通过Java代码手写模拟Spring Boot的启动过程，特别是spring.factories文件的解析源码API机制。
喜欢猪猪
28 2
互联网课堂
|
13天前
|
XML Java 数据安全/隐私保护
Spring Aop该如何使用
本文介绍了AOP（面向切面编程）的基本概念和术语，并通过具体业务场景演示了如何在Spring框架中使用Spring AOP。文章详细解释了切面、连接点、通知、切点等关键术语，并提供了完整的示例代码，帮助读者轻松理解和应用Spring AOP。
互联网课堂
29 2
Spring Aop该如何使用
张飞的猪
|
20天前
|
安全 Java 编译器
什么是AOP面向切面编程？怎么简单理解？
本文介绍了面向切面编程（AOP）的基本概念和原理，解释了如何通过分离横切关注点（如日志、事务管理等）来增强代码的模块化和可维护性。AOP的核心概念包括切面、连接点、切入点、通知和织入。文章还提供了一个使用Spring AOP的简单示例，展示了如何定义和应用切面。
张飞的猪
57 1
什么是AOP面向切面编程？怎么简单理解？
砖业洋__
|
1月前
|
存储 缓存 Java
Spring高手之路23——AOP触发机制与代理逻辑的执行
本篇文章深入解析了Spring AOP代理的触发机制和执行流程，从源码角度详细讲解了Bean如何被AOP代理，包括代理对象的创建、配置与执行逻辑，帮助读者全面掌握Spring AOP的核心技术。
砖业洋__
38 3
Spring高手之路23——AOP触发机制与代理逻辑的执行
进步`于辰
|
18天前
|
Java Spring
[Spring]aop的配置与使用
本文介绍了AOP（面向切面编程）的基本概念和核心思想。AOP是Spring框架的核心功能之一，通过动态代理在不修改原代码的情况下注入新功能。文章详细解释了连接点、切入点、通知、切面等关键概念，并列举了前置通知、后置通知、最终通知、异常通知和环绕通知五种通知类型。
进步`于辰
29 1
喜欢猪猪
|
24天前
|
XML Java 开发者
论面向方面的编程技术及其应用（AOP）
【11月更文挑战第2天】随着软件系统的规模和复杂度不断增加，传统的面向过程编程和面向对象编程（OOP）在应对横切关注点（如日志记录、事务管理、安全性检查等）时显得力不从心。面向方面的编程（Aspect-Oriented Programming，简称AOP）作为一种新的编程范式，通过将横切关注点与业务逻辑分离，提高了代码的可维护性、可重用性和可读性。本文首先概述了AOP的基本概念和技术原理，然后结合一个实际项目，详细阐述了在项目实践中使用AOP技术开发的具体步骤，最后分析了使用AOP的原因、开发过程中存在的问题及所使用的技术带来的实际应用效果。
喜欢猪猪
51 5
蓝易云
|
14天前
|
安全 Java 测试技术
Java开发必读，谈谈对Spring IOC与AOP的理解
Spring的IOC和AOP机制通过依赖注入和横切关注点的分离，大大提高了代码的模块化和可维护性。IOC使得对象的创建和管理变得灵活可控，降低了对象之间的耦合度；AOP则通过动态代理机制实现了横切关注点的集中管理，减少了重复代码。理解和掌握这两个核心概念，是高效使用Spring框架的关键。希望本文对你深入理解Spring的IOC和AOP有所帮助。
蓝易云
28 0
程序员飞鱼
|
1月前
|
设计模式 缓存 Java
面试题：谈谈Spring用到了哪些设计模式？
面试题：谈谈Spring用到了哪些设计模式？
程序员飞鱼
39 2
Codelinghu
|
1月前
|
Java 容器
AOP面向切面编程
AOP面向切面编程
Codelinghu
42 0
木子0204
|
1月前
|
XML Java 数据格式
Spring的IOC和AOP
Spring的IOC和AOP
木子0204
48 0

热门文章

最新文章

  • 1
    面试必问的4种单点登录的实现方式，你知道几个？
  • 2
    flink面试问题总结（3）
  • 3
    经典软件面试题（2）
  • 4
    C# 面试题解析-请遍历页面上所有的TextBox控件并给它赋值为string.Empty
  • 5
    面试题1：赋值运算符函数
  • 6
    超有用的sql查询语句。项目、面试都有用
  • 7
    大厂高频面试真题详解：最长无重复字符的子串
  • 8
    JVM面试高频问题（上）
  • 9
    Java中Map接口的使用和有关集合的面试知识点补充
  • 10
    面试官：知道Java1.8中新加的StampedLock吗?
  • 1
    Spring Boot框架在java领域的优势
    78
  • 2
    Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法
    285
  • 3
    spring 事务控制 设置手动回滚 TransactionAspectSupport.currentTransactionStatus().setRollbackOnly()；
    124
  • 4
    面试一口气说出Spring的声明式事务@Transactional注解的6种失效场景
    120
  • 5
    nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException（Spring循环依赖问题）
    108
  • 6
    【spring cloud】注解@SpringCloudApplication和@SpringBootApplication的区别
    64
  • 7
    Spring Boot 2.x 嵌入式 Servlet 容器
    63
  • 8
    Spring Cloud微服务框架：构建高可用、分布式系统的现代架构
    189
  • 9
    Java技术栈中的核心组件：Spring框架
    56
  • 10
    基于SpringBoot+Vue+uniapp的公园管理系统的详细设计和实现(源码+lw+部署文档+讲解等)
    74

    • 相关课程

    更多
  • 全面讲解Spring Cloud Alibaba技术栈（知识精讲+项目实战）第二阶段
  • 精通Spring Cloud Alibaba
  • 微服务框架 Spring Cloud 快速入门
  • Java Web开发系列课程 - Spring框架入门
  • Spring Boot 2.5.x开发实战
  • Spring Cloud微服务架构设计与开发实战

    • 相关电子书

    更多
  • 云栖社区特邀专家徐雷Java Spring Boot开发实战系列课程（第20讲）：经典面试题与阿里等名企内部招聘求职面试技巧
  • 微服务架构模式与原理Spring Cloud开发实战
  • 阿里特邀专家徐雷Java Spring Boot开发实战系列课程（第18讲）：制作Java Docker镜像与推送到DockerHub和阿里云Docker仓库

    • 相关实验场景

    更多
  • Rocketmq-spring入门与实践
  • 从零搭建Spring Boot的Hello World
    • 下一篇
    无影云桌面