Spring中的编程式、声明式事务

已于 2024-09-29 10:24:48 修改
阅读量787 收藏 30
点赞数 30
分类专栏： Spring Framework 深入探索 文章标签： spring 数据库 spring boot
于 2024-09-26 16:06:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44929475/article/details/142559556
版权

1. 事务

        事务（Transaction）是数据库管理系统中的一个重要概念，它是一个原子性的数据库操作序列。原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）和持久性（Durability）是事务必须具备的四个核心特性，通常简称为ACID特性。

  • 原子性（Atomicity）：事务中的所有操作要么全部执行成功，要么全部失败并回滚到操作之前的状态。这意味着，事务内的操作是不可分割的。

  • 一致性（Consistency）：事务必须确保数据库从一个一致性状态转换到另一个一致性状态。一致性状态意味着数据库中的数据应满足完整性约束和业务规则。

  • 隔离性（Isolation）：当多个事务并发执行时，它们之间的操作应该相互隔离。事务的隔离级别决定了事务操作的可见性和其他事务的干扰程度。

  • 持久性（Durability）：一旦事务被提交（Commit），它对数据库所做的修改应该是永久性的。即使系统崩溃，事务的结果也应该被保存。

        在Spring框架中，事务管理是一个核心功能，它允许开发者以声明式或编程式的方式来处理事务，从而确保数据库操作的ACID特性。Spring的事务管理机制是基于代理模式和AOP（面向切面编程）的，这使得事务管理更加灵活和透明。

1.1 Spring事务管理的关键概念

  • PlatformTransactionManager：这是Spring事务管理的核心接口，负责抽象出不同事务管理器的共同操作。根据底层数据访问技术的不同，Spring提供了不同的实现，如DataSourceTransactionManager、HibernateTransactionManager和JpaTransactionManager。

  • TransactionDefinition：这个接口定义了事务的属性，包括传播行为、隔离级别、超时时间等。

  • TransactionStatus：这是一个对象，代表了当前事务的状态，它可以被用来查询事务的当前状态，或者控制事务的执行（如设置回滚标志）。

  • TransactionCallback 和 TransactionTemplate：这是编程式事务管理的关键类。TransactionTemplate是一个模板类，它提供了执行事务的方法，而TransactionCallback是一个回调接口，用于执行实际的业务逻辑。

  • @Transactional 注解：这是声明式事务管理的核心，可以应用于类或方法上。它定义了事务的边界和属性，Spring容器在运行时会根据这些注解来自动管理事务。

1.2 Spring事务管理的工作流

  1.  获取事务：Spring通过PlatformTransactionManager获取当前线程的事务。

  2.  事务传播：根据TransactionDefinition的传播行为，Spring决定是创建一个新的事务，还是加入现有的事务。

  3.  执行业务逻辑：在事务的保护下执行业务逻辑。

  4.  事务提交或回滚：如果业务逻辑执行成功，则提交事务；如果发生异常，则根据配置决定是否回滚事务。

  5.  释放资源：无论事务是否成功，Spring都会释放事务资源。

2. 实例

JDK

8

Maven

3.6

SpringBoot

2.7.12

2. 1 环境搭建

2.1.1 添加依赖
<dependencies>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.12</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <version>2.7.12</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.13.2</version>
        <scope>test</scope>
    </dependency>
    
    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.32</version>
    </dependency>
    <dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>2.1.4</version>
    </dependency>

    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.26</version>
    </dependency>
</dependencies>

 注：更换依赖版本需要注意依赖冲突问题

2.1.2 MySQL库表创建
user表

CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(255) DEFAULT NULL,
  `iphone` varchar(128) DEFAULT NULL,
  `money` decimal(6,2) DEFAULT NULL,
  `address` varchar(128) DEFAULT NULL,
  `password` varchar(32) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

order表
CREATE TABLE `order` (
  `id` int NOT NULL AUTO_INCREMENT,
  `user_id` int DEFAULT NULL,
  `name` varchar(128) DEFAULT NULL,
  `number` int DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci

注：库表结构不一定非要按照这样，符合逻辑即可。

2.1.3 application.yml
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://116.198.242.56:13306/transaction?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    hikari:
      minimum-idle: 5
      maximum-pool-size: 20
      auto-commit: true
      idle-timeout: 30000
      pool-name: DatebaseHikariPool
      max-lifetime: 1800000
      connection-timeout: 30000
      type: com.zaxxer.hikari.HikariDataSource

server:
  port: 8081

mybatis:
  mapper-locations: classpath:/mapper/*.xml

2.2 工程结构

project-root/
|-- main/
|   |-- java/
|   |   |-- com/
|   |   |   | -- xiaokai/
|   |   |       |-- TransactionApplication.java
|   |   |       |-- service/
|   |   |       |   |-- impl/
|   |   |       |   |   |-- IOrderServiceImpl.java
|   |   |       |   |   |-- IUserServiceImpl.java
|   |   |       |   |   `-- (其他 service impl 类)
|   |   |       |   `-- IOrderService.java
|   |   |       |   `-- IUserService.java
|   |   |       `-- tran/
|   |   |           |-- AnnotationService.java
|   |   |           |-- config/
|   |   |               |-- TransactionConfig.java
|   |   |           |-- entity
|   |                   |-- OrderEntity.java
|   |                   `-- UserEntity.java
|   |   |           |-- repository
|   |                   |-- OrderMapper.java
|   |                   `-- UserMapper.java
|   |-- resources/
|   |   |-- mapper/
|   |   |   |-- order_mapper.xml
|   |   |   `-- user_mapper.xml
|   |   `-- application.yml
|-- test/
|   |-- java/
|   |   |-- com/
|   |       `-- TransactionTest.java

注：工程结构只是提供一个版本，可以根据所需更换类名或者所在包。

2.3 编程式事务

2.3.1 config
package com.xiaokai.tran.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import org.springframework.transaction.support.TransactionTemplate;

import javax.sql.DataSource;

@Configuration
@EnableTransactionManagement
public class TransactionConfig {

    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
        DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
        transactionManager.setDataSource(dataSource);
        return transactionManager;
    }

    @Bean
    public TransactionTemplate transactionTemplate(PlatformTransactionManager transactionManager) {
        return new TransactionTemplate(transactionManager);
    }
}

注：有的版本不需要这个配置bean类。

2.3.2 实体类
/**
 * Author:yang
 * Date:2024-09-26 10:52
 * Description:订单实体类
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class OrderEntity {

    private Integer userId;

    private String name;

    private Integer number;
}


/**
 * Author:yang
 * Date:2024-09-26 10:55
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class UserEntity {

    private int id;

    private String name;

    private String password;

    private String iphone;

    private String address;

    private int money;

}
2.3.3 ORM交互接口
/**
 * Author:yang
 * Date:2024-09-26 11:00
 */
@Mapper
public interface OrderMapper {

    int insertOrder(OrderEntity order);
}

/**
 * Author:yang
 * Date:2024-09-26 10:46
 */
@Mapper
public interface UserMapper {

    Integer insertUser(UserEntity userEntity);

}
2.3.4 mapper.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.xiaokai.tran.repository.UserMapper">

    <insert id="insertUser" parameterType="com.xiaokai.tran.entity.UserEntity" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO user (name, iphone, money, address, password)
        VALUES (#{name}, #{iphone}, #{money}, #{address}, #{password})
    </insert>
</mapper>


<?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.xiaokai.tran.repository.OrderMapper">
    <insert id="insertOrder" parameterType="com.xiaokai.tran.entity.OrderEntity" useGeneratedKeys="true">
        insert into `order` (`user_id`, `name`, `number`)
        values (#{userId},
                #{name},
                #{number})
    </insert>
</mapper>
2.3.5 启动类
package com.xiaokai;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.transaction.annotation.EnableTransactionManagement;

/**
 * Author:yang
 * Date:2024-09-25 9:55
 */
@SpringBootApplication
@EnableTransactionManagement
public class TransactionApplication {
    public static void main(String[] args) {
        SpringApplication.run(TransactionApplication.class, args);
    }
}
2.3.6 测试
package com;

import com.xiaokai.TransactionApplication;
import com.xiaokai.service.IOrderService;
import com.xiaokai.service.IUserService;
import com.xiaokai.service.impl.IOrderServiceImpl;
import com.xiaokai.tran.entity.OrderEntity;
import com.xiaokai.tran.entity.UserEntity;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.support.TransactionTemplate;

/**
 * Author:yang
 * Date:2024-09-26 11:09
 */
@SpringBootTest(classes = {TransactionApplication.class})
@Slf4j
@RunWith(SpringRunner.class)
public class TransactionTest {


    @Autowired
    private IOrderService orderService;
    @Autowired
    private IUserService userService;
    
    // 注入编程式事务管理bean
    @Autowired
    private TransactionTemplate transactionTemplate;

    @Test
    public void test_program() {
        log.info("test_program_transaction");
        transactionTemplate.execute(status -> {
            try {
                // 添加用户
                UserEntity user = new UserEntity().builder()
                        .name("xiaokai")
                        .iphone("13812345678")
                        .money(1000)
                        .address("beijing")
                        .build();
                Integer countUser = userService.createUser(user);
                if (countUser != 1) {
                    log.error("createUser error count: {}", countUser);
                }else {
                    log.info("createUser count: {},user: {}", countUser, user.toString());
                }
                // 创建异常，事务回滚
                int i = 1 / 0;

                OrderEntity order = new OrderEntity().builder()
                        .userId(user.getId())
                        .name("xiaokai")
                        .number(10)
                        .build();
                Integer countOrder = orderService.createOrder(order);
                if (countOrder != 1) {
                    log.error("createOrder count: {}", countOrder);
                }else {
                    log.info("createOrder count: {},order: {}", countOrder, order.toString());
                }
            } catch (Exception e) {
                status.setRollbackOnly();
                log.error("transaction rollback", e);
            }
            return 1;
        });
        log.info("test_program_transaction end");
    }
}

结果1：

2024-09-26 15:18:20.122  INFO 26420 --- [           main] com.TransactionTest                      : test_program_transaction
2024-09-26 15:18:20.124  INFO 26420 --- [           main] com.zaxxer.hikari.HikariDataSource       : DatebaseHikariPool - Starting...
2024-09-26 15:18:20.493  INFO 26420 --- [           main] com.zaxxer.hikari.HikariDataSource       : DatebaseHikariPool - Start completed.
2024-09-26 15:18:20.635  INFO 26420 --- [           main] com.TransactionTest                      : createUser count: 1,user: UserEntity(id=6, name=xiaokai, password=null, iphone=13812345678, address=beijing, money=1000)
2024-09-26 15:18:20.637 ERROR 26420 --- [           main] com.TransactionTest                      : transaction rollback

java.lang.ArithmeticException: / by zero

        由于有异常终止了终止了后部分代码，在捕获异常后回滚事务。根据日志，user表中已经插入了一条数据id=6，查看表数据：

        没有找到该数据是由于事务回滚了。 

结果2：注释 int i = 1 / 0;

test_program_transaction
DatebaseHikariPool - Starting...
DatebaseHikariPool - Start completed.
createUser count: 1,user: UserEntity(id=7, name=xiaokai, password=null, iphone=13812345678, address=beijing, money=1000)
createOrder count: 1,order: OrderEntity(userId=7, name=xiaokai, number=10)
test_program_transaction end

        没有异常抛出，两条数据均插入成功，事务commit。 

2.4 声明式事务

2.4.1 添加注解

        在启动类上添加 @EnableTransactionManagement 注解以及在所需要执行事务的方法或者类上添加 @Transactional 注解

2.4.2 添加事务服务
package com.xiaokai.tran;

import com.xiaokai.service.IOrderService;
import com.xiaokai.service.IUserService;
import com.xiaokai.tran.entity.OrderEntity;
import com.xiaokai.tran.entity.UserEntity;
import com.xiaokai.tran.repository.UserMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;


/**
 * Author:yang
 * Date:2024-09-25 14:40
 */
@Service
@Transactional
@Slf4j
public class AnnotationService {

    @Autowired
    private IUserService userService;

    @Autowired
    private IOrderService orderService;

    public void statementTransaction() {
        // 添加用户
        UserEntity user = new UserEntity().builder()
                .name("xiaokai")
                .iphone("13812345678")
                .money(1000)
                .address("beijing")
                .build();
        Integer countUser = userService.createUser(user);
        if (countUser != 1) {
            log.error("createUser error count: {}", countUser);
        } else {
            log.info("createUser count: {},user: {}", countUser, user.toString());
        }
        // 创建异常
        //int i = 1 / 0;
        OrderEntity order = new OrderEntity().builder()
                .userId(user.getId())
                .name("xiaokai")
                .number(10)
                .build();
        Integer countOrder = orderService.createOrder(order);
        if (countOrder != 1) {
            log.error("createOrder count: {}", countOrder);
        } else {
            log.info("createOrder count: {},order: {}", countOrder, order.toString());
        }
    }

}
2.4.3 测试
@Test
public void test_statement() {
    log.info("test_statement_transaction");
    annotationService.statementTransaction();
    log.info("test_statement_transaction end");
}

        测试结果可以参考编程式事务结果。

注：在声明式事务管理中，@Transactional注解可以配置多种事务属性，如propagation（传播行为）、isolation（隔离级别）、timeout（超时时间）、readOnly（只读标志）等，以满足不同的业务需求。

3. 传播机制

参考另一篇文章：Spring事务传播机制

4. 事务失效

参考另一篇文章：Spring事务常见失效场景

菜鸟起航ing
关注
专栏目录
【Spring笔记08】Spring中的事务（编程式、声明式）
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
06-01 443
这篇文章，主要介绍Spring中的两种事务，编程式事务和基于XML方式的声明式事务。 目录 一、Spring中事务 1.1、什么是事务 1.2、Spring两种事务 （1）数据源配置 1.3、编程式事务 1.4、声明式事务 （1）XML中添加【tx】命名空间 （2）配置事务管理器 （3）配置事务通知 （4）配置事务切面 （5）编写事务处理类方法 （6）编写测试类 一、Spring中事务 1.1、什么是事务 事务，是指将很多件事情看成一个整体，这些事情要么全部执行成功，要么.
Spring事务处理-编程式事务和声明式事务
义臻的博客
08-11 3839
Spring框架提供编程式事务处理和声明式事务处理。 编程式事务处理就是指在业务代码中利用Spring框架提供的一些类进行事务处理。 声明式事务处理就是指在xml配置文件或注解的方式声明对某个类方法进行事务处理。 通过以上的描述可以大概知道编程式事务处理是以侵入的方式完成，代码的耦合度高一些。而声明式事务处理耦合度低，或者说基本没有耦合。 编程式事务管理是基于Spring框架底层的 API来完成的...
spring编程式事务实现
07-30
演示了spring编程式事务的实现，通过TransactionTemplate模板进行事务控制
Spring中的事务详解
最新发布
努力分享一些干货内容，纯干货，没有一点水
07-19 1291
但是随着事务越来越大，执行时间也会变长，就需要将这个大事务拆分成多个事务，如果确保这个事务能够拆分成多个事务，就需要指定Spring的事务传播行为。比如，在用户注册时候，需要记录注册日志，这时候可以将记录日志的操作单独划分为一个事务，而注册是另一个单独的事务，可以将保存日志的方法指定。事务隔离级别，即数据库中事务隔离级别，指的是一个事务对数据的修改与另一个并行的事务的隔离程度。事务传播行为指，当一个事务方法被另一个事务方法调用时，这个事务方法应该如何进行，是应该加入现有事务，还是应该启动一个新事务。
【第九章】 Spring的事务 之 9.3 编程式事务 ——跟我学spring3
jinnianshilongnian的专栏
03-06 424
9.3  编程式事务 9.3.1  编程式事务概述        所谓编程式事务指的是通过编码方式实现事务，即类似于JDBC编程实现事务管理。        Spring框架提供一致的事务抽象，因此对于JDBC还是JTA事务都是采用相同的API进行编程。   java代码： Connection conn = null; UserTransaction tx = nu...
【Spring】-编程式事务和声明式事务
一起加油吧~
04-17 2568
PlatformTransactionManager 事务管理器TransactionDefinition 事务属性优点：与业务逻辑分离：声明式事务管理将事务管理逻辑从业务代码中分离出来，使得业务逻辑更清晰，降低了代码的耦合性。配置简单：通过注解或XML配置，可以简单地定义事务的传播行为、隔离级别等属性，而无需在每个业务方法中编写重复的事务管理代码。易于维护：由于事务管理逻辑集中在配置中，易于维护和修改，提高了代码的可读性和可维护性。提高一致性。
Spring的编程式事务和声明式事务
酸酸酱的博客
10-12 569
spring事务管理的API platfformTransactionManager 平台事务管理器 平台事务管理器： 接口 是spring用于管理事务的真正的对象 DataSourceTransactionManager: 底层使用JDBC管理事务 HibernateTransactionManager: 底层使用Hibernate管理事务 TransactionDefinition 事务定...
spring编程式事务
Onely丶初
09-06 184
Spring （jdbc事务管理） Spring 实现编程式事务，依赖于2大类，分别是 DataSourceTransactionManager(事务管理器),与 TransactionTemplate（事务模板）。下面详细介绍 Spring是如何通过该类实现事务管理,我这里模拟转账业务 首先给所有准备工作做好，导入所有需要的 jar 1:建立数据库连接资源文件,我这里是 mysql 的 ...
Spring的编程式事务和声明式事务详解
08-29
Spring框架提供了两种事务管理机制：编程式事务和声明式事务。编程式事务是通过编写代码来管理事务，声明式事务则是通过配置文件或注解来管理事务。 事务属性 Spring的事务属性是通过TransactionDefinition接口...
Spring编程式和声明式事务实例讲解小结
08-25
Spring编程式和声明式事务实例讲解小结 本文主要介绍了Spring编程式和声明式事务实例讲解小结，涵盖了Spring事务管理的两种方式：编程式事务管理和声明式事务管理。编程式事务管理通过Transaction Template手动管理...
全面分析 Spring 的编程式事务管理及声明式事务管理
04-18
1. **基于XML的声明式事务管理**: 在Spring的配置文件中，我们可以通过`<tx:advice>`、`<aop:config>`等元素定义事务的边界，指定哪些方法需要在事务中运行。 2. **基于注解的声明式事务管理**: 使用@Transactional...
spring事务管理几种方式代码实例
08-22
spring事务管理几种方式代码实例：涉及编程式事务，声明式事务之拦截器代理方式、AOP切面通知方式、AspectJ注解方式，通过不同方式实例代码展现，总结spring事务管理的一般规律，从宏观上加深理解spring事务管理特性。
spring 自定义事务管理器，编程式事务，声明式事务@Transactional使用
07-13
本教程将深入探讨如何在Spring中实现自定义事务管理器、编程式事务处理以及声明式事务`@Transactional`的使用。 首先，让我们了解事务管理的基本概念。事务是一组数据库操作，这些操作要么全部执行，要么全部回滚，...
Spring编程式事务
weixin_43381142的博客
11-02 618
事务是spring框架中一个核心的模块，事务的ACID特性想必对于学习java的同学来说都不陌生，对于spring，实现事务的底层原理其实很简单，就是通过AOP代理进行实现，而实现spring的AOP更底层的，就是使用反射机制完成的； 举例来说，当你的方法上标注了@Service之后，spring怎么知道你这个类会被纳入到整个bean的容器中进行管理呢？如果在这个类下面的某个方法上面加了@Transactionnal注解，spring怎么知道要为你的这个方法开启一个事务管理器呢？说到底，反射在这里就派上用场
Spring 编程式事务 (Spring 重点)
q322359的博客
01-22 1121
概述 Spring ⼿动操作事务和 MySQL操作事务类似,有 3 个重要操作步骤： • 开启事务(获取事务) • 提交事务 • 回滚事务
Spring框架 编程式事务
moyuxi_的博客
10-30 3116
spring编程式事务的实现，仅为个人理解，如有错误，请大佬指正。万分感谢
【Spring】Spring 事务之编程式事务
lucashu的博客
08-02 817
本文目录事务概述 事务概述 数据库事务(Database Transaction) ，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。 事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。通过将一组相关操作组合为一个要么全部成功要么全部失败的单元，可以简化错误恢复并使应用程序更加可靠。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处
Spring - 事务之编程式
牧码的博客
11-25 479
1、编程式和声明式事务的区别 Spring提供了对编程式事务和声明式事务的支持，编程式事务允许用户在代码中精确定义事务的边界，而声明式事务（基于AOP）有助于用户将操作与事务规则进行解耦。 简单地说，编程式事务侵入到了业务代码里面，但是提供了更加详细的事务管理；而声明式事务由于基于AOP，所以既能起到事务管理的作用，又可以不影响业务代码的具体实现。 2、如何实现编程式事务？ Sprin...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值