spring--基础--08--spring事务

已于 2023-11-15 17:48:41 修改
阅读量879 收藏
点赞数
分类专栏： spring 文章标签： spring java 后端
于 2020-10-04 10:37:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhou920786312/article/details/108916995
版权

spring–基础–08–spring事务

代码地址

https://gitee.com/DanShenGuiZu/learnDemo.git

1、ACID

  1. 原子性：事务操作要么是成功,要么是失败的。
  2. 一致性：数据一致
  3. 隔离性：事务之间,数据是隔离的
  4. 持久性：保存到硬盘中

2、五大属性

  1. 隔离级别
  2. 传播行为
  3. 是否只读
  4. 事务超时
  5. 回滚规则

2.1、隔离级别

  1. 指若干个并发的事务之间的隔离程度。
  2. TransactionDefinition：定义了5个表示隔离级别：
    1. ISOLATION_DEFAULT：
      1. 这是默认值，表示使用底层数据库的默认隔离级别。
      2. 对大部分数据库而言，通常这值就是ISOLATION_READ_COMMITTED。
    2. ISOLATION_READ_UNCOMMITTED：
      1. 该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。
      2. 该级别不能防止脏读，不可重复读和幻读
      3. 很少使用该隔离级别。比如PostgreSQL实际上并没有此级别。
    3. ISOLATION_READ_COMMITTED：
      1. 该隔离级别表示一个事务只能读取另一个事务已经提交的数据。
      2. 该级别可以防止脏读，这也是大多数情况下的推荐值。
    4. ISOLATION_REPEATABLE_READ：
      1. 该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。
      2. 该级别可以防止脏读和不可重复读。
    5. ISOLATION_SERIALIZABLE：
      1. 所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。
      2. 该级别这将严重影响程序的性能。
      3. 通常情况下不会使用

2.2、事务传播行为

  1. 指如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。
  2. 在TransactionDefinition:定义中5传播行为
    1. PROPAGATION_REQUIRED：
      1. 如果当前存在事务，则加入该事务；
      2. 如果当前没有事务，则创建一个新的事务。
      3. 这是默认值。
    2. PROPAGATION_REQUIRES_NEW：
      1. 创建一个新的事务，
      2. 如果当前存在事务，则把当前事务挂起。
    3. PROPAGATION_SUPPORTS：
      1. 如果当前存在事务，则加入该事务；
      2. 如果当前没有事务，则以非事务的方式继续运行。
    4. PROPAGATION_NOT_SUPPORTED：
      1. 以非事务方式运行，
      2. 如果当前存在事务，则把当前事务挂起。
    5. PROPAGATION_NEVER：
      1. 以非事务方式运行，
      2. 如果当前存在事务，则抛出异常。
    6. PROPAGATION_MANDATORY：
      1. 如果当前存在事务，则加入该事务；
      2. 如果当前没有事务，则抛出异常。
    7. PROPAGATION_NESTED：
      1. 如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；
      2. 如果当前没有事务，则创建一个新的事务。

2.3、事务超时

  1. 指一个事务所允许执行的最长时间，如果超过该时间限制但事务还没有完成，则自动回滚事务。其单位是秒。
  2. 默认设置为底层事务系统的超时值，如果底层数据库事务系统没有设置超时值，那么就是none，没有超时限制。

2.4、是否只读

  1. 只读事务并不是一个强制选项，它只是一个暗示，提示数据库驱动程序和数据库系统，这个事务并不包含更改数据的操作，那么JDBC驱动程序和数据库就有可能根据这种情况对该事务进行一些特定的优化，比方说不安排相应的数据库锁，以减轻事务对数据库的压力，毕竟事务也是要消耗数据库的资源的。
  2. 你非要在只读事务里面修改数据，也并非不可以，只不过对于数据一致性的保护不像读写事务那样保险而已。
  3. 只读事务仅仅是一个性能优化的推荐配置而已，并非强制你要这样做不可

2.5、回滚规则

  1. spring事务管理器回滚一个事务的推荐方法:
    1. 在当前事务的上下文内抛出异常。
  2. spring事务管理器会捕捉任何未处理的异常，然后依据规则决定是否回滚。
  3. 默认配置下
    1. spring只有在抛出的异常为运行时unchecked异常时才回滚该事务，也就是抛出的异常为RuntimeException的子类(Errors也会导致事务回滚)，
    2. 抛出checked异常则不会导致事务回滚。
  4. 可以明确的配置在抛出那些异常时回滚事务，包括checked异常。
  5. 可以明确定义那些异常抛出时不回滚事务。
  6. 可以编程性的通过setRollbackOnly()方法来指示一个事务必须回滚，在调用完setRollbackOnly()后你所能执行的唯一操作就是回滚。

2.5.1、回滚规则测试

@Override
public void insert2(){
    Integer age = 12;
    String name = "xiao6";
    String SQL = "insert into Student(name, age)values(?, ?)";
    jdbcTemplateObject.update(SQL, name, age);
    if(1 == 1){
        // 抛异常，事务由回滚
        int i = 4 / 0;
    }
}

@Override
public void insert3()throws Exception {
    try {
        Integer age = 12;
        String name = "xiao7";
        String SQL = "insert into Student(name, age)values(?, ?)";
        jdbcTemplateObject.update(SQL, name, age);
        int i = 4 / 0;
    } catch(Exception e){
        // 抛出异常，事务没有回滚
        throw new Exception("人为产生异常");// 受检异常(非运行异常)
    }

}

@Override
public void insert4(){
    try {
        Integer age = 12;
        String name = "xiao8";
        String SQL = "insert into Student(name, age)values(?, ?)";
        jdbcTemplateObject.update(SQL, name, age);
        int i = 4 / 0;
    } catch(Exception e){
        // 异常抛出，事务回滚
        throw new RuntimeException("人为产生异常");// 运行异常(非受检异常)可以不抛出
    }

}

@Override
@Transactional(rollbackFor = Exception.class)
public void insert5()throws Exception {
    try {
        Integer age = 12;
        String name = "xiao9";
        String SQL = "insert into Student(name, age)values(?, ?)";
        jdbcTemplateObject.update(SQL, name, age);
        int i = 4 / 0;
    } catch(Exception e){
        // 抛出异常，事务回滚
        throw new Exception("人为产生异常");// 受检异常(非运行异常)
    }

}

3、@Transactional属性和用法

3.1、属性

  1. value:指定使用的事务管理器
  2. propagation:事务传播行为
  3. isolation:事务隔离级别
  4. readOnly:读写或只读事务,默认读写
  5. timeout:事务超时时间设置(秒)
  6. rollbackFor：class对象数组,必须继承自Throwable,导致事务回滚的异常类数组
  7. rollbackForClassName:类名数组,必须继承自Throwable,导致事务回滚的异常类名字数组
  8. noRollbackFor:Class对象数组,必须继承自Throwable,不会导致事务回滚的异常类数组
  9. noRollbackForClassName:类名数组,必须继承自Throwable,不会导致事务回滚的异常类名字数组

3.2、用法

  1. 可以作用于接口、接口方法、类以及类方法上。

  2. 当作用于类上时

    1. 该类的所有public方法将都具有该类型的事务属性。
    2. 我们也可以在方法级别使用该标注来覆盖类级别的定义。

  3. 建议不要在接口或者接口方法上使用该注解,因为这只有在使用基于接口的代理时它才会生效。

  4. 应该只被应用到public方法上

    1. 这是由SpringAOP的本质决定的。
    2. 如果你在protected、private或者默认可见性的方法上使用@Transactional注解,这将被忽略,也不会抛出任何异常。

  5. 默认情况下

    1. 只有来自外部的方法调用才会被AOP代理捕获。
    2. 类内部方法调用本类内部的其他方法并不会引起事务行为,即使被调用方法使用@Transactional注解进行修饰。

  6. 注解不能被继承

    1. 在业务接口中标注的@Transactional注解不会被业务实现类继承,会出现不启动事务的情况。
    2. Spring建议我们将@Transaction注解在实现类上。
    3. 方法上的@Transactional注解会覆盖掉类上的@Transactional。

4、编程式和声明式事务

  1. 编程式事务管理：
    1. 代码控制事务,极大的灵活性,但却很难维护。
    2. 使用TransactionTemplate接口(推荐)
    3. 使用底层的PlatformTransactionManager接口
  2. 声明式事务管理：
    1. 业务代码中分离事务管理。通过注解释或XML配置来管理事务。
    2. 建立在AOP之上的。
    3. 本质是对方法前后进行拦截,然后在目标方法开始之前创建或者加入一个事务,在执行完目标方法之后根据执行情况提交或者回滚事务。
    4. 优点
      1. 不需要在业务逻辑代码中掺杂事务管理的代码,只需在配置文件中做相关的事务规则声明(或通过基于@Transactional注解的方式),便可以将事务规则应用到业务逻辑中。
      2. 非侵入式的开发方式。
    5. 缺点
      1. 最细粒度只能作用到方法级别,无法做到像编程式事务那样可以作用到代码块级别。

4.1、编程式和声明式事务测试

4.1.1、公共部分

CREATE TABLE Student(
  ID int(11)NOT NULL AUTO_INCREMENT,
  NAME varchar(20)DEFAULT NULL,
  AGE int(11)DEFAULT NULL,
  PRIMARY KEY(ID)
)ENGINE=InnoDB AUTO_INCREMENT=25 DEFAULT CHARSET=utf8;

4.1.2、编程式

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

	<bean id="dataSource"
		  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://zhoufei.ali.db.com:3306/test"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
	</bean>


	<!-- Initialization for TransactionManager -->
	<bean id="transactionManager"
		  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>

	<!-- Definition for studentJDBCTemplate bean -->
	<bean id="studentJDBCTemplate"
		  class="com.example.demolearn.other.spring.demo6.StudentJDBCTemplate">
		<property name="dataSource" ref="dataSource"/>
		<property name="transactionManager" ref="transactionManager"/>
	</bean>

</beans>


public interface StudentDAO {
	void insert();
}



public class StudentJDBCTemplate implements StudentDAO {
	private DataSource dataSource;
	private JdbcTemplate jdbcTemplateObject;
	private PlatformTransactionManager transactionManager;

	// 设置数据源
	public void setDataSource(DataSource dataSource){
		this.dataSource = dataSource;
		this.jdbcTemplateObject = new JdbcTemplate(dataSource);
	}

	public PlatformTransactionManager getTransactionManager(){
		return transactionManager;
	}

	public void setTransactionManager(PlatformTransactionManager transactionManager){
		this.transactionManager = transactionManager;
	}

	@Override
	public void insert(){
		TransactionDefinition def = new DefaultTransactionDefinition();
		TransactionStatus status = transactionManager.getTransaction(def);
		try {

			Integer age = 12;
			String name = "xiao4";
			String SQL = "insert into Student(name, age)values(?, ?)";
			jdbcTemplateObject.update(SQL, name, age);

			String SQL2 = "update Student set age = ? where id = ?";
			jdbcTemplateObject.update(SQL2, 21, 25);
			transactionManager.commit(status);

		} catch(DataAccessException e){
			System.out.println("异常,事务回滚");
			transactionManager.rollback(status);
			throw e;
		}

	}
}

public class JDCB1 {
	public static void main(String[] args){
		ApplicationContext context = new ClassPathXmlApplicationContext("./other/JDBC2.xml");
		StudentDAO dao =(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
		dao.insert();

	}
}

在这里插入图片描述

4.1.3、声明式01

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:aop="http://www.springframework.org/schema/aop"
	   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/tx
   http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
   http://www.springframework.org/schema/aop
   http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

	<!--数据源-->
	<bean id="dataSource"
		  class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="com.mysql.jdbc.Driver"/>
		<property name="url" value="jdbc:mysql://zhoufei.ali.db.com:3306/test"/>
		<property name="username" value="root"/>
		<property name="password" value="root"/>
	</bean>
	<!--事务-->
	<bean id="transactionManager"
		  class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"/>
	</bean>


	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="insert"/>
		</tx:attributes>
	</tx:advice>

	<aop:config>
		<aop:pointcut id="createOperation"
					  expression="execution(* com.example.demolearn.other.spring.demo7.StudentJDBCTemplate.insert(..))"/>
		<aop:advisor advice-ref="txAdvice" pointcut-ref="createOperation"/>
	</aop:config>


	<!-- Definition for studentJDBCTemplate bean -->
	<bean id="studentJDBCTemplate"
		  class="com.example.demolearn.other.spring.demo7.StudentJDBCTemplate">
		<property name="dataSource" ref="dataSource"/>
	</bean>

</beans>

public interface StudentDAO {
	void insert();
}




public class StudentJDBCTemplate implements StudentDAO {
	private DataSource dataSource;
	private JdbcTemplate jdbcTemplateObject;

	// 设置数据源
	public void setDataSource(DataSource dataSource){
		this.dataSource = dataSource;
		this.jdbcTemplateObject = new JdbcTemplate(dataSource);
	}

	@Override
	public void insert(){

		Integer age = 12;
		String name = "xiao5";
		String SQL = "insert into Student(name, age)values(?, ?)";
		jdbcTemplateObject.update(SQL, name, age);

		if(1 == 1){
			throw new RuntimeException("异常");
		}

		String SQL2 = "update Student set age = ? where id = ?";
		jdbcTemplateObject.update(SQL2, 21, 25);

	}
}


public class JDCB1 {
	public static void main(String[] args){
		ApplicationContext context = new ClassPathXmlApplicationContext("./other/JDBC3.xml");
		StudentDAO dao =(StudentDAO)context.getBean("studentJDBCTemplate");
		dao.insert();

	}
}

在这里插入图片描述

4.1.4、声明式2

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

5、接口

5.1、PlatformTransactionManager接口

在这里插入图片描述

在这里插入图片描述

5.2、TransactionDefinition 接口

public interface TransactionDefinition {
   int getPropagationBehavior();
   int getIsolationLevel();
   String getName();
   int getTimeout();
   boolean isReadOnly();
}

在这里插入图片描述

5.3、TransactionStatus 接口

public interface TransactionStatus extends SavepointManager {
   boolean isNewTransaction();
   boolean hasSavepoint();
   void setRollbackOnly();
   boolean isRollbackOnly();
   boolean isCompleted();
}

在这里插入图片描述

6、获取当前Spring事务

6.1、步骤

  1. 获取当前线程绑定的事务上下文
  2. 判断是否存在事务上下文
  3. 获取当前事务

6.2、代码和测试

// 步骤1：获取当前线程绑定的事务上下文
String transactionName = TransactionSynchronizationManager.getCurrentTransactionName();
System.out.println("当前事务上下文名称：" + transactionName);

// 步骤2：判断是否存在事务上下文，如果当前线程没有绑定事务上下文，那么说明当前没有正在执行的事务。
boolean hasTransactionContext = TransactionSynchronizationManager.isActualTransactionActive();
System.out.println("是否存在事务上下文：" + hasTransactionContext);

// 步骤3：获取当前事务，TransactionStatus对象包含了事务的各种状态和属性。
TransactionStatus transactionStatus = TransactionAspectSupport.currentTransactionStatus();
System.out.println("当前事务状态：" + transactionStatus);

在这里插入图片描述

勤径苦舟
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring中TransactionTemplate 简单灵活的事务配置及使用
wang0928007的专栏
05-17 3万+
在一般的交易类程序中会频繁的使用事务来约束重要或关键的动作，已保证交易行为的整体性和一致性。 下例中是在Spring框架下中使用JDBC连接数据库的事务示例。 1.配置文件内容  数据源、事务的底层配置 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/20
ssm-spring-part.rar
12-19
- **面向切面编程（Aspect-Oriented Programming, AOP）**：Spring支持AOP，允许开发者定义横切关注点，如日志、事务管理，然后将其编织到业务逻辑中，使得代码更加模块化。 - **容器**：Spring容器（如...
Spring Boot 中的 TransactionTemplate 是什么，如何使用
IT徐师兄
10-13 6811
是Spring框架中的一个类，用于编程式地管理事务。它允许开发者在方法内定义事务范围，以确保在方法执行期间的数据库操作要么全部成功提交，要么全部回滚。提供了一种更灵活、更细粒度的事务控制方式，适用于各种场景。有时候，您可能需要自定义事务的逻辑，例如根据某些条件来决定是否提交或回滚事务。使用，您可以在execute方法内部编写自定义的逻辑，以满足特定需求。是Spring Boot中用于编程式事务管理的强大工具。它允许开发者更灵活地控制事务的边界，适用于多种应用场景，特别是需要细粒度控制事务的情况。通过。
编程事务管理
最新发布
qq_74842675的博客
05-06 185
编程式事务
Spring中事务管理TransactionTemplate和@Transactional注解
weixin_45817985的博客
02-13 423
Spring中事务管理TransactionTemplate和@Transactional注解
使用TransactionTemplate
关注J2EE
12-28 2391
 使用TransactionTemplate2008年04月24日 星期四 14:30----------------------------------------------------------------------------------------------------------Spring编程式事务管理直接采用JDBC操作数据库使用Tra
Spring的事务管理入门：编程式事务管理（TransactionTemplate）！！！
事后诸葛亮的程序人生（微信：zq9017197）
04-13 3万+
<br />Spring可以支持编程式事务和声明式事务。<br />Spring使用事务管理器，每个不同平台的事务管理器都实现了接口：PlatformTransactionManager<br />此接口是事务管理的核心，提供了三个需要实现的函数：<br />commit(TransactionStatus status) ; getTransaction(TransactionDefinition definition) ; rollback(TransactionStatus statu
spring-framework-4.3.30.RELEASE-dist.zip
01-07
2. **AOP**：提供面向切面编程的支持，允许开发者定义横切关注点，如日志、事务管理等，实现代码的解耦。 3. **MVC框架**：Spring Web MVC为构建基于HTTP的服务提供了强大的支持，包括模型-视图-控制器的设计模式、...
spring-framework-4.3.29.RELEASE.zip
05-25
- **反应式编程支持**：Spring 4.3引入了对Reactor的支持，为未来的反应式编程模式打下基础。 - **HTTP/2支持**：Spring MVC 4.3开始支持HTTP/2，提升了Web应用的性能。 4. **文档资源** - **spring-framework-...
spring-framework-4.3.30.RELEASE-docs.zip
01-07
Spring框架是Java开发中的核心工具，它为构建高质量的企业级应用程序提供了全面的基础设施。4.3.30.RELEASE是Spring框架的一个稳定版本，带来了丰富的功能和改进。本文将深入探讨Spring框架4.3.30.RELEASE的主要特性...
SpringBoot中进行事务回滚的方法
xiaogaotongxue__的博客
04-03 3987
Springboot中的事务回滚
Spring——事务注解@Transactional【建议收藏】
娜娜米的博客
07-18 3万+
在某些业务场景下，如果一个请求中，需要同时写入多张表的数据或者执行多条sql，为了保证操作的原子性（要么同时成功，要么同时失败），避免数据不一致的情况，我们一般都会用到事务；Spring框架下，我们经常会使用@Transactional注解来管理事务； 本篇介绍Spring的事务注解@Transactional相关的知识，包括事务简介、事务隔离级别、Spring声明式事务实现原理、事务的传播行为、@Transactional的用法及注意事项等，属于Spring的常用注解之一，需要掌握相关知识点；...
使用spring的TransactionTemplate操作数据库事务
zhangbeizhen18的博客
01-03 1721
场景:使用spring的TransactionTemplate操作数据库事务 1.事务操作过程 /**事务操作过程*/ @SuppressWarnings("unchecked") public static void doTransaction(){ /**1.创建事务管理器*/ DataSourceTransactionManager manager = ne...
spring事务
每天都充一点电
10-16 1338
sring事务
SpringBoot2异常处理回滚事务详解(自动回滚/手动回滚/部分回滚）
热门推荐
zzhongcy的专栏
11-04 4万+
1 问题背景 有时候，我们总是需要再SpringBoot2中对一个Service方法做一个完整的事务，发现异常时，进行回滚，然后又能返回错误信息。 事务定义 事务，就是一组操作数据库的动作集合。事务是现代数据库理论中的核心概念之一。如果一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多...
Spring事务——查看事务id
u010266988的博客
03-11 1万+
今天同事遇到一个问题：在使用Spring的事务管理时，开启了一个事务，接着在内部开启了两个传播模式为嵌入（PROPAGATION_NESTED）的事务，想看下这三个事务的id是否一致，但是查了半天也没查到Spring怎么获取事务id。 这里提供两个思路，不知到对不对。 1 使用MySQL的事务id 既然Spring的事务最终还是要看MySQL，那我们不如直接去MySQL里查询事务id： ...
spring@Transactional /TransactionTemplate开发周总结
u010214773的博客
03-11 1930
spring事务的使用，有三种方式。 1】.@Transactional注解 使用该注解，必需要在spring管理的bean 中使用，可使用在类/方法上。需要注意：方法包含try ..catch ，该注解失效。以及多线程下，该注解失效。一般用在dao层或者使用mybatis，就用在mapper调用的service层。 2】.TransactionTemplate（使用此方法，注意别嵌套，容易出二次异常unexpectedrollbackexception） 多线程以及try catch 中可以使用该
Spring 事务
Dgs的博客
05-19 937
一、事务的概念 什么是事务？事务是一些sql序列的集合，是多条sql，作为一个整体执行 mysql执行事务 beginTransaction 开启事务 insert select update endTransaction 事务结束 什么情况下需要使用事务？ 一个操作需要多条SQL语句一起完成，操作才能成功 二、在程序中事务在哪说明 在service（业务类）的public方法上面，需要说明事务 三、事务管理器 1、不同的数据库访.
spring-boot-starter-jpa
04-17
4. 数据库操作：spring-boot-starter-jpa提供了一组简单易用的API，可以进行数据库的增删改查操作，支持事务管理。 5. 查询语言支持：可以使用JPQL（Java Persistence Query Language）或者原生SQL进行复杂查询操作...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值