Spring高手之路25——深入解析事务管理的切面本质

举报
砖业洋__ 发表于 2024/11/23 16:05:35 2024/11/23
【摘要】 本篇文章将带你深入解析Spring事务管理的切面本质，通过AOP手动实现 @Transactional 基本功能，并探讨PlatformTransactionManager的设计和事务拦截器TransactionInterceptor的工作原理，结合时序图详细展示事务管理流程，最后引导分析 @Transactional 的代理机制源码，帮助你全面掌握Spring事务管理。

1. 事务管理的切面本质

  事务管理在Spring中的实现依赖于AOP，而AOP主要通过代理机制来实现。具体而言，AOP通过代理对象拦截对目标方法的调用，并在方法调用前后插入事务管理逻辑。拦截器机制是AOP实现的一部分，用于定义具体的增强逻辑。

  Spring能够通过AOP将事务管理逻辑独立出来，作为一个切面应用于所有标注了 @Transactional 的方法。代理对象会拦截对这些方法的调用，并在方法执行前后插入事务管理逻辑。

  在事务管理中，拦截器机制起到了关键作用。Spring使用 TransactionInterceptor 拦截器来处理事务逻辑。TransactionInterceptor 在方法调用之前开启事务，在方法执行过程中进行事务管理，并在方法调用结束后根据执行结果提交或回滚事务。这种机制确保了事务管理逻辑与业务逻辑的解耦，提高了代码的可维护性和可读性。

2. 用AOP手动实现 @Transactional 基本功能

  为了能更清晰的理解到@Transactional本质就是AOP，我们自行实现一个@MyTransactional 注解，来简单模拟@Transactional的功能。

  我这里为了演示API的使用，在代码演示的时候会设置事务的隔离级别为READ_COMMITTED，设置事务的传播行为为REQUIRES_NEW

全部代码如下：

  1. 数据库表创建

首先，创建 test 表：

CREATE TABLE `test` (
  `id` bigint unsigned NOT NULL AUTO_INCREMENT,
  `name` varchar(255) NOT NULL DEFAULT '',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4
  1. 配置数据源、MyBatis和事务管理器
package com.example.demo.configuration;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

@Configuration
@ComponentScan(basePackages = "com.example.demo")
@MapperScan("com.example.demo.mapper")
@EnableAspectJAutoProxy
public class AppConfig {
    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/demo");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }

    @Bean
    public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath*:mybatis/**/*.xml"));
        return sqlSessionFactoryBean.getObject();
    }

    @Bean
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}
  1. 创建 Mapper 接口和 XML 映射文件

这里TestMapper.java和TestMapper.xml定义了数据库操作方法。

TestMapper.java：

package com.example.demo.mapper;

import com.example.demo.model.Test;


public interface TestMapper {
    // 定义插入Test的方法
    void insertTest(Test test);

    // 定义根据ID查询Test的方法
    Test selectTestById(Long id);
}

TestMapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.demo.mapper.TestMapper">

    <!-- 插入记录到test表 -->
    <insert id="insertTest" parameterType="com.example.demo.model.Test">
        INSERT INTO test (name) VALUES (#{name})
    </insert>

    <!-- 根据ID查询test表中的记录 -->
    <select id="selectTestById" parameterType="long" resultType="com.example.demo.model.Test">
        SELECT * FROM test WHERE id = #{id}
    </select>

</mapper>
  1. 创建模型类

Test.java定义了数据表对应的实体类。

Test.java：

package com.example.demo.model;

// 定义Test类与数据库表test对应
public class Test {
    private Long id; // 主键ID
    private String name; // 名称

    // 获取ID
    public Long getId() {
        return id;
    }

    // 设置ID
    public void setId(Long id) {
        this.id = id;
    }

    // 获取名称
    public String getName() {
        return name;
    }

    // 设置名称
    public void setName(String name) {
        this.name = name;
    }
}
  1. 创建自定义事务注解

MyTransactional.java：

package com.example.demo.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 自定义事务注解
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyTransactional {
}
  1. 创建事务管理切面

TransactionAspect.java：

package com.example.demo.aspect;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

@Aspect // 声明这是一个切面类
@Component // 将这个类标记为 Spring 组件
public class TransactionAspect {

    @Autowired // 注入事务管理器
    private PlatformTransactionManager transactionManager;

    // 环绕通知，拦截所有标注了 @MyTransactional 的方法
    @Around("@annotation(com.example.demo.annotation.MyTransactional)")
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        // 创建默认事务定义
        DefaultTransactionDefinition def = new DefaultTransactionDefinition();
        // 设置事务的传播行为为REQUIRES_NEW
        def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
        // 设置事务的隔离级别为READ_COMMITTED
        def.setIsolationLevel(TransactionDefinition.ISOLATION_READ_COMMITTED);
        // 获取事务状态对象，开启事务
        TransactionStatus status = transactionManager.getTransaction(def);
        Object result;
        try {
            result = pjp.proceed(); // 执行目标方法
            transactionManager.commit(status); // 提交事务
        } catch (Throwable ex) {
            transactionManager.rollback(status); // 回滚事务
            throw ex;
        }
        return result; // 返回结果
    }
}
  1. 创建 Service 层

TestService.java：

package com.example.demo.service;

import com.example.demo.mapper.TestMapper;
import com.example.demo.model.Test;
import com.example.demo.annotation.MyTransactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service // 标记这个类为 Spring 服务组件
public class TestService {

    @Autowired // 注入 TestMapper
    private TestMapper testMapper;

    // 使用自定义的 @MyTransactional 注解
    @MyTransactional
    public void createTest(Test test) {
        testMapper.insertTest(test); // 插入记录

        // 模拟异常以测试事务回滚
        if ("error".equals(test.getName())) {
            throw new RuntimeException("Simulated error");
        }
    }

    // 根据 ID 查询记录
    public Test getTestById(Long id) {
        return testMapper.selectTestById(id);
    }
}
  1. Main 方法

创建一个 Main 方法来启动 Spring 应用程序并执行测试逻辑：

MainApp.java：

package com.example.demo;

import com.example.demo.configuration.AppConfig;
import com.example.demo.model.Test;
import com.example.demo.service.TestService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class DemoApplication {
    public static void main(String[] args) {
        // 加载 Spring 配置文件
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

        // 获取 TestService Bean
        TestService testService = context.getBean(TestService.class);

        try {
            Test test = new Test();
            test.setName("success");
            testService.createTest(test);
            System.out.println("Test with name 'success' created.");
        } catch (Exception e) {
            System.out.println("Failed to create test with name 'success': " + e.getMessage());
        }

        try {
            Test test = new Test();
            test.setName("error");
            testService.createTest(test);
        } catch (Exception e) {
            System.out.println("Failed to create test with name 'error': " + e.getMessage());
        }
    }
}

执行结果如下:

在这里插入图片描述

在这里插入图片描述

  注意：使用 DefaultTransactionDefinition 来设置事务的隔离级别和传播行为时，这些设置是针对当前事务的，而不是针对整个数据库会话的。具体来说，事务的隔离级别和传播行为是在事务管理器（例如 DataSourceTransactionManager）控制的事务范围内有效。

  当设置事务的隔离级别为 READ_COMMITTED 时，实际上是针对当前事务的连接设置的。这意味着在当前事务的生命周期内（从事务开始到提交或回滚），该隔离级别是有效的。一旦事务结束，连接的隔离级别会被重置为默认值。

  在 JDBC 和 Spring 框架中，事务的隔离级别通常用整数来表示。以下是这些隔离级别及其对应的整数值：

  • TransactionDefinition.ISOLATION_DEFAULT (0): 默认隔离级别，这个值依赖于底层数据库的默认设置。
  • TransactionDefinition.ISOLATION_READ_UNCOMMITTED (1): 读未提交。这是最低的隔离级别，允许读取未提交的数据，可能会导致脏读。
  • TransactionDefinition.ISOLATION_READ_COMMITTED (2): 读已提交。只允许读取已提交的数据，可以防止脏读。
  • TransactionDefinition.ISOLATION_REPEATABLE_READ (4): 可重复读。保证在同一个事务中多次读取相同数据的结果是一致的，防止不可重复读。
  • TransactionDefinition.ISOLATION_SERIALIZABLE (8): 串行化。这是最高的隔离级别，确保事务完全串行化执行，防止脏读、不可重复读和幻读，但性能较低。

3. PlatformTransactionManager的设计

  从上面可以看到，提交事务和回滚事务都是由PlatformTransactionManager对象操作的。PlatformTransactionManager是做什么的？

  在日常开发中，虽然我们通常使用@Transactional注解来管理事务，但实际上PlatformTransactionManager在后台起着关键作用。Spring的事务管理是通过代理机制和AOP（面向切面编程）来实现的，PlatformTransactionManager就是在这个过程中被使用的核心组件。

PlatformTransactionManager接口定义了以下主要方法：

1. getTransaction(TransactionDefinition definition)：

  • 这是用于开始一个新的事务或返回当前事务的句柄的方法。它根据传入的TransactionDefinition（事务定义）参数来决定是否需要开启一个新事务，或者参与一个现有的事务。比如，若是REQUIRES_NEW，代表如果没有事务存在，它会创建一个新的事务。
  • TransactionDefinition参数包括事务的传播行为、隔离级别、超时时间和是否只读等属性。

  句柄（handle）在编程中的作用可以理解为一种引用或者标识符，也可以理解为指针。用来间接地访问某个资源或对象。句柄的目的是简化和抽象资源管理，不需要直接操作底层资源，只需要通过句柄来进行操作。
  Spring事务管理中，句柄用来表示事务的状态和上下文。这个句柄并不是实际的事务对象，而是对事务的一种引用或标识，使得Spring框架可以管理事务的生命周期。
现实生活中的类比
图书馆借书卡：

  • 在图书馆中，你有一张借书卡，这张借书卡上有一个唯一的编号。
  • 借书卡相当于一个句柄，它并不直接代表你借的书，而是代表在图书馆的借书权限和记录。
  • 当你想借书或还书时，只需要出示这张借书卡，图书馆的系统会通过借书卡的编号找到你的借书记录，完成借书或还书操作。

在编程中，句柄扮演的角色类似于借书卡的编号，通过句柄可以间接地操作或访问实际的资源。

2. commit(TransactionStatus status)：

  • 提交给定的事务，TransactionStatus包含了事务的具体信息。
  • 如果事务被成功提交，则对数据库的所有更改将被保存。

3. rollback(TransactionStatus status)：

  • 回滚给定的事务，TransactionStatus包含了事务的具体信息。
  • 如果事务被回滚，则对数据库的所有更改将被撤销。

4. 事务拦截器TransactionInterceptor

  在Spring中，事务拦截器是通过AOP（面向切面编程）机制实现的。事务拦截器会拦截标注了@Transactional注解的方法调用，并在方法执行前后管理事务。

  1. 事务管理的启用

  在Spring应用中，事务管理通常通过@EnableTransactionManagement注解启用，这会注册必要的基础设施来处理事务。

@Configuration
@EnableTransactionManagement
public class AppConfig {
    // 配置数据源和事务管理器
}
  1. 事务拦截器的配置

  @EnableTransactionManagement会配置一个事务顾问（advisor）和一个事务拦截器（interceptor）。这些组件在Spring容器启动时被注册。

关键类和接口

  1. TransactionManagementConfigurationSelector：负责选择启用事务管理所需的配置类。
  2. ProxyTransactionManagementConfiguration：具体配置类，负责注册事务管理相关的bean。
  3. TransactionInterceptor：事务拦截器，实际负责事务管理的逻辑。

TransactionInterceptor的工作原理

  TransactionInterceptor是Spring事务管理的核心组件之一，它实现了MethodInterceptor接口，通过AOP拦截标注了@Transactional的方法，并在方法执行前后进行事务管理。

TransactionInterceptor的源码位置

  TransactionInterceptor类位于org.springframework.transaction.interceptor包中。以下是其关键部分的简化代码和解释。

package org.springframework.transaction.interceptor;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallback;
import org.springframework.transaction.support.TransactionTemplate;

public class TransactionInterceptor extends TransactionAspectSupport implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        // 获取目标方法
        Method method = invocation.getMethod();
        // 获取事务属性
        TransactionAttributeSource tas = getTransactionAttributeSource();
        TransactionAttribute txAttr = tas.getTransactionAttribute(method, invocation.getThis().getClass());

        // 获取事务管理器
        PlatformTransactionManager tm = determineTransactionManager(txAttr);

        // 如果没有事务属性或事务管理器，则直接执行方法
        if (txAttr == null || tm == null) {
            return invocation.proceed();
        }

        // 创建事务模板
        TransactionTemplate tt = createTransactionTemplate(tm, txAttr);
        // 开启事务，执行目标方法，并管理事务提交或回滚
        return tt.execute(new TransactionCallback<Object>() {
            @Override
            public Object doInTransaction(TransactionStatus status) {
                try {
                    return invocation.proceed();
                } catch (Throwable ex) {
                    // 回滚事务
                    status.setRollbackOnly();
                    throw new RuntimeException(ex);
                }
            }
        });
    }
}

时序图如下：

在这里插入图片描述
过程描述

  1. 客户端调用目标方法：
  • 客户端发起对目标方法的调用。
  • 这一调用被 TransactionInterceptor 拦截。
  1. 获取事务属性：
  • TransactionInterceptor 通过 TransactionAttributeSource 获取目标方法的事务属性。
  • 事务属性包括事务的传播行为、隔离级别、超时设置等。
  • TransactionAttributeSource 返回获取到的事务属性。
  1. 确定事务管理器：
  • TransactionInterceptor 确定要使用的 PlatformTransactionManager。
  1. 获取事务管理器：
  • 根据事务属性获取适当的事务管理器。
  • 事务管理器负责管理事务的生命周期（开始、提交、回滚）。
  1. 检查事务属性和事务管理器：
  • TransactionInterceptor 检查是否获取到事务属性和事务管理器。
  • 如果没有获取到事务属性或事务管理器，则直接执行目标方法，不进行事务管理。
  • TransactionInterceptor 调用目标方法并返回执行结果。
  1. 创建事务模板：
  • 如果获取到事务属性和事务管理器，TransactionInterceptor 创建一个 TransactionTemplate。
  • TransactionTemplate 用于简化事务操作。
  1. 使用事务模板执行目标方法：
  • TransactionInterceptor 使用 TransactionTemplate 开启事务并执行目标方法。
  1. 方法执行成功：
  • 如果目标方法执行成功，事务模板提交事务。
  • 事务模板返回执行结果。
  • TransactionInterceptor 将结果返回给客户端。
  1. 方法执行抛出异常：
  • 如果目标方法抛出异常，事务模板回滚事务。
  • 事务模板抛出异常。
  • TransactionInterceptor 将异常抛出给客户端。

  当Spring启动时，@EnableTransactionManagement启用事务管理，Spring会自动配置事务拦截器TransactionInterceptor。当调用标注了@Transactional的方法时，TransactionInterceptor会拦截该方法，并通过PlatformTransactionManager管理事务的开启、提交和回滚。

总结

  • @EnableTransactionManagement启用事务管理，并注册必要的事务管理组件。
  • TransactionInterceptor通过AOP拦截事务方法，并管理事务的开启、提交和回滚。
  • PlatformTransactionManager在后台执行实际的事务操作。

有兴趣的小伙伴可以自行去学习了解TransactionInterceptor 如何处理事务，以及在事务属性解析、事务管理器选择等方面的具体实现。

5. 时序图展示事务管理流程

这里展示处理事务时的作用流程，包含多种事务传播行为的判断。

在这里插入图片描述

详细步骤解释

1. 调用带有@Transactional的方法：

  • 客户端调用标注了@Transactional的方法。
  • AOP拦截器拦截该方法调用。

2. 获取事务：

  • AOP拦截器，也就是事务拦截器，调用PlatformTransactionManager的getTransaction(TransactionDefinition)方法获取事务。
  • 事务管理器检查当前事务上下文，确定是否需要创建新事务或加入现有事务。

3. 处理传播行为：

  • 根据TransactionDefinition中的传播行为（Propagation Behavior）决定事务的处理方式。
  • REQUIRED：如果没有现有事务，创建新事务；如果已有事务，加入现有事务。
  • REQUIRES_NEW：总是创建新事务，如果已有事务，则挂起当前事务。
  • SUPPORTS：如果有现有事务，则加入现有事务；如果没有事务，则以非事务方式执行。
  • NOT_SUPPORTED：如果有现有事务，则挂起当前事务，以非事务方式执行。
  • MANDATORY：如果没有现有事务，则抛出异常。
  • NEVER：如果有现有事务，则抛出异常。
  • NESTED：如果有现有事务，则创建嵌套事务；如果没有事务，则创建新事务。

4. 执行目标方法：

  • AOP拦截器通知客户端继续执行业务逻辑。
  • 客户端执行数据库操作（例如保存实体）。

5. 提交或回滚事务：

如果业务逻辑执行过程中抛出异常：

  • AOP拦截器调用事务管理器的rollback(TransactionStatus)方法。
  • 事务管理器执行回滚操作，并返回回滚状态。
  • AOP拦截器将异常抛回给客户端。

如果业务逻辑正常执行完毕：

  • AOP拦截器调用事务管理器的commit(TransactionStatus)方法。
  • 事务管理器执行提交操作，并返回提交状态。
  • AOP拦截器将结果返回给客户端。

6. 事务与线程的关系——@Transactional方法内的异步线程

  在写业务的时候可以会遇到，一个方法内部有数据库操作和异步线程的操作，如果是数据库操作的异常，这肯定会回滚，如果数据库操作正常，异步线程执行的时候出现异常，数据库操作会回滚吗？

用一个例子简洁的说明

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Transactional
    public void placeOrder(Order order) {
        // 保存订单
        orderRepository.save(order);

        // 启动异步任务
        CompletableFuture.runAsync(() -> {
            try {
                // 模拟异步任务抛出异常
                if (true) {
                    throw new RuntimeException("异步任务出错");
                }
            } catch (Exception e) {
                // 异常处理逻辑
                // 记录日志，发送告警等
                System.err.println("异步任务异常: " + e.getMessage());
            }
        });

        // 其他业务逻辑
    }
}

答案如下：

  在@Transactional方法中直接启动的异步线程如果抛出异常，不会导致整个事务回滚。事务的边界仅限于当前线程，异步线程中的异常不会影响主事务。

事务和线程的关系如下

  1. 事务绑定到线程上下文：
  • Spring的事务管理是基于TransactionSynchronizationManager来管理事务状态的。
  • 每个事务在当前线程中开始，事务状态（如是否提交或回滚）存储在当前线程的ThreadLocal变量中。这意味着事务的边界是线程级的。
  1. @Transactional的工作原理：
  • 当一个方法被@Transactional注解修饰时，Spring会通过AOP创建一个代理，该代理会在方法调用之前开启事务，在方法完成之后根据方法执行情况提交或回滚事务。
  • 事务的开始和结束都发生在当前线程中，即事务的边界局限于执行该方法的线程。

异步线程与事务的独立性

  1. 异步任务在不同的线程中执行：
  • 异步任务通常使用@Async注解、CompletableFuture.runAsync、new Thread或自定义线程池来启动。无论哪种方式，异步任务会在一个新的线程中运行。
  • 新线程没有继承原始线程的ThreadLocal变量，包括事务上下文，因此异步线程不参与主事务。
  1. 事务状态的隔离：
  • 主线程中执行的事务与异步线程中的操作是独立的。即使异步线程中抛出异常，也不会影响主线程的事务状态。
  • 异步线程中的异常只会在异步线程中传播，不会传播回主线程。

总结

  • Spring的事务管理是线程绑定的，每个事务与启动它的线程绑定。
  • 异步任务在不同的线程中执行，不继承主线程的事务上下文。
  • 异步线程中的异常不会影响主线程的事务状态。

7. @Transactional 代理机制源码引导分析

  一旦分析源码，文章的可阅读性就降低了，这里留有有兴趣的小伙伴自行阅读。

  在 Spring 框架中，@Transactional 的代理机制主要涉及几个关键类和接口，包括 TransactionInterceptor、ProxyTransactionManagementConfiguration、TransactionAttributeSourceAdvisor 和 ProxyFactoryBean 等。下面是一些关键的源码位置：

  TransactionInterceptor：这个类位于 org.springframework.transaction.interceptor 包中，它是事务管理的核心拦截器。

  TransactionAttributeSourceAdvisor：这个类位于 org.springframework.transaction.annotation 包中，它是 AOP Advisor，负责根据事务注解创建切点。

  ProxyTransactionManagementConfiguration：这个类位于 org.springframework.transaction.annotation 包中，它是事务管理配置的核心，负责注册事务管理相关的 bean。

  可以从 @EnableTransactionManagement 注解开始追踪源码，该注解引导到 ProxyTransactionManagementConfiguration 类，该类配置了事务管理的 AOP 切面。


欢迎一键三连~

有问题请留言，大家一起探讨学习

----------------------Talk is cheap, show me the code-----------------------
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
AOP Spring
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入