spring事务-2（事务传播级别组合说明）

最新推荐文章于 2023-05-09 07:45:00 发布
最新推荐文章于 2023-05-09 07:45:00 发布
阅读量596 收藏 4
点赞数 1
分类专栏： spring 文章标签： mysql java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/daliucheng/article/details/123026097
版权

事务传播级别组合说明

例子

  1. 配置类

    package transaction;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;

import javax.sql.DataSource;

@Configuration(proxyBeanMethods = false)
@EnableTransactionManagement
public class Config {
	@Bean
	public DriverManagerDataSource driverManagerDataSource() {
		DriverManagerDataSource dataSource = new DriverManagerDataSource();
		dataSource.setDriverClassName("com.mysql.jdbc.Driver");
		dataSource.setUrl("jdbc:mysql://10.100.0.176:3306/mybatis");
		dataSource.setUsername("root");
		dataSource.setPassword("123456");
		return dataSource;
	}
	@Bean
	public TestTx testTx() {
		return new TestTx();
	}
	@Bean
	public JdbcTemplate jdbcTemplate(DataSource dataSource) {
		JdbcTemplate jdbcTemplate = new JdbcTemplate();
		jdbcTemplate.setDataSource(dataSource);
		return jdbcTemplate;
	}

	@Bean
	public PlatformTransactionManager txManager(DataSource dataSource) {
		return new DataSourceTransactionManager(dataSource);
	}
}

  2. 事务方法

    package transaction;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.Assert;

public class TestTx {
	@Autowired
	private JdbcTemplate jdbcTemplate;
	private int count;
	@Autowired
	private TestTx testTxAgent;

	@Transactional(propagation = Propagation.REQUIRED)
	public void b(int id, String name) {
		throw new RuntimeException("updateNameWithException1");
	}

	public void be(int id, String name) {
		jdbcTemplate.update("update t_test set name=? where id=?", name, id);
	}

	@Transactional(propagation = Propagation.REQUIRED)
	public TestBean a(int id) {
		TestBean testBean = jdbcTemplate.queryForObject("select * from t_test where id=?", new BeanPropertyRowMapper<>(TestBean.class), id);
		Assert.notNull(testBean, "testBean not be null");
		try {
			testTxAgent.b(id, testBean.getName() + "-" + count++);
		} catch (Exception e) {
			e.printStackTrace();
		}
		be(id,"be-name");
		return testBean;
	}

}

class TestBean {
	private Integer id;
	private String name;
	private Double age;

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Double getAge() {
		return age;
	}

	public void setAge(Double age) {
		this.age = age;
	}

	@Override
	public String toString() {
		return "TestBean{" +
				"id=" + id +
				", name='" + name + '\'' +
				", age=" + age +
				'}';
	}
}

  3. DDL

    -- auto-generated definition
create table t_student
(
    id   int auto_increment,
    age  int         null,
    name varchar(50) null,
    constraint t_student_id_uindex
        unique (id)
);

alter table t_student
    add primary key (id);

  4. 主启动类

    package transaction;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.sql.SQLException;

public class MainTest
{
	public static void main(String[] args) throws SQLException {
		try {
			AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);
			TestTx testTx = context.getBean(TestTx.class);
			TestBean testBeanById = testTx.a(1);
			System.out.println(testBeanById);
		}catch (Throwable e){
			e.printStackTrace();;
		}
	}
}

下面的这些例子都是围绕上面的代码来测试。没有额外说明的话，都是a->b，上面方法中的@Transactional会变。不是上面例子中一成不变的。

通过上一篇文章，已经知道，最终操作的是Connection。所谓挂起，就是将之前的事务的状态变为当前事务的一个属性。事务的传播级别上面已经说的很清楚了，这里想总体的区分一下。

主要分为：

  1. 需要创建一个新的事务。
  2. 需要事务，不需要创建一个新的事务。不需要用SavePoint（其实就是第二个不能为PROPAGATION_NESTED）。
  3. 需要事务，不需要创建一个新的事务。需要用SavePoint（其实就是第二个是PROPAGATION_NESTED）
  4. 不需要事务，但是可以执行
  5. 不能有事务，有就要报错。

下面的组合也是按照这种的思路来分析。下面只说异常的情况，正常的情况是没有可说的。

还有一点，可以指定异常回滚，要是当前的异常和指定的异常不匹配，还是会找RuntimeException和Error,这里我抛出的异常都是RuntimeException的子类。所以，这里就不需要指定异常了。

在这里插入图片描述

现在有两个方法。A和B。

需要创建一个新的事务

这个要求能组合的传播级别不多。a可以为（PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW，PROPAGATION_NESTED），b只能为（PROPAGATION_REQUIRES_NEW）。

没有处理异常

在这里插入图片描述

b和a里面的事务都会回滚。

分析：

之前对事务的实现（TransactionInterceptor做了分析），异常会被catch掉，做事务的回滚操作，但是这个异常还会继续的抛出去。同样的逻辑，这个异常会被调用a的时候的TransactionInterceptor掉，同样的也是会做事务的回滚的。当前提条件是异常需要回滚。如果不需要回滚就会提交掉，当然需要注意的是，a方法中调用b方法之后的代码是不会执行的。如果提交也是提前调用b方法之前的操作，回滚也是。

  • 补充说明（举个例子说明一下异常不满足，导致a中的调用b方法之前的操作提交掉）

在这里插入图片描述

在这里插入图片描述

处理了异常

a在调用b的时候用try catch处理了异常。
在这里插入图片描述

b回滚，a提交

分析：

a和b是两个独立的事务，在TransactionInterceptor的catch块里面捕获了异常，在处理事务的回滚之后，会将原始的异常抛出来，在调用b之后，处理完b事务的回滚之后，会将原始的异常抛出来。但是这个时候被a在内部catch了，这个异常并没有抛到TransactionInterceptor里面的catch块。所以对于a来说，一切都是正常的。所以，他的事务会提交。
在这里插入图片描述

需要事务，不需要创建一个新的事务。不需要用SavePoint（其实就是第二个不能为PROPAGATION_NESTED）

这意思就是a得先有一个事务，b才能复用a中的事务。a(PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW，PROPAGATION_NESTED),b(PROPAGATION_REQUIRED)

没有处理异常

在这里插入图片描述

注意：这里从头到尾就一个事务，b用的是a的事务。

a和b的操作都没有生效，并且事务回滚。

分析：

和上面是一样的模式，TransactionInterceptor捕获了异常，做回滚操作，之后将原始的异常抛出，同样的逻辑，在a里面做了回滚操作。

需要注意的一点：

a和b用的是同一个事务，也就是同一个Connection对象，在调用b的异常之后，TransactionInterceptor里面做回滚操作，不会真正的去做回滚（也就是说不会调用Connection.rollback()方法），只是设置了一下ConnectionHolder的一个标志位（Rollback only为true），表示这个事务出现了异常，需要做回滚。真正处理回滚的地方应该是那个方法创建的Connection，它就应该做真正的回滚操作。

但是因为a调用b的时候，并没有用catch块捕获，原始的异常还是可以被TransactionInterceptor捕获到，去做回滚操作，a是真正创建connection的，所以，真正的回滚操作也得是它来。

处理了异常

在这里插入图片描述

a和b的操作都没有生效，并且事务回滚，抛出了一个怪异的错误Transaction rolled back because it has been marked as rollback-only

在这里插入图片描述

分析:

接着上面的说，b异常被a内部catch了，a对应的TransactionInterceptor无法获取到异常信息，catch块走不了，只能走提交操作，在提交的时候发现当前ConnectionHolder的Rollback属性为true，就会去做回滚操作，会真正的调用connection的rollback()方法，并且抛出UnexpectedRollbackException。

长事务：就是多个方法引用的是同一个事务，并且这些方法没有savePoint的操作，这就是长事务，一般默认，长事务中只有要一个报错，整个事务都会失败。

补充说明

直接看代码更加的清晰

  1. 做回滚(AbstractPlatformTransactionManager#processRollback(DefaultTransactionStatus,boolean))

    private void processRollback(DefaultTransactionStatus status, boolean unexpected) {
		try {
			boolean unexpectedRollback = unexpected;
			try {
				triggerBeforeCompletion(status);
        // 是否有savePoint，判断的顺序是关键，如果b为nested的话，a中处理了异常是不会有问题的。因为没有设置rollback only属性
				if (status.hasSavepoint()) {
					if (status.isDebug()) {
						logger.debug("Rolling back transaction to savepoint");
					}
          // 回滚到savePoint，并且释放到savePoint
					status.rollbackToHeldSavepoint();
				}
        // 是否是新的事务，也就是说这个事务是否是由这个方法创建的。如
				else if (status.isNewTransaction()) {
					if (status.isDebug()) {
						logger.debug("Initiating transaction rollback");
					}
					doRollback(status);// 这个回滚操作很简单，就是connection.rollback方法
				}
				else {
  			// 上述条件不满足，就是一个长事务。
					if (status.hasTransaction()) {
            // 可以直接改TransactionStatus的对应的值，也可以直接改AbstractPlatformTransactionManager中的方法返回值。
            // 基本上来说AbstractPlatformTransactionManager为true
						if (status.isLocalRollbackOnly() || isGlobalRollbackOnParticipationFailure()) {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - marking existing transaction as rollback-only");
							}
              // 设置ConnectionHolder的rollback only
							doSetRollbackOnly(status);
						}
						else {
							if (status.isDebug()) {
								logger.debug("Participating transaction failed - letting transaction originator decide on rollback");
							}
						}
					}
					else {
						logger.debug("Should roll back transaction but cannot - no transaction available");
					}
					// Unexpected rollback only matters here if we're asked to fail early
					if (!isFailEarlyOnGlobalRollbackOnly()) {
						unexpectedRollback = false;
					}
				}
			}
			catch (RuntimeException | Error ex) {
				triggerAfterCompletion(status, TransactionSynchronization.STATUS_UNKNOWN);
				throw ex;
			}

			triggerAfterCompletion(status, TransactionSynchronization.STATUS_ROLLED_BACK);

      // 这个为true直接抛出异常，
			if (unexpectedRollback) {
				throw new UnexpectedRollbackException(
						"Transaction rolled back because it has been marked as rollback-only");
			}
		}
		finally {
			cleanupAfterCompletion(status);
		}
	}

    调用该方法的地方多着呢，unexpectedRollback的为true主要是在事务做提交的时候传递的。

  2. 做提交(AbstractPlatformTransactionManager#commit(TransactionStatus))

    public final void commit(TransactionStatus status) throws TransactionException {
		if (status.isCompleted()) {
			throw new IllegalTransactionStateException(
					"Transaction is already completed - do not call commit or rollback more than once per transaction");
		}

		DefaultTransactionStatus defStatus = (DefaultTransactionStatus) status;
  // 先判断DefaultTransactionStatus的rollback only
		if (defStatus.isLocalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Transactional code has requested rollback");
			}
			processRollback(defStatus, false);
			return;
		}
		// 这里传递的是true，这会判断connectionHolder中rollback only的值。
  // shouldCommitOnGlobalRollbackOnly也可以重写
		if (!shouldCommitOnGlobalRollbackOnly() && defStatus.isGlobalRollbackOnly()) {
			if (defStatus.isDebug()) {
				logger.debug("Global transaction is marked as rollback-only but transactional code requested commit");
			}
			processRollback(defStatus, true);
			return;
		}
   // 这里才会做提交操作。
		processCommit(defStatus);
	}

对照代码来看上面的例子就比较清晰了。

需要事务，不需要创建一个新的事务。需要用SavePoint（其实就是第二个是PROPAGATION_NESTED）

这意思就是a得先有一个事务，b才能复用a中的事务。和上一个一样，但是b只能是PROPAGATION_NESTED。a(PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW，PROPAGATION_NESTED),b(PROPAGATION_NESTED)

没有处理异常

在这里插入图片描述

a和b的操作都没有生效，并且事务回滚。

分析

这个原因和上面的是一样，没有try catch，会导致异常直接到a相关的TransactionInterceptor里面，捕获异常做回滚。

处理了异常

在这里插入图片描述

b方法回滚，a方法执行成功。事务提交，a和b用是同一个事务。

分析：

如果存在事务，nested会按照嵌套的方式来执行，其实就是利用SavePoint，a开始一个事务，执行到b的时候。b对应的TransactionInterceptor在调用b方法之前会在当前的事务的Connection里面保存一个savePoint，在执行完成之后会释放savePoint。

如果b出现了异常，在上面的例子中已经分析了出现异常之后的回滚操作，一上来就会检查是否有savePoint，如果有会回滚到savePoint。不会设置rollback only。对这个这个例子来说，异常已经捕获到了，a对应的TransactionInterceptor没有捕获到异常，并且也不需要rollback only，所以事务正常提交。

这里a和b用的是同一个事务。这就是嵌套事务，外层事务回滚会导致内层事务也回滚，内存事务回滚不会导致外层事务回滚。这话其实不对，就没有内外层事务之说，从始到终一个事务。

不需要事务，但是可以执行

这种组合方式比较多，可以是a方法有事务，b方法没有事务，这样的组合有a（PROPAGATION_REQUIRED，PROPAGATION_REQUIRES_NEW，PROPAGATION_NESTED），b（PROPAGATION_NOT_SUPPORTED）。也可以是a b 方法都没有事务，这样的组合有a(PROPAGATION_NOT_SUPPORTED,PROPAGATION_NEVER),b(PROPAGATION_NOT_SUPPORTED,PROPAGATION_NEVER)。

a方法有事务，b方法没有事务

没有处理异常

在这里插入图片描述

b中按照没有事务的方式运行，a中事务回滚

在这里插入图片描述

分析：

b按照没有事务的方式运行，所以每一行的sql操作都是事务的。所以，b中的修改成功了。

但是这个异常还是抛给了a，a所对应的TransactionInterceptor会捕获异常，做事务的回滚操作。所以，a中的修改没有作用。

处理了异常

在这里插入图片描述

b中按照没有事务的方式运行，a中事务提交

分析:

异常在a中已经处理掉了，所以a对应的TransactionInterceptor没有异常，正常提交

a b 方法都没有事务

在这里插入图片描述

a和b都按照非事务的方式来执行了，所以没什么好说的了

补充说明

既然都不需要事务了，为啥不直接去掉这两注解呢？

这两注解只是Connection相关的操作没有了，但是在Spring事务里面除了Connecton之外，还有别的，比如和事务相关的资源（TransactionSynchronization）,他会走完事务操作的流程，支持在一些真正需要回滚的地方没有操作而已。

不能有事务，有就要报错。

这其实就是PROPAGATION_NEVER了，有事务就直接报错。

必须有事务，有就要报错。

这其实就是PROPAGATION_MANDATORY了，没有事务就直接报错，但是他不会创建一个新的事务，只会复用之前的事务。那这个逻辑就和a和b都是PROPAGATION_SUPPORTS差不多了。长事务的概念。

关于博客这件事，我是把它当做我的笔记，里面有很多的内容反映了我思考的过程，因为思维有限，不免有些内容有出入，如果有问题，欢迎指出。一同探讨。谢谢。
daliucheng
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
事务五个隔离级别与七个传播行为示例
qq_35273686的博客
03-19 169
1. TransactionDefinition接口中定义五个隔离级别： ISOLATION_DEFAULT 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应； ISOLATION_READ_UNCOMMITTED 这是事务最低的隔离级别，它充许别外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏...
Spring事务管理之事务传播
AlgebraFly的博客
05-21 122
概念 Spring 在 TransactionDefinition 接口中规定了 7 种类型的事务传播行为。事务传播行为是 Spring 框架独有的事务增强特性，他不属于的事务实际提供方数据库行为。 事务传播行为用来描述由某一个事务传播行为修饰的方法被嵌套进另一个方法的时事务如何传播。 **ps.**所谓事务的嵌套就是两个事务方法之间相互调用。spring事务开启 ，或者是基于接口的或者是基于类的代理被创建（注意一定要是代理，不能手动new 一个对象，并且此类（有无接口都行）一定要被代理——spring中的
Spring事务传播行为
xiaxiaomao1981的博客
02-02 117
假如有两个方法A和B，A调用B,这两个方法上都加了事物，究竟使用哪个事物？ Public void A(){ B(); } 这就是spring事物传播行为要解决的问题。 在spring中有七种事务传播行为。 简单介绍一下这七种方式（如果不懂不用纠结，后面详细介绍） 常用： REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入...
Spring与Mybatis组合使用事务
q1937915896的博客
03-13 239
1、首先配置Spring与mybatis的spring-config.xml配置文件: &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLS...
spring的七种事务传播级别
weixin_46374887的博客
07-12 317
总结： [1]死活不要事务的 PROPAGATION_NEVER：没有就非事务执行，有就抛出异常 PROPAGATION_NOT_SUPPORTED：没有就非事务执行，有就直接挂起，然后非事务执行 [2]可有可无的 PROPAGATION_SUPPORTS: 有就用，没有就算了 [3]必须有事务的 PROPAGATION_REQUIRES_NEW：有没有都新建事务，如果原来有，就将原来的挂起。 PROPAGATION_NESTED: 如果没有，就新建一个事务；如果有，就在当前事务中嵌套其他事务。 PROPA
Spring事务传播属性和隔离级别详细介绍
08-29
Spring事务传播属性和隔離级别详细介绍 Spring事务传播属性（Propagation）是指在事务中如何处理事务边界的规则。它定义了事务如何与其他事务进行交互，例如是否支持当前事务、创建新的事务、抛出异常等。 1. ...
spring事务-项目案例-PPT解读.zip
10-08
spring事务_案例_PPT 一、事务传播机制的demo案例，内容包括： 1.业务代码列举7种事务传播机制的情况，每个测试方法都附带日志分析记录、使用场景和实际场景，小白也能看得懂！！！ 2.在测试类Test包下，使用juniter...
54.Spring事务的传播特性和隔离级别.avi
03-07
java面试宝典
浅谈Spring事务传播行为实战
08-25
2. 在异步事件的方式解耦服务调用时，需要考虑事务传播行为的问题。 3. 在使用线程池的方式解耦嵌套事务时，需要考虑事务传播行为的问题。 五、结论： 本文主要介绍了浅谈Spring事务传播行为实战，通过示例代码...
Spring声明式数据库事务的使用－隔离级别
12-14
上面我们只是简单的使用事务，这里将讨论Spring事务机制中最重要的两个配置项，即隔离级别与传播行为。毫无疑问本节内容是本章的核心内容，也是互联网企业最关注的内容之一，因此他十分重要，值得花费大的篇幅去讨论...
Spring事务配置及事务的传播性与隔离级别详解
热门推荐
程序员囧辉
03-10 1万+
1.Spring事务配置 通过注解配置 1.在Spring配置文件引入<tx:> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.s...
Spring2.x——事务管理
SUN19980421的博客
04-22 160
1、认识事务本身 对于一个软件系统来说，需要相应的数据资源（比如，数据库、文件系统等）来保存系统状态。在对系统状态所依托的数据资源进行访问的时候，为了保证系统始终处于“正确”的状态，我们必须对这些访问操作进行一些必要的限定，一次来保证系统状态的完整性。 ...
二分查找法的变种，声明式事务的传播方式，基于注解配置声明式事务
sdfsdfsdds2的博客
10-08 391
二分查找法的变种，声明式事务的传播方式，基于注解配置声明式事务
事务传播行为 @Transactional
学海无涯,我用JAVA
05-09 672
事务传播行为: 指的是在项目中开启多个事务后,他们之间的影响关系;虽然事务的传播枚举还有很多,但是其实,只要掌握这两个就够了,其他的了解即可;如果当前存在事务，就在当前事务内执行；否则，就执行与 PROPAGATION_REQUIRED 类似的操作。如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。以非事务方式运行，如果当前存在事务，则把当前事务挂起。以非事务方式运行，如果当前存在事务，则抛出异常。
同一个类或者两个分别不同的类中a方法调用b方法事务的隔离级别问题
依然在路上、
09-08 2027
BookService: buyBook方法(a) updatePrice方法(b) transactional 不加注解 a报错 b不报错 事务回滚 transactional 不加注解 b报错 a不报错 事务回滚 不加注解 transactional a报错 b不报错 事务都不回滚 不加注解 transactional b报错 a不报错 ...
Spring相同类方法调用事务管理
u011487710的博客
05-20 821
关键词 事务的特性 事务的传播性 事务的管理 BUG:一个ServiceImpl方法A调用同一个类中的方法B，A循环调用B,A无需事务，B必须事务 参考文档 踩坑! spring事务,非事务方法与事务方法执行相互调用 Spring中同一个service类中方法相互调用事务不生效问题解决方案 Spring事务管理嵌套事务详解 : 同一个类中，一个方法调用另外一个有事务的方法 spring 事务处理中，同一个类中:A方法（无事务）调B方法（有事务）,事务不生效问题 @Transactional 同一个类中
Spring事务传播机制，多个事务方法互相调用时，事务如何在这些方法间传播
weixin_44979389的博客
08-31 2868
Spring事务传播机制，多个事务方法互相调用时，事务如何在这些方法间传播
spring，springboot之事务（事务传播机制详解、嵌套事务）
qq_35493807的博客
04-27 8627
spring，springboot之事务（事务传播机制、嵌套事务、事务隔离机制详解）
Spring同一个类事务处理
tsp150600的博客
05-18 2237
Spring同一个类事务处理同一个类不同方法事务可以传播（需要满足事务的前提）同一个类两个不同方法调用（注解方式）同一个类两个不同方法调用（注解方式，父方法捕捉了异常）同一个类两个不同方法调用（注解方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法未使用事务）同一个类两个不同方法调用（子方法编码事务方式，父方法使用注解事务）结论 同一个类不同方法事务可以传播（需要满足事务的前提） 你好！查看一些博客说，同一个类的不同标有事务注解的方法不可以传播。今天就以身试法，尝试一下，不同情况下
Spring框架+Spring中的事务
最新发布
03-22
"本文主要介绍了Spring框架中的事务管理和Spring事务传播机制。Spring是一个分层架构的Java开源框架，它的核心之一是声明式事务管理，它简化了事务处理，避免了手动处理事务相关的代码。在Spring中，事务属性包括...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值