Spring-声明式事务

最新推荐文章于 2023-08-26 17:20:11 发布
最新推荐文章于 2023-08-26 17:20:11 发布
阅读量367 收藏
点赞数
分类专栏： Spring 文章标签： spring java 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44981526/article/details/125092269
版权

Spring-声明式事务

1.事务分类

● 分类:

  1. 编程式事务: 示意代码, 传统方式
Connection connection = JdbcUtils.getConnection();
try {
    //1. 先设置事务不要自动提交
    connection.setAutoCommint(false);
    //2. 进行各种 crud 
    //多个表的修改，添加 ，删除 
    //3. 提交
    connection.commit(); 
	} catch (Exception e) {
    //4. 回滚
    conection.rollback();
}
  1. 声明式事务

2.声明式事务-使用实例

1.需求说明-用户购买商品
  1. 通过商品 id 获取价格.
  2. 购买商品(某人购买商品，修改用户的余额.)
  3. 修改库存量
  4. 其实大家可以看到，这时，我们需要涉及到三张表商品表，用户表，商品存量表。 应该使用事务处理
2.解决方案分析
  1. 使用传统的编程事务来处理，将代码写到一起[缺点: 代码冗余，效率低，不利于扩展, 优 点是简单，好理解]
Connection connection = JdbcUtils.getConnection();
try {
    //1. 先设置事务不要自动提交 connection.setAutoCommit(false);
    //2. 进行各种 crud 
    //多个表的修改，添加 ，删除 select from 商品表 => 获取价格 修改用户余额 update ... 修改库存量 update 
    //3. 提交 
    connection.commit(); 
} catch (Exception e) { 
    //4. 回滚 
    conection.rollback();
}
  1. 使用 Spring 的声明式事务处理， 可以将上面三个子步骤分别写成一个方法，然后统一 管理

[这个是 Spring 很牛的地方，在开发中使用的很多，优点是无代码冗余，效率高，扩展方便， 缺点是理解较困难]==> 底层使用 AOP (动态代理+动态绑定+反射+注解)

3.声明式事务使用-代码实现
  1. 先创建商品系统的数据库和表
-- 演示声明式事务创建的表 
-- 用户账户表
CREATE TABLE `user_account`( 
user_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, 
user_name VARCHAR(32) NOT NULL DEFAULT '', 
money DOUBLE NOT NULL DEFAULT 0.0 
)CHARSET=utf8; 
INSERT INTO `user_account` VALUES(NULL,'张三', 1000); 
INSERT INTO `user_account` VALUES(NULL,'李四', 2000); 

-- 商品表
CREATE TABLE `goods`(
goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT,
goods_name VARCHAR(32) NOT NULL DEFAULT '',
price DOUBLE NOT NULL DEFAULT 0.0
)CHARSET=utf8 ;
INSERT INTO `goods` VALUES(NULL,'小风扇', 10.00); 
INSERT INTO `goods` VALUES(NULL,'小台灯', 12.00); 
INSERT INTO `goods` VALUES(NULL,'可口可乐', 3.00);

-- 商品库存表
CREATE TABLE `goods_amount`(
goods_id INT UNSIGNED PRIMARY KEY AUTO_INCREMENT, 
goods_num INT UNSIGNED DEFAULT 0 
)CHARSET=utf8 ;
INSERT INTO `goods_amount` VALUES(1,200);
INSERT INTO `goods_amount` VALUES(2,20); 
INSERT INTO `goods_amount` VALUES(3,15);

GoodsDao

@Repository //将 GoodsDao-对象 注入到spring容器
public class GoodsDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    /**
     * 根据商品id,返回对应的价格
     * @param id
     * @return
     */
    public Float queryPriceById(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    /**
     * 修改用户的余额 [减少用户余额]
     * @param user_id
     * @param money
     */
    public void updateBalance(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    /**
     * 修改商品库存 [减少]
     * @param goods_id
     * @param amount
     */
    public void updateAmount(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }
}

GoodsService

@Service //将 GoodsService对象注入到spring容器
public class GoodsService {

    //定义属性GoodsDao
    @Resource
    private GoodsDao goodsDao;

    //编写一个方法，完成用户购买商品的业务, 这里主要是讲解事务管理

    /**
     * @param userId  用户id
     * @param goodsId 商品id
     * @param amount  购买数量
     */
    public void buyGoods(int userId, int goodsId, int amount) {

        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(goodsId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);

        System.out.println("用户购买成功~");

    }

    /**
     * @Transactional 注解解读
     * 1. 使用@Transactional 可以进行声明式事务控制
     * 2. 即将标识的方法中的，对数据库的操作作为一个事务管理
     * 3. @Transactional 底层使用的仍然是AOP机制
     * 4. 底层是使用动态代理对象来调用buyGoodsByTx
     * 5. 在执行buyGoodsByTx() 方法 先调用 事务管理器的 doBegin() , 调用 buyGoodsByTx()
     *    如果执行没有发生异常，则调用 事务管理器的 doCommit(), 如果发生异常 调用事务管理器的 doRollback()
     * @param userId
     * @param goodsId
     * @param amount
     */
    @Transactional
    public void buyGoodsByTx(int userId, int goodsId, int amount) {
        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);
        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);
        System.out.println("用户购买成功~");

    }
}

tx_ioc.xml

<?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:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!--配置要扫描的包-->
    <context:component-scan base-package="com.llp.spring.tx.dao"/>
    <context:component-scan base-package="com.llp.spring.tx.service"/>

    <!--引入外部的jdbc.properties文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置数据源对象-DataSoruce-->
    <bean class="com.mchange.v2.c3p0.ComboPooledDataSource" id="dataSource">
        <!--给数据源对象配置属性值-->
        <property name="user" value="${jdbc.user}"/>
        <property name="password" value="${jdbc.pwd}"/>
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
    </bean>

    <!--配置JdbcTemplate对象-->
    <bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
        <!--给JdbcTemplate对象配置dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置事务管理器-对象
    1. DataSourceTransactionManager 这个对象是进行事务管理-debug源码
    2. 一定要配置数据源属性，这样指定该事务管理器 是对哪个数据源进行事务控制
    -->
    <bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="transactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--配置启动基于注解的声明式事务管理功能-->
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>

测试

public class TxTest {

    @Test
    public void queryPriceByIdTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);

        Float price = goodsDao.queryPriceById(1);
        System.out.println("id=100 的price=" + price);
    }

    @Test
    public void updateBalance() {

        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);
        goodsDao.updateBalance(1, 1.0F);
        System.out.println("减少用户余额成功~");

    }

    @Test
    public void updateAmount() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsDao goodsDao = ioc.getBean(GoodsDao.class);
        goodsDao.updateAmount(1, 1);
        System.out.println("减少库存成功...");
    }

    //测试用户购买商品业务
    @Test
    public void buyGoodsTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsService goodsService = ioc.getBean(GoodsService.class);
        goodsService.buyGoods(1, 1, 1);
    }

    //测试用户购买商品业务
    @Test
    public void buyGoodsByTxTest() {
        //获取到容器
        ApplicationContext ioc =
                new ClassPathXmlApplicationContext("tx_ioc.xml");
        GoodsService goodsService = ioc.getBean(GoodsService.class);
        goodsService.buyGoodsByTx(1, 1, 1);//这里我们调用的是进行了事务声明的方法
    }
}
4.声明式事务机制-Debug

3.事务的传播机制

1.事务的传播机制说明

  1. 当有多个事务处理并存时，如何控制?

  2. 比如用户去购买两次商品(使用不同的方法), 每个方法都是一个事务，那么如何控制呢?

  3. 这个就是事务的传播机制，看一个具体的案例(如图)

    image-20220531223648239

2.事务传播机制种类

● 事务传播的属性/种类一览图

image-20220531225212609

● 事务传播的属性/种类机制分析，重点分析了 REQUIRED 和 REQUIRED_NEW 两种事务 传播属性, 其它知道即可(看上图)

image-20220531225257988

image-20220531225324659

● 事务的传播机制的设置方法

image-20220531225808675

● REQUIRES_NEW 和 REQUIRED 在处理事务的策略

image-20220531230022590

  1. 如果设置为 REQUIRES_NEW buyGoods2 如果错误，不会影响到 buyGoods()反之亦然，即它们的事务是独立的.
  2. 如果设置为 REQUIRED buyGoods2 和 buyGoods 是一个整体，只要有方法的事务错误，那么两个方法都不会执行成功.!
3.事务的传播机制-应用实例

GoodsDao新增第二套方法

    /**
     * 根据商品id,返回对应的价格
     * @param id
     * @return
     */
    public Float queryPriceById2(Integer id) {
        String sql = "SELECT price From goods Where goods_id=?";
        Float price = jdbcTemplate.queryForObject(sql, Float.class, id);
        return price;
    }

    /**
     * 修改用户的余额 [减少用户余额]
     * @param user_id
     * @param money
     */
    public void updateBalance2(Integer user_id, Float money) {
        String sql = "UPDATE user_account SET money=money-? Where user_id=?";
        jdbcTemplate.update(sql, money, user_id);
    }

    /**
     * 修改商品库存 [减少]
     * @param goods_id
     * @param amount
     */
    public void updateAmount2(Integer goods_id, int amount){
        String sql = "UPDATE goods_amount SET goods_num=goods_num-? Where goods_id=?";
        jdbcTemplate.update(sql, amount , goods_id);
    }

GoodsService

   @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void buyGoodsByTx(int userId, int goodsId, int amount) {


        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount(goodsId, amount);

        System.out.println("用户购买成功~");

    }


    /**
     * 这个方法是第二套进行商品购买的方法
     *
     * @param userId
     * @param goodsId
     * @param amount
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void buyGoodsByTx2(int userId, int goodsId, int amount) {


        //输出购买的相关信息
        System.out.println("用户购买信息 userId=" + userId
                + " goodsId=" + goodsId + " 购买数量=" + amount);

        //1.得到商品的价格
        Float price = goodsDao.queryPriceById2(userId);
        //2. 减少用户的余额
        goodsDao.updateBalance2(userId, price * amount);
        //3. 减少库存量
        goodsDao.updateAmount2(goodsId, amount);

        System.out.println("用户购买成功~");

    }

MultiplyService

@Service
public class MultiplyService {
    @Resource
    private GoodsService goodsService;


    /**
     * 1. multiBuyGoodsByTx 这个方法 有两次购买商品操作
     * 2. buyGoodsByTx 和 buyGoodsByTx2 都是声明式事务
     * 3. 当前buyGoodsByTx 和 buyGoodsByTx2 使用的传播属性是默认的 REQUIRED [这个含义老师前面讲过了
     *    即会当做一个整体事务进行管理 , 比如buyGoodsByTx方法成功，但是buyGoodsByTx2() 失败，会造成 整个事务的回滚
     *    即会回滚buyGoodsByTx]
     *
     * 4. 如果 buyGoodsByTx 和 buyGoodsByTx2 事务传播属性修改成 REQUIRES_NEW
     *    , 这时两个方法的事务是独立的，也就是如果 buyGoodsByTx成功 buyGoodsByTx2失败
     *    , 不会造成 buyGoodsByTx回滚.
     *
     */
    @Transactional
    public void multiBuyGoodsByTx() {

        goodsService.buyGoodsByTx(1, 1, 1);
        goodsService.buyGoodsByTx2(1, 1, 1);
    }
}

4.事务的隔离级别

1.事务隔离级别说明

image-20220531232343931

● 事务隔离级别说明

  1. 默认的隔离级别, 就是 mysql 数据库默认的隔离级别 一般为 REPEATABLE_READ
  2. 看源码可知 Isolation.DEFAULT 是 ：Use the default isolation level of the underlying datastore
  3. 查看数据库默认的隔离级别 SELECT @@global.tx_isolation
2.事务隔离级别的设置和测试
  1. 修改 GoodsService.java , 先测默认隔离级别，增加方法 buyGoodsByTxISOLATION()

image-20220601224758971

/**
 * 1. 在默认情况下 声明式事务的隔离级别是 REPEATABLE_READ
 * 2. 我们将buyGoodsByTxISOLATION的隔离级别设置为 Isolation.READ_COMMITTED
 * ,表示只要是提交的数据，在当前事务是可以读取到最新数据
 */
@Transactional(isolation = Isolation.READ_COMMITTED)
public void buyGoodsByTxISOLATION() {

    //查询两次商品的价格
    Float price = goodsDao.queryPriceById(1);
    System.out.println("第一次查询的price= " + price);

    Float price2 = goodsDao.queryPriceById(1);
    System.out.println("第二次查询的price= " + price2);

}
3.事务的超时回滚

● 基本介绍

  1. 如果一个事务执行的时间超过某个时间限制，就让该事务回滚。
  2. 可以通过设置事务超时回顾来实现

● 基本语法

image-20220601225640528

● 超时回滚-代码实现

/**
 * 1. @Transactional(timeout = 2)
 * 2. timeout = 2 表示 buyGoodsByTxTimeout 如果执行时间超过了2秒
 *    , 该事务就进行回滚.
 * 3. 如果你没有设置 timeout, 默认是 -1，表示使用事务的默认超时时间,
 *    或者不支持
 */
@Transactional(timeout = 2)
public void buyGoodsByTxTimeout(int userId, int goodsId, int amount) {
    //输出购买的相关信息
    System.out.println("用户购买信息 userId=" + userId
            + " goodsId=" + goodsId + " 购买数量=" + amount);
    //1.得到商品的价格
    Float price = goodsDao.queryPriceById2(userId);
    //2. 减少用户的余额
    goodsDao.updateBalance2(userId, price * amount);
    //模拟超时
    System.out.println("=====超时开始4s=====");
    try {
        //睡眠4秒
        Thread.sleep(4000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    System.out.println("=====超时结束4s=====");
    //3. 减少库存量
    goodsDao.updateAmount2(goodsId, amount);
    System.out.println("用户购买成功~");
}

测试方法

//测试timeout 属性
@Test
public void buyGoodsByTxTimeoutTest() {
    //获取到容器
    ApplicationContext ioc =
            new ClassPathXmlApplicationContext("tx_ioc.xml");
    GoodsService goodsService = ioc.getBean(GoodsService.class);

    goodsService.buyGoodsByTxTimeout(1,1,1);
}

image-20220601225900893

llp1110
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring--JdbcTemplate.pdf
01-02
spring中使用JdbcTemplate操作数据库crud，一图详解(脑图)
Spring JdbcTemplate（使用详解）
洛卡JAVA架构师每日分享Java架构师知识
05-19 5350
我们知道，JDBC 是 Java 提供的一种用于执行 SQL 语句的 API，可以对多种关系型数据库（例如 MySQL、Oracle 等）进行访问。 但在实际的企业级应用开发中，却很少有人直接使用原生的 JDBC API 进行开发，这是因为使用 JDBC API 对数据库进行操作十分繁琐，需要我们对每一步都做到“步步把控，处处关心”，例如我们需要手动控制数据库连接的开启，异常处理、事务处理、最后还要手动关闭连接释放资源等等。 Spring 提供了一个 Spring JDBC 模块，它对 JDBC API 进
JdbcTemplate_ 操作数据库(2)
17902的博客
11-20 223
JdbcTemplate 操作数据库（添加） 1、对应数据库创建实体类 public class User{ private String userId; private String username; private String ustatus; public void setUserId(String userId){ this.userId = userId; } public void setUsername(String username){ this username =
Spring 从入门到精通系列 11 —— Spring 中的 JdbcTemplate
秀岩的博客
06-02 735
本文针对 Spring 中的 JdbcTemplate 进行了分析，并实现对数据库的操作。 文章目录一、JdbcTemplate 概述二、JdbcTemplate 对象的创建三、JdbcTemplate 的应用3.1 JdbcTemplate 的简单使用3.2 JdbcTemplate 的增删改查3.2 在 Spring 中应用 JdbcTemplate3.2.1 编写 spring 的配置文件3.2.1 配置数据源3.2.3 持久层及其实现类3.2.4 测试方法 一、JdbcTemplate 概
【Spring6】| JdbcTemplate（Spring中的CRUD）
m0_61933976的博客
03-22 2832
【Spring6】| JdbcTemplate（Spring中的CRUD）
Spring声明式事务配置管理方法
03-02
发布于2013-5-6项目使用SSH架构，现在要添加Spring事务管理功能，针对当前环境，只需要添加Spring2.0AOP类库即可。添加方法：点击项目右键->BuildPath->Addlibrarys:打开AddLibraries对话框，然后选定...
Spring声明式事务
01-12
spring声明式事务实例 可复制修改使用。。。。。。。。。。
spring声明式事务.zip
08-19
spring声明式事务.zip
spring 声明式事务实现过程解析
08-25
主要介绍了spring 声明式事务实现过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Spring与Hibernate集成---声明式事务
03-24
NULL 博文链接：https://chenming47.iteye.com/blog/437199
Spring-JdbcTemplate
爱笑的boy的博客
06-01 526
Spring-JdbcTemplate
Java之Spring JdbcTemplate（一篇文章精通系列）
程序员猫爪
09-15 737
一、Spring JdbcTemplate基本使用 1、JdbcTemplate概述 它是spring框架中提供的一个对象， 是对原始繁琐的Jdbc API对象的简单封装。 spring框架为我们提供了很多的操作模板类。 例如： 操作关系型数据的JdbcTemplate和HibernateTemplate， 操作nosql数据库的RedisTemplate， 操作消息队列的JmsTemplate等等。 2、JdbcTemplate开发步骤 导入spring-jdbc和spring-tx坐标 创建数据库表和
【SSM直击大厂】第七章：Spring JdbcTemplate基础详解
专注Spring、SSM、数据结构与算法、蓝桥杯领域创作者
03-31 3602
🙊🙊作者主页：求不脱发 📔📔 精选专栏：SSM直击大厂 📋📋精彩摘要：JdbcTemplate JdbcTemplate 是 Spring JDBC 核心包（core）中的核心类，它可以通过配置文件、注解、Java 配置类等形式获取数据库的相关信息，实现了对 JDBC 开发过程中的驱动加载、连接的开启和关闭、SQL 语句的创建与执行、异常处理、事务处理、数据类型转换等操作的封装。 💞💞觉得文章还不错的话欢迎大家点赞👍➕收藏⭐️➕评论💬支持博主🤞 📚目录 📖Spring JdbcTemplat...
Spring框架|JdbcTemplate介绍
热门推荐
匿名攻城狮
02-02 7万+
文章目录一、JdbcTemplate 概述二、创建对象的源码分析三、JdbcTemplate操作数据库 一、JdbcTemplate 概述 在之前的web学习中，学习了手动封装JDBCtemplate，其好处是通过(sql语句+参数)模板化了编程。而真正的JDBCtemplete类，是Spring框架为我们写好的。 它是 Spring 框架中提供的一个对象，是对原始 Jdbc API 对象的简单...
Spring——JdbcTemplate
前尘忆梦的博客
12-13 1252
JdbcTemplate 1、JdbcTemplate（概念和准备） 1.1、什么是 JdbcTemplate？ Spring 框架对 JDBC 进行封装，使用 JdbcTemplate 方便实现对数据库操作。 1.2、准备工作 （1）引入相关 jar 包 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-dsl09qA6-1639402734125)(素材/所需要的依赖.png)] （2）在 spring 配置文件配置数据库连接池 <!-- 数据库连接池 --> &
SpringJDBC的JdbcTemplate
ZERO
12-03 472
转载自： http://blog.csdn.net/dyllove98/article/details/7772463 JdbcTemplate主要提供以下五类方法：       execute方法：可以用于执行任何SQL语句，一般用于执行DDL语句；       update方法及batchUpdate方法：update方法用于执行新增、修改、删除等语句；batchUpdate方法用于
Spring系列六：JdbcTemplate
你好, 我在学java的博客
08-15 560
JdbcTemplate
spring学习笔记 （4）使用spring jdbc模块
weixin_42640037的博客
06-03 1482
实体类与对应dao层的创建
springboot整合jdbctemplate教程
最新发布
沐雨橙风ιε的博客
08-26 1512
springboot整合jdbctemplate教程
Spring的声明式事务处理
07-28
Spring的声明式事务处理是指通过在配置文件中声明的方式来处理事务。在Spring配置文件中，可以使用声明式的方式来代替代码式的处理事务。声明式事务处理的作用是使事务管理不侵入开发的组件。业务逻辑对象不需要意识...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值