Spring笔记(5) - 声明式事务@EnableTransactionManagement注解源码分析

最新推荐文章于 2024-04-01 17:17:05 发布
最新推荐文章于 2024-04-01 17:17:05 发布
阅读量1.2w 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/time_poster/article/details/109300066
版权
本文详细介绍了Spring框架中使用注解实现事务管理的方法，包括配置类的定义、业务代码的编写及异常处理机制。通过具体示例展示了如何利用@EnableTransactionManagement开启基于注解的事务管理，并解析了其内部原理。
摘要由CSDN通过智能技术生成

一.背景

　　前面详解了实现Spring事务的两种方式的不同实现：编程式事务和声明式事务，对于配置都使用到了xml配置，今天介绍Spring事务的注解开发，例如下面例子：

  1. 配置类：注册数据源、JDBC模板、事务管理器 
    //包扫描，将包下的dao、service注册到Spring容器中
@ComponentScan("com.hrh")
//开启基于注解的事务管理，跟@Transactional注解配套使用
@EnableTransactionManagement
//表明TxConfig是配置类
@Configuration
public class TxConfig {
    //注册数据源
    @Bean
    public DataSource dataSource() throws Exception {
        ComboPooledDataSource comboPooledDataSource = new ComboPooledDataSource();
        comboPooledDataSource.setUser("xxx");
        comboPooledDataSource.setPassword("xxx");
        comboPooledDataSource.setJdbcUrl("jdbc:mysql://xxx:3306/xxx");
        comboPooledDataSource.setDriverClass("com.mysql.jdbc.Driver");
        return comboPooledDataSource;
    }

    //注册jdbc模板
    @Bean
    public JdbcTemplate jdbcTemplate() throws Exception {
        return new JdbcTemplate(dataSource());
    }

    //注册事务管理器来控制事务
    @Bean
    public PlatformTransactionManager manager() throws Exception {
        return new DataSourceTransactionManager(dataSource());
    }
}
  2. 业务代码： 
    @Repository
public class UserDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    public void insert(){
        String sql ="insert into tab_person(name,age) values(?,?)";
        String name = UUID.randomUUID().toString().substring(0, 5);
        jdbcTemplate.update(sql,name,19);
    }
}

@Service
public class UserService{
    @Autowired
    private UserDao userDao;
    
    //添加事务
    @Transactional
    public void insert() {
        userDao.insert();
        System.out.println("插入完成。");
        int i = 10/0;
    }
}
  3. 测试：从下面运行结果可以看出抛出了异常，在数据库中查看数据发现没有最新的数据插入，表明插入操作进行了回滚 
        public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(TxConfig.class);
        UserService bean = context.getBean(UserService.class);
        bean.insert();
        context.close();
    }
    
运行结果：
    
    插入完成。
    Exception in thread "main" java.lang.ArithmeticException: / by zero
        at com.hrh.service.UserService.insert(UserService.java:20) 

 二. @EnableTransactionManagement注解源码分析

　　1.流程

  1. EnableTransactionManagement导入一个TransactionManagementConfigurationSelector组件

  2. TransactionManagementConfigurationSelector默认导入两个组件：AutoProxyRegistrar和ProxyTransactionManagementConfiguration

  3. AutoProxyRegistrar（利用后置处理器包装代理对象）：注册一个InfrastructureAdvisorAutoProxyCreator组件（自动代理创建器），利用后置处理器机制在对象创建之后包装对象，返回一个代理对象（增强器），利用拦截器链执行方法

  4. ProxyTransactionManagementConfiguration（注册配置）：给容器注册各种组件，注册了事务增强器

　　　　　　　　4.1）事务增强器要用事务注解的信息，AnnotationTransactionAttributeSource解析了注解上的各种属性信息

　　　　　　　　4.2）同时用到TransactionInterceptor事务拦截器：保存了事务属性信息、事务管理器

　　　　　　　　　　4.2.1）在目标方法执行时：执行拦截器链（即TransactionInterceptor）

　　　　　　　　　   4.2.2）TransactionInterceptor事务拦截器的作用：获取事务相关的属性，再获取事务管理器进行事务的执行、回滚或提交操作；

　　2.源码解析

  1.  EnableTransactionManagement导入一个TransactionManagementConfigurationSelector组件 
    @Import({TransactionManagementConfigurationSelector.class})
public @interface EnableTransactionManagement {
    //默认为false
    boolean proxyTargetClass() default false;
    //默认为PROXY
    AdviceMode mode() default AdviceMode.PROXY;

    int order() default 2147483647;
}

     

  2. TransactionManagementConfigurationSelector默认导入两个组件：AutoProxyRegistrar和ProxyTransactionManagementConfiguration 
    public class TransactionManagementConfigurationSelector extends AdviceModeImportSelector<EnableTransactionManagement> {
    //AdviceMode值在EnableTransactionManagement默认了
    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
        switch (adviceMode) {
            case PROXY:
                return new String[] {AutoProxyRegistrar.class.getName(),
                        ProxyTransactionManagementConfiguration.class.getName()};
            case ASPECTJ:
                return new String[] {
                        TransactionManagementConfigUtils.TRANSACTION_ASPECT_CONFIGURATION_CLASS_NAME};
            default:
                return null;
        }
    }

}
  3. AutoProxyRegistrar（利用后置处理器包装代理对象）：注册一个InfrastructureAdvisorAutoProxyCreator组件（自动代理创建器），利用后置处理器机制在对象创建之后包装对象，返回一个代理对象（增强器），利用拦截器链执行方法 
    public class AutoProxyRegistrar implements ImportBeanDefinitionRegistrar {

    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
        boolean candidateFound = false;
        Set<String> annTypes = importingClassMetadata.getAnnotationTypes();
        for (String annType : annTypes) {
            AnnotationAttributes candidate = AnnotationConfigUtils.attributesFor(importingClassMetadata, annType);
            if (candidate == null) {
                continue;
            }
            Object mode = candidate.get("mode");
            Object proxyTargetClass = candidate.get("proxyTargetClass");
            if (mode != null && proxyTargetClass != null && AdviceMode.class == mode.getClass() &&
                    Boolean.class == proxyTargetClass.getClass()) {
                candidateFound = true;
                //注册一个InfrastructureAdvisorAutoProxyCreator组件（自动代理创建器）
                if (mode == AdviceMode.PROXY) {
                    AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry);
                    //proxyTargetClass在EnableTransactionManagement默认false
                    if ((Boolean) proxyTargetClass) {
                        AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
                        return;
                    }
                }
            }
        }
        .....
    }

}
    • AopConfigUtils.registerAutoProxyCreatorIfNecessary(registry)：自动代理创建器 
      public static BeanDefinition registerAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry) {
        return registerAutoProxyCreatorIfNecessary(registry, null);
    }

    @Nullable
    public static BeanDefinition registerAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry, @Nullable Object source) {
        //给容器注册InfrastructureAdvisorAutoProxyCreator（是一个后置处理器），利用后置处理器机制在对象创建之后包装对象，返回一个代理对象（增强器），利用拦截器链执行方法
        return registerOrEscalateApcAsRequired(InfrastructureAdvisorAutoProxyCreator.class, registry, source);
    }
  4. ProxyTransactionManagementConfiguration（注册配置）：给容器注册各种组件，注册了事务增强器 
    @Configuration
public class ProxyTransactionManagementConfiguration extends AbstractTransactionManagementConfiguration {
    //注册事务增强器BeanFactoryTransactionAttributeSourceAdvisor
    @Bean(name = TransactionManagementConfigUtils.TRANSACTION_ADVISOR_BEAN_NAME)
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryTransactionAttributeSourceAdvisor transactionAdvisor() {
        BeanFactoryTransactionAttributeSourceAdvisor advisor = new BeanFactoryTransactionAttributeSourceAdvisor();
        //设置事务属性,从注解解析器获取注解上的事务属性值
        advisor.setTransactionAttributeSource(transactionAttributeSource());
        //设置了TransactionInterceptor事务拦截器
        advisor.setAdvice(transactionInterceptor());
        advisor.setOrder(this.enableTx.<Integer>getNumber("order"));
        return advisor;
    }
    //注册事务属性，解析注解中的各种属性，比如propagation、isolation、timeout等
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionAttributeSource transactionAttributeSource() {
        //注解解析器
        return new AnnotationTransactionAttributeSource();
    }
    //注册了TransactionInterceptor事务拦截器：保存了事务属性信息、事务管理器
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public TransactionInterceptor transactionInterceptor() {
        TransactionInterceptor interceptor = new TransactionInterceptor();
        //保存了事务属性信息
        interceptor.setTransactionAttributeSource(transactionAttributeSource());
        if (this.txManager != null) {
            //保存了事务管理器
            interceptor.setTransactionManager(this.txManager);
        }
        return interceptor;
    }

}
    1. 注解解析器AnnotationTransactionAttributeSource 
      public AnnotationTransactionAttributeSource(boolean publicMethodsOnly) {
    this.publicMethodsOnly = publicMethodsOnly;
    this.annotationParsers = new LinkedHashSet<TransactionAnnotationParser>(4);
    //添加spring事务注解的解析器
    this.annotationParsers.add(new SpringTransactionAnnotationParser());
    if (jta12Present) {
        //添加jta事务注解的解析器
        this.annotationParsers.add(new JtaTransactionAnnotationParser());
    }
    if (ejb3Present) {
        //添加Ejb3事务注解的解析器
        this.annotationParsers.add(new Ejb3TransactionAnnotationParser());
    }
}
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
    AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(
            element, Transactional.class);
    if (attributes != null) {
        //解析注解
        return parseTransactionAnnotation(attributes);
    }
    else {
        return null;
    }
}
//解析注解Transactional上的每个属性
protected TransactionAttribute parseTransactionAnnotation(AnnotationAttributes attributes) {
    RuleBasedTransactionAttribute rbta = new RuleBasedTransactionAttribute();

    Propagation propagation = attributes.getEnum("propagation");
    rbta.setPropagationBehavior(propagation.value());
    Isolation isolation = attributes.getEnum("isolation");
    rbta.setIsolationLevel(isolation.value());
    rbta.setTimeout(attributes.getNumber("timeout").intValue());
    rbta.setReadOnly(attributes.getBoolean("readOnly"));
    rbta.setQualifier(attributes.getString("value"));

    List<RollbackRuleAttribute> rollbackRules = new ArrayList<RollbackRuleAttribute>();
    for (Class<?> rbRule : attributes.getClassArray("rollbackFor")) {
        rollbackRules.add(new RollbackRuleAttribute(rbRule));
    }
    for (String rbRule : attributes.getStringArray("rollbackForClassName")) {
        rollbackRules.add(new RollbackRuleAttribute(rbRule));
    }
    for (Class<?> rbRule : attributes.getClassArray("noRollbackFor")) {
        rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
    }
    for (String rbRule : attributes.getStringArray("noRollbackForClassName")) {
        rollbackRules.add(new NoRollbackRuleAttribute(rbRule));
    }
    rbta.setRollbackRules(rollbackRules);

    return rbta;
}
    2. 事务拦截器TransactionInterceptor：是一个MethodInterceptor，方法拦截器（4个通知方法整合成了增强器，增强器整合成了MethodInterceptor。我们在容器中放置了一个代理对象，当要执行代理对象时，方法拦截器就执行了） 
      public Object invoke(final MethodInvocation invocation) throws Throwable {
    // Work out the target class: may be {@code null}.
    // The TransactionAttributeSource should be passed the target class
    // as well as the method, which may be from an interface.
    Class<?> targetClass = (invocation.getThis() != null ? AopUtils.getTargetClass(invocation.getThis()) : null);

    // Adapt to TransactionAspectSupport's invokeWithinTransaction...
    return invokeWithinTransaction(invocation.getMethod(), targetClass, new InvocationCallback() {
        @Override
        public Object proceedWithInvocation() throws Throwable {
            return invocation.proceed();
        }
    });
}
protected Object invokeWithinTransaction(Method method, Class<?> targetClass, final InvocationCallback invocation)
        throws Throwable {

    // If the transaction attribute is null, the method is non-transactional.
    //获取事务属性
    final TransactionAttribute txAttr = getTransactionAttributeSource().getTransactionAttribute(method, targetClass);
    //获取事务管理器
    final PlatformTransactionManager tm = determineTransactionManager(txAttr);
    //获取执行的事务方法
    final String joinpointIdentification = methodIdentification(method, targetClass, txAttr);

    if (txAttr == null || !(tm instanceof CallbackPreferringPlatformTransactionManager)) {
        // Standard transaction demarcation with getTransaction and commit/rollback calls.
        //开启事务
        TransactionInfo txInfo = createTransactionIfNecessary(tm, txAttr, joinpointIdentification);
        Object retVal = null;
        try {
            // This is an around advice: Invoke the next interceptor in the chain.
            // This will normally result in a target object being invoked.
            //事务方法执行
            retVal = invocation.proceedWithInvocation();
        }
        catch (Throwable ex) {
            // target invocation exception
            //事务异常会获取事务管理器，利用事务管理器执行回滚操作
            completeTransactionAfterThrowing(txInfo, ex);
            throw ex;
        }
        finally {
            cleanupTransactionInfo(txInfo);
        }
        //如果正常，利用事务管理器提交事务
        commitTransactionAfterReturning(txInfo);
        return retVal;
    }

    else {
        final ThrowableHolder throwableHolder = new ThrowableHolder();

        // It's a CallbackPreferringPlatformTransactionManager: pass a TransactionCallback in.
        try {
            Object result = ((CallbackPreferringPlatformTransactionManager) tm).execute(txAttr,
                    new TransactionCallback<Object>() {
                        @Override
                        public Object doInTransaction(TransactionStatus status) {
                            TransactionInfo txInfo = prepareTransactionInfo(tm, txAttr, joinpointIdentification, status);
                            try {
                                return invocation.proceedWithInvocation();
                            }
                            catch (Throwable ex) {
                                if (txAttr.rollbackOn(ex)) {
                                    // A RuntimeException: will lead to a rollback.
                                    if (ex instanceof RuntimeException) {
                                        throw (RuntimeException) ex;
                                    }
                                    else {
                                        throw new ThrowableHolderException(ex);
                                    }
                                }
                                else {
                                    // A normal return value: will lead to a commit.
                                    throwableHolder.throwable = ex;
                                    return null;
                                }
                            }
                            finally {
                                cleanupTransactionInfo(txInfo);
                            }
                        }
                    });

            // Check result state: It might indicate a Throwable to rethrow.
            if (throwableHolder.throwable != null) {
                throw throwableHolder.throwable;
            }
            return result;
        }
        catch (ThrowableHolderException ex) {
            throw ex.getCause();
        }
        catch (TransactionSystemException ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
                ex2.initApplicationException(throwableHolder.throwable);
            }
            throw ex2;
        }
        catch (Throwable ex2) {
            if (throwableHolder.throwable != null) {
                logger.error("Application exception overridden by commit exception", throwableHolder.throwable);
            }
            throw ex2;
        }
    }
} 
码猿手
关注
spring 事务 @EnableTransactionManagement原理
sjtu_chenchen的专栏
06-10 1万+
@EnableXXX原理：注解上有个XXXRegistrar，或通过XXXSelector引入XXXRegistrar，XXXRegistrar实现了 ImportBeanDefinitionRegistrar的registerBeanDefinitions方法，给容器注册XXXCreator。这个Creator实现了后置处理器， 后置处理器在对象创建以后，包装对象，返回一个代理对象，代理对象...
Spring系列第44篇：详解spring声明式事务(@Transactional)
最新发布
m0_55030688的博客
04-02 1084
Java架构学习技术内容包含有：Spring，Dubbo，MyBatis, RPC, 源码分析，高并发、高性能、分布式,性能优化，微服务 高级架构开发等等。还有Java核心知识点+全套架构师学习资料和视频+一线大厂面试宝典+面试简历模板可以领取+阿里美团网易腾讯小米爱奇艺快手哔哩哔哩面试题+Spring源码合集+Java架构实战电子书+2021年最新大厂面试题。6110)][外链图片转存中…(img-2HocfpfA-1711997466110)]
Spring事务（2）-EnableTransactionManagement实现源码解析
ALONG的博客
04-16 1104
Pointcut：“切点”，它是用来匹配连接点 Join point 的，可以说"Pointcut"表示的是"Join point"的集合。Advice：“通知”，表示 Aspect 在特定的 Join point 采取的操作。包括 “around”, “before” and “after 等Advisor：“通知者”，它持有 Advice，是 Spring AOP 的一个基础接口。Advisor 可以获取到 Advice。为Advisor子接口可以获取到Pointcut和Advice。事务使用。
Spring事务源码解析（一）@EnableTransactionManagement注解
javaxuexilu的博客
08-30 484
测试Demo本篇文章的Demo基于上一篇文章SpringJDBC源码解析@EnableTransactionManagementDataSourceTransaction...
@EnableTransactionManagement注解理解
dichengyan0013的博客
12-14 1394
@EnableTransactionManagement表示开启事务支持，在springboot项目中一般配置在启动类上，效果等同于xml配置的<tx:annotation-driven />。开启事务支持后，然后在访问数据库的Service方法上添加注解 @Transactional 便可。 转载于:https://www.cnblogs.com/shamo89/p/...
Spring-tx-@EnableTransactionManagement注解
文天大人
01-14 466
xml形式的spring配置使用tx标签来开启事务 而注解形式的spring配置，则使用@EnableTransactionManagement注解 其实本文要说的内容，在该注解的注释当中都有，例如下面这个代码 @Component public class Creater1 { @Autowired JdbcTemplate jdbcTemplate; @Transactional(rollbackFor = Exception.class) public void create() {
Spring学习笔记之九--声明式事务
05-24
本篇文章将深入探讨Spring框架的一个关键特性——声明式事务管理。通过声明式事务，开发者可以避免手动处理事务的繁琐工作，提高代码的可读性和可维护性。 首先，我们了解什么是事务。在数据库操作中，事务是一系列...
spring学习笔记(十六)-声明式事务的例子
05-24
在本篇“spring学习笔记(十六)-声明式事务的例子”中，我们将深入探讨这一主题。 首先，声明式事务管理基于AOP（面向切面编程）实现，Spring通过代理模式在方法调用前后自动插入事务管理的代码。它主要通过两种方式...
Spring学习笔记(17)----使用Spring注解方式管理事务
03-17
编程式事务管理需要开发者手动控制事务的开始、提交、回滚等操作，而声明式事务管理则通过配置或注解来定义事务边界，让Spring自动处理事务生命周期。 1. **注解驱动的事务管理** Spring提供了一些关键的注解，如`...
Spring源码剖析-事务源码之@Transactionl解析，java基础面试集合
2401_83621136的博客
04-01 800
在上一章我们分析了Spring的AOP的源码，本篇文章是对事务的源码分析，我们都知道事务的管理是基于AOP实现的，所以有了上一篇的铺垫这一章会比较简单一点。事务的源码我会分两章写，一张写Transcational的解析，一张写事务的执行流程。先上一个图，待会儿可以根据这个图来看源码事务配置案例配置事务管理器，开启注解事务支持开启事务支持事务管理器配置数据源…省略…标记方法需要事务//事务注解事务注解打在方法上，当然也是可以打在类上。事务注解原理。
@EnableTransactionManagement源码
liuqiang211的专栏
03-12 1888
@EnableTransactionManagement 默认 AdviceMode mode() default AdviceMode.PROXY; 所有会给容器导入两个组件：AutoProxyRegistrar，ProxyTransactionManagementConfiguration 分析：AutoProxyRegistrar 进入这个方法AopConfigU...
Spring 事务源码(3)—@EnableTransactionManagement事务注解源码解析
终生学习践行者
04-21 2256
基于最新Spring 5.x，详细介绍了Spring 事务源码，包括@EnableTransactionManagement事务注解源码解析
Spring源码-@EnableTransactionManagement方式事务实现分析（上）
it_lihongmin的博客
11-09 6498
先总览实现逻辑： @EnableTransactionManagement使用 @Import方式，注入TransactionManagementConfigurationSelector的Bean，相当于间接注入了以下两个bean 1、AutoProxyRegistrar 实现了ImportBeanDefinitionRegistrar接口，在registerBean...
Spring5 源码阅读笔记（4）事务：@EnableTransactionManagement 做了什么？
日有寸进
03-04 273
基于注解开始事务 import org.mybatis.spring.SqlSessionFactoryBean; import org.mybatis.spring.annotation.MapperScan; import org.springframework.context.annotation.Bean; import org.springframework.jdbc.datasourc...
Spring 5.x 源码之旅五十七事务注解EnableTransactionManagement
王伟王胖胖的博客
04-05 773
Spring 5.x 源码之旅五十七事务注解EnableTransactionManagement@EnableTransactionManagement做了什么TransactionManagementConfigurationSelectorAdviceModeImportSelector的selectImportsTransactionManagementConfigurationSelec...
Spring 事务原理篇：@EnableTransactionManagement注解底层原理分析技巧，就算你看不懂源码，也要学会这个技巧！
avengerEug的博客
07-08 1728
前言 学习了关于Spring AOP原理以及事务的基础知识后，今天咱们来聊聊Spring在底层是如何操作事务的。如果阅读到此文章，并且对Spring AOP原理不太了解的话，建议先阅读下本人的这篇文章：Spring AOP原理篇：我用上我的洪荒之力来帮你彻底了解aop注解@EnableAspectJAutoProxy的原理的文章，后文的内容与这篇文章有很大的关联关系。 一、先说说@EnableTransactionManagement注解内部有哪些方法 我们看下@EnableTransactionM
Spring源码之@Transactional源码解析一
geng2568的博客
01-23 644
一、开启事务需要哪些步骤 一、开启事务入口类 @EnableTransactionManagement 这注解中的都做了那些事？ 首先通过Import的方式将这个事务切面入口类TransactionManagementConfigurationSelector 变成beandefinition对象，接下来进入源码初探： public class TransactionManagementConfigurationSelector extends AdviceModeImportSelect.
Spring中 @Transactional事务管理注解用法
m0_37965811的博客
02-20 1157
目录 简要概述 简单的使用方法 @Transactional 注解的属性介绍 value 和 transactionManager 属性 propagation 属性 isolation 属性 timeout 属性 readOnly 属性 rollbackFor 属性 noRollbackFor 属性 简要概述 事务管理是应用系统开发中必不可少的一部分。Spring 为事务管理提供了丰富的功能支持。 Spring 事务管理分为编程式和声明式的两种方式。 编程式事务指的是通
你认真研究过Spring中的@EnableTransactionManagement注解吗？
小小默：进无止境
09-10 5480
# 【1】基本功能 简单来讲， `@EnableTransactionManagement`注解就是在SpringBoot环境(或者JavaConfig)下开启事务管理。与`` xml配置类似用来注入Spring支持注解驱动的事务管理行为时必须的组件，比如TransactionInterceptor。 比如JavaConfig下应用如下： ```java @Configuration @EnableTransactionManagement public cl............
Spring笔记：声明式事务管理与ProxyTransactionManagementConfiguration详解
本文档主要介绍了Spring框架中的ProxyTransactionManagementConfiguration在声明式事务管理中的作用。首先，它在Spring容器中注册了事务增强器，这些增强器基于事务注解（如@Transactional）的信息进行配置，由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值