【分布式事务系列二】Spring事务管理器PlatformTransactionManager

最新推荐文章于 2024-03-25 22:28:27 发布
最新推荐文章于 2024-03-25 22:28:27 发布
阅读量324 收藏 2
点赞数
文章标签： 数据库 java python
原文链接：https://my.oschina.net/xianggao/blog/541466
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

#0 系列目录#

#1 jdbc事务# ##1.1 例子##

public void save(User user) throws SQLException{
    Connection conn=jdbcDao.getConnection();
    conn.setAutoCommit(false);
    try {
        PreparedStatement ps=conn.prepareStatement("insert into user(name,age) value(?,?)");
        ps.setString(1,user.getName());
        ps.setInt(2,user.getAge());
        ps.execute();
        conn.commit();
    } catch (Exception e) {
        e.printStackTrace();
        conn.rollback();
    }finally{
        conn.close();
    }
}

##1.2 分析##

  1. 怎么使用事务

将自动提交设置为false,即conn.setAutoCommit(false)，然后手动来conn.commit()、或者conn.rollback()。

  1. 一个重要意识

conn.commit();conn.rollback()等这些属于事务代码，其他执行sql的代码属于业务代码。

只有事务代码和业务代码使用的是同一个Connection的时候，事务的回滚和提交才能正常执行,所以如果我们要实现事务代码和业务代码的分离，必须要保证他们使用的是同一个Connection。

  1. 谁在执行事务

我们可以看到，可以通过操作Connection连接来执行事务，这并不代表Connection具有事务功能，而是使用了数据库自身的事务功能，Connection仅仅是把一些命令如commit、rollback传递给数据库。

##1.3 存在的问题##

  1. 业务代码都要嵌套在try catch事务模板代码中。

  2. 当存在多个类似save(User user)的业务逻辑时，没法保证他们的原子性：

login(user); save(user);

这两个业务逻辑都是相似的代码,获取Connection连接，然后执行sql语句。没法保证它们的原子性，是因为它们使用的不是同一个连接，不在同一个事务内。

#2 Hibernate的事务# ##2.1 例子##

public void save(User user){
    Session session=hibernateDao.openSession();
    Transaction tx=null;
    try {
        tx=session.beginTransaction();  
        session.save(user);  
        tx.commit();  
    } catch (Exception e) {
        if(tx!=null){
            tx.rollback();
        }
    }finally{
        session.close();
    }
}

##2.2 分析##

  1. 事务功能和业务功能的分离

jdbc事务中Connection负担了两方面的功能，事务功能和执行sql的功能。这里的Transaction是Hibernate自己定义的事务，Hibernate则把这两者的功能单独开来，将事务功能交给了Transaction，使得职责更加分工明确。

  1. 事务的原理

其实Session、Transaction内部会有一个相同的Connection，这样就保证了业务代码和事务代码使用的是同一个Connection，Transaction事务的回滚都是依托内部的Connection来完成的，如下：

  • 事务的开始，设置自动提交为false

输入图片说明

  • 事务的提交，通过connection的commit方法来提交

输入图片说明

#3 Spring事务功能的总体接口设计# 由于上述各家实现事务功能的方式各不相同，Spring进行了统一的抽象，形成了PlatformTransactionManager事务管理器接口，事务的提交、回滚等操作全部交给它来实现。Spring的事务体系也是在PlatformTransactionManager事务管理器接口上开展开来的，所以先来了解下PlatformTransactionManager事务管理器。

##3.1 事务功能的总体接口设计## 先来看下三大接口：

PlatformTransactionManager：事务管理器；

TransactionDefinition：事务的一些基础信息，如超时时间、隔离级别、传播属性等；

TransactionStatus：事务的一些状态信息，如是否是一个新的事务、是否已被标记为回滚；

看下PlatformTransactionManager如何来操作事务：

public interface PlatformTransactionManager {

    //根据事务定义TransactionDefinition，获取事务
    TransactionStatus getTransaction(TransactionDefinition definition);

    //提交事务
    void commit(TransactionStatus status);

    //回滚事务
    void rollback(TransactionStatus status);
}

##3.2 接口对应的实现## ###3.2.1 事务定义接口TransactionDefinition### 输入图片说明

  • 红线上方是一些常量定义（事务的隔离级别和事务的传播属性，具体不再说，网上一大堆）
  • 事务的定义包含：事务的隔离级别、事务的传播属性、超时时间设置、是否只读

**要明白的地方：**事务的隔离级别是数据库本身的事务功能，然而事务的传播属性则是Spring自己为我们提供的功能，数据库事务没有事务的传播属性这一说法。

该接口的实现DefaultTransactionDefinition：默认的事务定义

public class DefaultTransactionDefinition implements TransactionDefinition, Serializable {
    private int propagationBehavior = PROPAGATION_REQUIRED;
    private int isolationLevel = ISOLATION_DEFAULT;
    private int timeout = TIMEOUT_DEFAULT;
    private boolean readOnly = false;
    //略
}

事务的传播属性为PROPAGATION_REQUIRED，即当前没有事务的时候，创建一个，如果有则使用当前事务

事务的隔离级别采用底层数据库默认的隔离级别

超时时间采用底层数据库默认的超时时间

是否只读为false

###3.2.2 事务接口定义TransactionStatus### 先引出Connection连接中的保存点功能：

//创建一个保存点
conn.setSavepoint(name);
//回滚到某个保存点
conn.rollback(savepoint);
//释放某个保存点
conn.releaseSavepoint(savepoint);

TransactionStatus它继承了SavepointManager接口，SavepointManager是对事务中上述保存点功能的封装，如下：

public interface SavepointManager {
    Object createSavepoint() throws TransactionException;
    void rollbackToSavepoint(Object savepoint) throws TransactionException;
    void releaseSavepoint(Object savepoint) throws TransactionException;
}

Spring利用保存点功能实现了事务的嵌套功能。后面会详细说明。TransactionStatus本身更多存储的是事务的一些状态信息：

输入图片说明

是否是一个新的事务

是否有保存点

是否已被标记为回滚

常用的TransactionStatus接口实现为DefaultTransactionStatus：

输入图片说明

目前jdbc事务是通过Connection来实现事务的，Hibernate是通过它自己定义的Transaction来实现的，所以各家的事务都不同，所以Spring只能以Object transaction的形式来表示各家的事务，事务的回滚和提交等操作都会最终委托给上述Object transaction来完成。

Object transaction的职责就是提交回滚事务，这个transaction的选择可能如下：

DataSourceTransactionObject

HibernateTransactionObject

JpaTransactionObject（之后再详细说）

详细信息分别如下：

  • 对于DataSourceTransactionObject：

我们使用了dataSource来获取连接，要想实现事务功能，必然需要使用Connection，所以它中肯定有一个Connection来执行事务的操作。

DataSourceTransactionObject中有一个ConnectionHolder，它封装了一个Connection。

  • 对于HibernateTransactionObject：

我们使用了hibenrate,此时要想实现事务功能，必然需要通过hibernate自己定义的Transaction来实现。

HibernateTransactionObject中含有一个SessionHolder，和上面的ConnectionHolder一样，它封装了一个Session,有了Session，我们就可以通过Session来产生一个Hibernate的Transaction，从而实现事务操作。

###3.2.3 事务管理器接口定义PlatformTransactionManager### 类图关系如下：

输入图片说明

重点来说下：

  • AbstractPlatformTransactionManager
  • DataSourceTransactionManager
  • HibernateTransactionManager
  • JpaTransactionManager（之后详细再说）

这就需要来看看事务管理器的接口，上述的他们都是怎么实现的：

  1. 第一个接口：TransactionStatus getTransaction(TransactionDefinition definition) 根据事务定义获取事务状态

大体内容就是先获取上述说明的Object transaction，判断当前事务是否已存在，如果存在则进行事务的传播属性处理，后面详细说明，如果不存在new DefaultTransactionStatus，新创建一个事务，同时使用Object transaction开启事务。 分成了几个过程：

1.1 获取Object transaction：不同的事务管理器获取不同的Object transaction。

  • DataSourceTransactionManager就是获取上述的DataSourceTransactionObject

从当前线程中获取绑定的ConnectionHolder，可能为null,如果为null，则会在下一个开启事务的过程中，从dataSource中获取一个Connection，封装成ConnectionHolder，然后再绑定到当前线程。

然后我们new 一个DataSourceTransactionObject了，具体过程如下：

输入图片说明

  • HibernateTransactionManager获取HibernateTransactionObject

从当前线程中获取绑定的SessionHolder，可能为null,如果为null，则会在下一个开启事务的过程中从sessionFactory中获取一个session,然后封装成SessionHolder，然后再绑定到当前线程

然后我们就可以new 一个HibernateTransactionObject了，具体过程如下：

输入图片说明

1.2 构建DefaultTransactionStatus，使用Object transaction开启事务

  • DataSourceTransactionManager的DataSourceTransactionObject开启过程如下：

首先判断之前的获取当前线程绑定的ConnectionHolder是否为null，如果为null，从dataSource中获取一个Connection，封装成ConnectionHolder，然后再绑定到当前线程

因为开启了一个事务，则必须要关闭DataSourceTransactionObject中Connection的自动提交，代码如下（省略一些）：

  protected void doBegin(Object transaction, TransactionDefinition definition) {
     DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
     Connection con = null;

     //如果ConnectionHolder是否为null，从新获取
     if (txObject.getConnectionHolder() == null ||
             txObject.getConnectionHolder().isSynchronizedWithTransaction()) {
         Connection newCon = this.dataSource.getConnection();
         txObject.setConnectionHolder(new ConnectionHolder(newCon), true);
     }
     con = txObject.getConnectionHolder().getConnection();

     Integer previousIsolationLevel = DataSourceUtils.prepareConnectionForTransaction(con, definition);
     txObject.setPreviousIsolationLevel(previousIsolationLevel);

     // 取消自动提交
     if (con.getAutoCommit()) {
         txObject.setMustRestoreAutoCommit(true);
         if (logger.isDebugEnabled()) {
             logger.debug("Switching JDBC Connection [" + con + "] to manual commit");
         }
         con.setAutoCommit(false);
     }
     txObject.getConnectionHolder().setTransactionActive(true);
     
     // 如果是新增的ConnectionHolder，则绑定到当前线程
     if (txObject.isNewConnectionHolder()) {
         TransactionSynchronizationManager.bindResource(getDataSource(), txObject.getConnectionHolder());
     }
  }
  • HibernateTransactionManager的HibernateTransactionObject开启过程如下：

也是同样的逻辑，如果SessionHolder为null，则从SessionFactory中获取一个Session，然后封装成SessionHolder，然后把这个SessionHolder绑定到当前线程：

Session newSession = (entityInterceptor != null ?
              getSessionFactory().withOptions().interceptor(entityInterceptor).openSession() :
              getSessionFactory().openSession());
txObject.setSession(newSession);

同时，使用上述session开启一个事务，把事务对象也保存到上述的SessionHolder中：

Transaction hibTx=session.beginTransaction();
txObject.getSessionHolder().setTransaction(hibTx);

如果是新创建的SessionHolder，则绑定到当前线程：

// Bind the session holder to the thread.
if (txObject.isNewSessionHolder()) {
    TransactionSynchronizationManager.bindResource(getSessionFactory(), txObject.getSessionHolder());
}
  1. 第二个接口：void rollback(TransactionStatus status) 回滚事务

回滚，则还是利用DefaultTransactionStatus内部的Object transaction来执行回滚操作

  • DataSourceTransactionManager就是使用DataSourceTransactionObject中的Connection来进行回滚操作：
protected void doRollback(DefaultTransactionStatus status) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) status.getTransaction();
    Connection con = txObject.getConnectionHolder().getConnection();
    try {
        con.rollback();
    } catch (SQLException ex) {
        throw new TransactionSystemException("Could not roll back JDBC transaction", ex);
    }
}
  • HibernateTransactionManager就是使用HibernateTransactionObject中的SessionHolder中的Session创建的事务Transaction来进行回滚操作：
protected void doRollback(DefaultTransactionStatus status) {
    HibernateTransactionObject txObject = (HibernateTransactionObject) status.getTransaction();
    try {
        txObject.getSessionHolder().getTransaction().rollback();
    }
}
  1. 第三个接口： void commit(TransactionStatus status) 提交事务

同理，DataSourceTransactionManager依托内部的Connection来完成提交操作；HibernateTransactionManager依托内部的Transaction来完成提交操作。

##3.3 事务的传播属性解析## 可以参考这篇文章的案例说明Spring事务的传播行为和隔离级别,下面重点源码分析下Spring的事务传播属性：

对于事务的传播属性的代码如下：

输入图片说明

在获取Object transaction之后，先进行判断，是否是已存在的事务。因为这个Object transaction的获取过程就是直接从线程绑定的获取的,可能当前线程已经存在事务，具体判断如下：

  • **DataSourceTransactionManager：**就是依据和当前线程绑定的ConnectionHolder中是否已存在事务。
protected boolean isExistingTransaction(Object transaction) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    return (txObject.getConnectionHolder() != null && txObject.getConnectionHolder().isTransactionActive());
}
  • **HibernateTransactionManager：**也是依据和当前线程绑定的SessionHolder是否已存在事务。
public boolean hasSpringManagedTransaction() {
    return (this.sessionHolder != null && this.sessionHolder.getTransaction() != null);
}

如果是已存在事务：则需要对事务的传播属性进行处理，如下即上述截图中的的handleExistingTransaction方法：

  1. PROPAGATION_NEVER：不允许存在事务，如果存在抛出异常
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NEVER) {
    throw new IllegalTransactionStateException(
          "Existing transaction found for transaction marked with propagation 'never'");
}
  1. PROPAGATION_NOT_SUPPORTED：不支持事务，如果存在事务，则需将事务挂起，保存起来，当执行完成之后，需要将挂起的事务继续恢复
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_NOT_SUPPORTED) {
    if (debugEnabled) {
        logger.debug("Suspending current transaction");
    }
    Object suspendedResources = suspend(transaction);
    boolean newSynchronization = (getTransactionSynchronization() == SYNCHRONIZATION_ALWAYS);
    return prepareTransactionStatus(
          definition, null, false, newSynchronization, debugEnabled, suspendedResources);
}

挂起之后，产生一个Object transaction=null的事务，即不执行事务代码，同时把挂起的资源信息传递给新创建的事务，当这个事务执行完成之后，再把挂起的资源恢复过来。

2.1 对于DataSourceTransactionManager来说，事务的挂起，就是把当前线程关联的ConnectionHolder解除绑定：

protected Object doSuspend(Object transaction) {
    DataSourceTransactionObject txObject = (DataSourceTransactionObject) transaction;
    txObject.setConnectionHolder(null);
    ConnectionHolder conHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(this.dataSource);
    return conHolder;
}

同理事务的恢复就是把上述ConnectionHolder再重新绑定到当前线程，继续执行该事务。

2.2 对于HibernateTransactionManager来说，事务的挂起，就是把当前线程关联的SessionHolder解除绑定

protected Object doSuspend(Object transaction) {
    HibernateTransactionObject txObject = (HibernateTransactionObject) transaction;
    txObject.setSessionHolder(null);
    SessionHolder sessionHolder =
         (SessionHolder) TransactionSynchronizationManager.unbindResource(getSessionFactory());
    txObject.setConnectionHolder(null);
    ConnectionHolder connectionHolder = null;
    if (getDataSource() != null) {
        connectionHolder = (ConnectionHolder) TransactionSynchronizationManager.unbindResource(getDataSource());
    }
    return new SuspendedResourcesHolder(sessionHolder, connectionHolder);
}

同理事务的恢复就是把上述SessionHolder再重新绑定到当前线程，继续执行该事务。

  1. PROPAGATION_REQUIRES_NEW：开启一个新的事务，如果当前存在事务则把当前事务挂起来
if (definition.getPropagationBehavior() == TransactionDefinition.PROPAGATION_REQUIRES_NEW) {
    SuspendedResourcesHolder suspendedResources = suspend(transaction);
    try {
        boolean newSynchronization = (getTransactionSynchronization() != SYNCHRONIZATION_NEVER);
        DefaultTransactionStatus status = newTransactionStatus(definition, transaction, true, newSynchronization, debugEnabled, suspendedResources);
        doBegin(transaction, definition);
        prepareSynchronization(status, definition);
        return status;
    }
}

可以看到，创建新的事务，就会调用doBegin(transaction, definition);方法，将事务开启。

  1. PROPAGATION_NESTED ： 原理很多人已详细说明，可以参考Spring事务的传播行为和隔离级别，源码证实有待继续研究

这里使用了Object transaction来创建了SavePoint，仍旧使用原事务。

  1. PROPAGATION_SUPPORTS 和 PROPAGATION_REQUIRED ： 如果当前存在事务，则仍旧使用该事物。

转载于:https://my.oschina.net/xianggao/blog/541466

csdn产品小助手
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
分布式事务——Spring.ChainedTransactionManager
Sucre
12-01 1万+
代码：https://github.com/JPCui/demos/tree/master/demo-chained-transactionmanager1. 因为之前用过spring-data-neo4j，里面的事务使用了分布式事务的配置；参考：http://docs.spring.io/spring-data/data-neo4j/docs/3.0.x/reference/htmlsingle...
spring 结合druid和hibernate使用jta配置分布式事务
10-31
5. **配置Spring事务管理器**：创建Atomikos事务管理器的bean，并配置Spring的PlatformTransactionManager，指定使用Atomikos的UserTransaction。 6. **代码实现**：在业务逻辑中，通过Spring的@Transactional注解...
多线程插入数据开启事务，要么都成功要么都失败，PlatformTransactionManager 管理事务
你走过的路 风都是暖的
07-27 1279
spring为我们提供了事务相关的接口，PlatformTransactionManager public interface PlatformTransactionManager extends TransactionManager { // 获取当前活动的事务或创建一个新事务 TransactionStatus getTransaction(@Nullable TransactionDefinition definition) throws Transactio..
【Spring】事务的执行原理（三）
S-H_A-N
05-06 433
事务的回滚 如果获取事务属性不为空，并且抛出的异常是RuntimeException或者Error类型，调用事务管理器中的rollback方法进行回滚 如果事务属性为空或者抛出的异常不是RuntimeException，也不是Error，将继续提交事务 public abstract class TransactionAspectSupport implements BeanFactoryAware, InitializingBean { /** * 处理抛出异常下的事务
spring事务原理三【事务回滚】
qq_44989936的博客
04-26 267
@Override public final void rollback(TransactionStatus status) throws TransactionException { //事务已完成则抛异常 //事务不能重复回滚和提交 if (status.isCompleted()) { throw new IllegalTransactionStateException( "Transaction is already completed - do not call comm
Spring事物05-源码分析TransactionStatus
my_momo_csdn的博客
09-22 8017
文章目录Spring事物源码分析-TransactionStatus一、TransactionStatus接口二、DefaultTransactionStatus(实现类)三、TransactionStatus和PlatformTransactionManager四、TransactionStatus和事物操作五、小结 Spring事物源码分析-TransactionStatus 一、Transa...
Spring事务源码分析
Ydoing的专栏
09-13 1237
事务属性定义接口TransactionDefinition是事务属性定义接口，保存事务定义的各种属性，如超时时间、隔离级别、传播属性等。public interface TransactionDefinition { //获取事务传播类型 int getPropagationBehavior(); //获取事务隔离级别 int getIsolationLevel();
Spring+JOTM 分布式事务管理
12-18
在IT行业中，分布式事务管理是复杂且至关重要的一个领域，特别是在构建可扩展的、高可用性的企业级应用时。Spring框架作为一个广泛使用的Java应用程序开发框架，提供了多种支持事务管理的解决方案，其中包括集成JOTM...
spring cloud事务管理
06-20
Spring Cloud事务管理基于Spring的声明式事务管理，它通过Spring Framework的PlatformTransactionManager接口和@Transactional注解来实现。在Spring Cloud中，我们可以利用Spring Boot的自动配置特性，配合RabbitMQ...
spring+atomikos+druid分布式事务Demo
02-08
Atomikos通过提供用户交易服务（UserTransactionService）和事务管理器（TransactionManager），使Spring能够管理分布式事务。在Spring中，我们可以通过配置Atomikos事务管理器，使得Spring可以在跨数据库操作时启动...
spring搭建分布式事务所需嘉宝atomikos加druid配置分布式事务
12-26
Spring框架提供了多种实现分布式事务管理的方式，其中一种是通过集成第三方工具如Atomikos来实现。Atomikos是一个开源的事务处理服务，支持JTA（Java Transaction API），能很好地处理分布式环境中的ACID（原子性、...
【老王读Spring Transaction-4】Spring事务管理的核心原理——PlatformTransactionManager&TransactionStatus
老王的专栏
02-10 2356
begin: 获取连接commit: 提交事务（业务正常执行）rollback: 回滚事务（业务异常）Spring 中通过注解的方式实现了切面式的事务管理，其本质还是会经历上面三个步骤。下面我们就来研究一下 Spring 中是怎么实现事务的管理的。
分布式事务系列（1.1）Spring事务管理器PlatformTransactionManager
weixin_34032779的博客
05-15 883
2019独角兽企业重金招聘Python工程师标准>>> ...
Spring事务管理(三)-PlatformmTransactionManager解析和事务传播方式原理
weixin_33730836的博客
01-28 408
2019独角兽企业重金招聘Python工程师标准>>> ...
spring 编程式事务管理—PlatformTransactionManager
shendeguang的专栏
11-06 3469
JDBC的事务管理在Spring2.0下有两种编程式的实现 PlatformTransactionManager TransactionTemplate 对于PlatformTransctionManager，通常，不直接使用它，而是使用它的实现类DataSourceTransactionManager。具体用法如下： 1. 实例化的时候，需要用个数据源作参数 2. 建立事务的定
Spring入门——事务管理Transaction Manager
忘忧的博客
04-24 5985
1、事务初识 事务是逻辑上的一组操作，要么全部成功，要么全部失败。 事务具有ACID特性，参考百度百科，具体如下： 原子性（Atomicity）：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。 一致性（Consistency）：事务必须始终保持系统处于一致的状态，不管在任何给定的时间并发事务有多少。 隔离性（Isolation）：隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。 持久性（Durability）：在事务完成以后，该事务对数据库所作的更
spring（三）之事务、事务管理器（TransactionManager）简介及实现事务的4种方式
hqy1719239337的博客
08-01 4262
1、事务 一组业务ACID操作，要么全部成功，要么全部不成功。 事务特性：①原子性，针对整体而言（一个事务不可以被拆分）；②一致性，针对数据而言（一个事务执行之前和执行之后必须处于一致性状态，一个事务包含的所以操作要么全部成功，要么全部失败。比如转账前，A和B各有250元，A转250给B，结果A有0元，B有500元，A和B相加的钱，不管转账前还是转账后都是500元...
spring框架（三）事务管理、PlatformTransactionManager、转账案例
ChihkAnchor的博客
03-21 1320
AOP ：切面编程 切面：切入点 和 通知 结合 spring aop 编程 <aop:config> 方法1： <aop:pointcut expression="切入点表达式" id=""> <aop:advisor advice-ref="通知引用" pointcut-ref="切入点的引用"> ...
Spring事务核心接口：PlatformTransactionManager
最新发布
five-five
03-25 2048
PlatformTransactionManager是Spring框架中事务管理的核心接口，它负责管理事务的创建、提交和回滚等操作。在Spring中，事务管理是通过PlatformTransactionManager和TransactionManager接口来实现的。PlatformTransactionManager是一个更高级的接口，它封装了TransactionManager接口，提供了更丰富的事务管理功能。
Spring事务管理：失效、回滚与大事务解析
"这篇文档是关于Spring事务管理的总结，主要涵盖了事务不生效的原因、事务回滚的条件、处理大事务的问题以及编程式事务的使用。文档提到了访问权限对事务生效的影响，以及在实际代码中如何配置和管理事务。" 在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值