分层架构下的纯JDBC事务控制简单解决方案

最新推荐文章于 2022-06-26 12:48:50 发布
最新推荐文章于 2022-06-26 12:48:50 发布
阅读量119 收藏
点赞数
分类专栏： 数据库技术 文章标签： JDBC DAO SQL 配置管理 Spring

对目前的JavaEE企业应用开发来说，基本都会采用分层的架构, 这样可以分散关注、松散耦合、逻辑复用、标准定义。例如，目前使用SSH组合时典型的四层架构：表示层、业务层、持久层和数据层；那么，在四层架构中，事务的控制应该放在哪一层呢？


如果使用Spring框架，它对事务做了很好的封装，通过它的AOP配置，可以灵活的配置在任何一层；但是在很多的需求和应用，直接使用JDBC事务控制还是有其优势的。所以，本文来讨论纯JDBC事务的控制问题。

其实，事务是以业务逻辑为基础的；一个完整的业务应该对应业务层里的一个方法；如果业务操作失败，则整个事务回滚；所以，事务控制是绝对应该放在业务层的；但是,持久层的设计应该遵循一个很重要的原则：持久层应该保证操作的原子性，就是说持久层里的每个方法都应该是不可以分割的。

例如针对一个部门和员工的CRUD操作。如果要删除某个部门，就应该在DeptDao中有一个删除部门的方法：
public class DeptDao {
    public void deleteDept(int id) ;         //删除指定ID的部门
}
在EmpDao中有一个删除指定部门下的所有员工的方法
public interface EmpDao{
    public void deleteEmpByDeptId(int id);    //删除指定部门下的所有员工
}
这样，就应该在业务层DeptService中的删除部门方法中组合这两个方法，即把它们放置在同一个事务中：
public class DeptService{
    public void deleteDept(int id){
        try{
             //启动JDBC事务
             //调用EmpDao中的deleteEmpByDeptId(id)方法
             //调用DeptDao中的deleteDept(id)方法
             //操作正常，提交事务
        }catch(Exception e){
             //异常，回滚事务
        }
    }
}

要让这两个Dao操作在同一个事务，最主要的一点就是：启动JDBC事务中使用的数据库连接和两个Dao操作方法里获得的数据库连接要是同一个连接。参照Spring的JDBC事务原理，可以使用ThreadLocal类, 在启动JDBC事务中把数据库连接绑定到线程，以保证在同一个线程下获得的都是同一个连接。这样就达到目的了。

如下数据库工具类：

view plaincopy to clipboardprint?
package com.tjitcast.common;  
import java.io.IOException;  
import java.sql.Connection;  
import java.sql.SQLException;  
import java.util.Properties;  
import javax.sql.DataSource;  
import com.mchange.v2.c3p0.DataSources;  
import com.tjitcast.dao.DaoException;  
/** 
 *  数据库工具类 
 *  可以根据classpath下配置文件jdbc.properties中配置的参数来获取数据库连接并绑定到当前线程上 
 *  可以获取JDBC的事务管理器 
 * @author qiujy 
 * @version 0.9Beta 
 */ 
public class DbUtils {  
    private static Properties prop = new Properties();  
    /** 数据源 */ 
    private static DataSource ds = null;   
      
    //用来把Connection绑定到当前线程上的变量  
    private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();  
    static{  
        try {  
            prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("jdbc.properties"));  
        } catch (IOException e) {  
            e.printStackTrace();  
            System.out.println("在classpath下没有找到jdbc.properties文件");  
        }  
          
        //使用C3P0连接池技术  
        try {  
            Class.forName("com.mysql.jdbc.Driver");  
              
            DataSource unpooled = DataSources.unpooledDataSource(  
                    prop.getProperty("url"),  
                    prop.getProperty("user"),  
                    prop.getProperty("password"));  
            ds = DataSources.pooledDataSource(unpooled);  
              
        } catch (ClassNotFoundException e) {  
            e.printStackTrace();  
        } catch (SQLException e) {  
            e.printStackTrace();  
        }  
    }  
      
    private DbUtils(){}  
      
    /** 
     * 根据数据库的默认连接参数获取数据库的Connection对象，并绑定到当前线程上 
     * @return 成功，返回Connection对象，否则返回null 
     */ 
    public static synchronized Connection getConnection(){  
        Connection conn = tl.get(); //先从当前线程上取出连接实例  
          
        if(null == conn){ //如果当前线程上没有Connection的实例   
            try {  
                conn = ds.getConnection(); // 从连接池中取出一个连接实例   
                tl.set(conn);  //把它绑定到当前线程上  
            } catch (SQLException e) {  
                e.printStackTrace();  
            }  
        }  
        return conn;  
    }  
    /** 
     * 获取事务管理器 
     * @return 事务管理实例 
     */ 
    public static synchronized TransactionManager getTranManager(){  
        return new TransactionManager(getConnection());  
    }  
      
    /** 
     * 关闭数据库连接，并卸装线程绑定 
     * @param conn 要关闭数据库连接实例 
     * @throws DaoException  
     */ 
    protected static void close(Connection conn) throws DaoException{  
        if(conn != null){  
            try {  
                conn.close();  
            } catch (SQLException e) {  
                throw new DaoException("关闭连接时出现异常",e);  
            } finally {  
                    tl.remove(); //卸装线程绑定  
            }  
        }  
    }  
      
} 
package com.tjitcast.common;
import java.io.IOException;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.DataSources;
import com.tjitcast.dao.DaoException;
/**
 *  数据库工具类
 *  可以根据classpath下配置文件jdbc.properties中配置的参数来获取数据库连接并绑定到当前线程上
 *  可以获取JDBC的事务管理器
 * @author qiujy
 * @version 0.9Beta
 */
public class DbUtils {
 private static Properties prop = new Properties();
 /** 数据源 */
 private static DataSource ds = null;
 
 //用来把Connection绑定到当前线程上的变量
 private static ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
 static{
  try {
   prop.load(Thread.currentThread().getContextClassLoader().getResourceAsStream("jdbc.properties"));
  } catch (IOException e) {
   e.printStackTrace();
   System.out.println("在classpath下没有找到jdbc.properties文件");
  }
  
  //使用C3P0连接池技术
  try {
   Class.forName("com.mysql.jdbc.Driver");
   
   DataSource unpooled = DataSources.unpooledDataSource(
     prop.getProperty("url"),
     prop.getProperty("user"),
     prop.getProperty("password"));
   ds = DataSources.pooledDataSource(unpooled);
   
  } catch (ClassNotFoundException e) {
   e.printStackTrace();
  } catch (SQLException e) {
   e.printStackTrace();
  }
 }
 
 private DbUtils(){}
 
 /**
  * 根据数据库的默认连接参数获取数据库的Connection对象，并绑定到当前线程上
  * @return 成功，返回Connection对象，否则返回null
  */
 public static synchronized Connection getConnection(){
  Connection conn = tl.get(); //先从当前线程上取出连接实例
  
  if(null == conn){ //如果当前线程上没有Connection的实例
   try {
    conn = ds.getConnection(); // 从连接池中取出一个连接实例
    tl.set(conn);  //把它绑定到当前线程上
   } catch (SQLException e) {
    e.printStackTrace();
   }
  }
  return conn;
 }
 /**
  * 获取事务管理器
  * @return 事务管理实例
  */
 public static synchronized TransactionManager getTranManager(){
  return new TransactionManager(getConnection());
 }
 
 /**
  * 关闭数据库连接，并卸装线程绑定
  * @param conn 要关闭数据库连接实例
  * @throws DaoException
  */
 protected static void close(Connection conn) throws DaoException{
  if(conn != null){
   try {
    conn.close();
   } catch (SQLException e) {
    throw new DaoException("关闭连接时出现异常",e);
   } finally {
           tl.remove(); //卸装线程绑定
   }
  }
 }
 
}
 

如下事务管理器类：

package com.tjitcast.common;  
import java.sql.Connection;  
import java.sql.SQLException;  
import com.tjitcast.dao.DaoException;  
/** 
 * 事务管理器 
 * @author qiujy 
 * @version 0.9Beta 
 */ 
public class TransactionManager {  
    private Connection conn;  
      
    protected TransactionManager(Connection conn) {  
        this.conn = conn;  
    }  
      
    /** 开启事务 */ 
    public void beginTransaction() throws DaoException{  
        try {  
            conn.setAutoCommit(false);  //把事务提交方式改为手工提交  
        } catch (SQLException e) {  
            throw new DaoException("开户事务时出现异常",e);  
        }  
    }  
      
    /** 提交事务并关闭连接 */ 
    public void commitAndClose() throws DaoException{  
        try {  
            conn.commit(); //提交事务  
        } catch (SQLException e) {  
            throw new DaoException("提交事务时出现异常",e);  
        }finally{  
            DbUtils.close(conn);  
        }  
    }  
      
    /** 回滚并关闭连接 */ 
    public void rollbackAndClose()throws DaoException{  
        try {  
            conn.rollback();  
        } catch (SQLException e) {  
            throw new DaoException("回滚事务时出现异常",e);  
        }finally{  
            DbUtils.close(conn);  
        }  
    }  
} 
package com.tjitcast.common;
import java.sql.Connection;
import java.sql.SQLException;
import com.tjitcast.dao.DaoException;
/**
 * 事务管理器
 * @author qiujy
 * @version 0.9Beta
 */
public class TransactionManager {
 private Connection conn;
 
 protected TransactionManager(Connection conn) {
  this.conn = conn;
 }
 
 /** 开启事务 */
 public void beginTransaction() throws DaoException{
  try {
   conn.setAutoCommit(false);  //把事务提交方式改为手工提交
  } catch (SQLException e) {
   throw new DaoException("开户事务时出现异常",e);
  }
 }
 
 /** 提交事务并关闭连接 */
 public void commitAndClose() throws DaoException{
  try {
   conn.commit(); //提交事务
  } catch (SQLException e) {
   throw new DaoException("提交事务时出现异常",e);
  }finally{
   DbUtils.close(conn);
  }
 }
 
 /** 回滚并关闭连接 */
 public void rollbackAndClose()throws DaoException{
  try {
   conn.rollback();
  } catch (SQLException e) {
   throw new DaoException("回滚事务时出现异常",e);
  }finally{
   DbUtils.close(conn);
  }
 }
}
 

如下业务层类：

view plaincopy to clipboardprint?
package com.tjitcast.service;  
import java.util.List;  
import com.tjitcast.common.DbUtils;  
import com.tjitcast.common.TransactionManager;  
import com.tjitcast.dao.DaoException;  
import com.tjitcast.dao.DaoFactory;  
import com.tjitcast.dao.DeptDao;  
import com.tjitcast.dao.EmployeeDao;  
import com.tjitcast.entity.Dept;  
import com.tjitcast.entity.Employee;  
import com.tjitcast.entity.PageModel;  
/** 
 * 业务层门面  --> 添加事务控制 
 * @author qiujy 
 */ 
public class ServiceFacade {  
    private DeptDao deptDao = DaoFactory.getInstance("deptDao", DeptDao.class);  
    private EmployeeDao empDao  = DaoFactory.getInstance("empDao", EmployeeDao.class);  
      
    /** 
     * 新增部门 
     * @param dept 
     */ 
    public void insertDept(Dept dept){  
        TransactionManager tx = DbUtils.getTranManager();  
        try{  
            tx.beginTransaction();  
              
            deptDao.insert(dept);  
              
            tx.commitAndClose();  
        }catch (DaoException e) {  
            tx.rollbackAndClose();  
        }  
    }  
      
    /** 
     * 新增员工 
     * @param emp 员工 
     */ 
    public void insertEmp(Employee emp){  
        TransactionManager tx = DbUtils.getTranManager();  
        try{  
            tx.beginTransaction();  
              
            empDao.insert(emp);  
              
            tx.commitAndClose();  
        }catch (DaoException e) {  
            tx.rollbackAndClose();  
        }  
    }  
      
    /** 
     * 获取所有部门的列表 
     * @return 部门列表 
     */ 
    public List<Dept> getDeptList(){  
        List<Dept> list = null;  
          
        TransactionManager tx = DbUtils.getTranManager();  
        try{  
            tx.beginTransaction();  
              
            list = deptDao.getDeptList();  
              
            tx.commitAndClose();  
        }catch (DaoException e) {  
            e.printStackTrace();  
            tx.rollbackAndClose();  
        }  
          
        return list;  
    }  
      
    /** 
     * 获取指定部门下的员工分页列表 
     * @param deptId 
     * @param pageNo 
     * @param pageSize 
     * @return 符合条件的PageModel 
     */ 
    public PageModel<Employee> getEmpListByDeptId(int deptId, int pageNo, int pageSize){  
        PageModel<Employee> pm = null;   
        TransactionManager tx = DbUtils.getTranManager();  
        try{  
            tx.beginTransaction();  
              
            pm = empDao.getEmpListByDeptId(deptId, pageNo, pageSize);  
              
            tx.commitAndClose();  
        }catch (DaoException e) {  
            tx.rollbackAndClose();  
        }  
        return pm;  
    }  
      
    /** 
     * 删除指定ID的部门 
     * @param id 部门ID 
     */ 
    public void deleteDept(int id){  
          
        TransactionManager tx = DbUtils.getTranManager();  
        try{  
            tx.beginTransaction();  
              
            empDao.deleteByDeptId(id); //先删除指定ID部门下的所有员工  
            deptDao.delete(id);  //再删除该部门  
              
            tx.commitAndClose();  
        }catch (DaoException e) {  
            tx.rollbackAndClose();  
        }  
    }  
} 
package com.tjitcast.service;
import java.util.List;
import com.tjitcast.common.DbUtils;
import com.tjitcast.common.TransactionManager;
import com.tjitcast.dao.DaoException;
import com.tjitcast.dao.DaoFactory;
import com.tjitcast.dao.DeptDao;
import com.tjitcast.dao.EmployeeDao;
import com.tjitcast.entity.Dept;
import com.tjitcast.entity.Employee;
import com.tjitcast.entity.PageModel;
/**
 * 业务层门面  --> 添加事务控制
 * @author qiujy
 */
public class ServiceFacade {
 private DeptDao deptDao = DaoFactory.getInstance("deptDao", DeptDao.class);
 private EmployeeDao empDao  = DaoFactory.getInstance("empDao", EmployeeDao.class);
 
 /**
  * 新增部门
  * @param dept
  */
 public void insertDept(Dept dept){
  TransactionManager tx = DbUtils.getTranManager();
  try{
   tx.beginTransaction();
   
   deptDao.insert(dept);
   
   tx.commitAndClose();
  }catch (DaoException e) {
   tx.rollbackAndClose();
  }
 }
 
 /**
  * 新增员工
  * @param emp 员工
  */
 public void insertEmp(Employee emp){
  TransactionManager tx = DbUtils.getTranManager();
  try{
   tx.beginTransaction();
   
   empDao.insert(emp);
   
   tx.commitAndClose();
  }catch (DaoException e) {
   tx.rollbackAndClose();
  }
 }
 
 /**
  * 获取所有部门的列表
  * @return 部门列表
  */
 public List<Dept> getDeptList(){
  List<Dept> list = null;
  
  TransactionManager tx = DbUtils.getTranManager();
  try{
   tx.beginTransaction();
   
   list = deptDao.getDeptList();
   
   tx.commitAndClose();
  }catch (DaoException e) {
   e.printStackTrace();
   tx.rollbackAndClose();
  }
  
  return list;
 }
 
 /**
  * 获取指定部门下的员工分页列表
  * @param deptId
  * @param pageNo
  * @param pageSize
  * @return 符合条件的PageModel
  */
 public PageModel<Employee> getEmpListByDeptId(int deptId, int pageNo, int pageSize){
  PageModel<Employee> pm = null;
  TransactionManager tx = DbUtils.getTranManager();
  try{
   tx.beginTransaction();
   
   pm = empDao.getEmpListByDeptId(deptId, pageNo, pageSize);
   
   tx.commitAndClose();
  }catch (DaoException e) {
   tx.rollbackAndClose();
  }
  return pm;
 }
 
 /**
  * 删除指定ID的部门
  * @param id 部门ID
  */
 public void deleteDept(int id){
  
  TransactionManager tx = DbUtils.getTranManager();
  try{
   tx.beginTransaction();
   
   empDao.deleteByDeptId(id); //先删除指定ID部门下的所有员工
   deptDao.delete(id);  //再删除该部门
   
   tx.commitAndClose();
  }catch (DaoException e) {
   tx.rollbackAndClose();
  }
 }
}

 


本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/qjyong/archive/2010/04/08/5464835.aspx

guxiang811417208
关注
专栏目录
JDBC三层架构
Yeung_ZY的博客
12-11 1932
三层架构的应用
分层架构
以前冷现在热
05-20 563
最近在项目设计时采用了领域驱动设计，在观摩《领域驱动设计》这本书时提到了layered architecture这个单词，也就是分层体系架构，觉得自己有必要对此分层架构进行一次系统的复习，记录下来以备后用 什么是分层架构？ 按照字面意思理解，即将程序分成多层的一种架构模式。那需要分成几层合适呢？Eric Evans建议分为四层，分别对应表现层，应用层，领域层以及基础设施层。而最基本的是分层架构是三...
MySQL —— JDBC 事务详解
永远的北极光
07-19 1073
一、概念 事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如 SQL，C++或Java）书写的用户程序的执行所引起，并用形如 begin transaction 和 end transaction 语句（或函数调用）来界定。事 务由事务开始(begin transaction)和事务结束(end tran
JDBC——“事务处理”
CHENZULAN的博客
12-21 554
一年前,学校广场上献血.200CC送一副修指甲的用具,400CC送个手表. 邻班一MM听说了感觉很幸福,跑过去问护士:"1000CC送什么?" 护士淡定的说:"送个棺材……"
JDBC 编程之事务处理
Cool的博客
06-26 903
数据库是一个多用户使用的共享资源，当多个用户并发的存取数据时，数据库中就会可能发生多个用户同时存取同一数据的情况若对并发操作不加控制，就可能会产生和读取不正确的数据，破坏数据的一致性而事务正是并发控制的基本单位。所谓事务，是一个操作序列，这些操作要么都执行，要么都不执行，是一个不可分割的工作单位事务也是数据库维护数据一致性的单位，在每个事务结束时，都能保持数据的一致性在编程中，可以把数据库事务看做是一组 SQL 语句，这组 SQL 语句是一个逻辑工作单元，它们是不可分割的，其执行结果应该作为一个整体，永久性
jdbc----事务处理（三个重点代码）
Big_xbc的博客
05-07 184
重点的三个代码 1./** 将事务设置为手动提交，即开启了事务 / conn.setAutoCommit(false); 2. /* 以上程序执行完成，事务结束 / conn.commit(); 3. /* 回滚事务 */ conn.rollback(); package com.Jdbc; import java.sql.*; /** * 事务处理 */ public class test08 { public static void main(String[] args) {
JDBC的三层和事务控制
weixin_40055163的博客
10-20 265
现有问题：用户交互代码与业务代码混杂在一起，将来更换交互方式势必会影响业务，耦合度高， 不利于重用与维护。 如图所示： 1 三层结构 将访问数据库、业务处理、用户交互分为三个模块，遵循单一职责，各司其职，降低耦合。 调用过程，如图所示： 1 业务层设计（service） 概念：根据业务需求，调用Dao实现具体业务功能的代码。 Service设计规范： 1.Service通常由接口+实现类组成，便于解耦合。 2.一个Service对应一张表的业务，例如t_person业务对应 PersonService，t
分层架构下的纯JDBC事务控制示例项目
04-08
非常常用的JavaEE四层架构下的纯JDBC事务控制简单解决方案。Eclipse工程。详情参看：http://blog.csdn.net/qjyong/archive/2010/04/08/5464835.aspx
数据治理概述及技术解决方案.pptx
08-13
2. **技术实现架构**：系统采用分层架构，包括资源层、业务层、集成层、管理与控制层、表现层和客户层。技术组件包括JDBC、Hibernate、XML配置、日志管理、安全控制、任务/事务处理、分析引擎等，支持数据导入导出、...
Spring框架分层架构详解
Spring的架构特性使得它在复杂性上保持了平衡，既提供了全面的解决方案，又避免了过度设计。它遵循“不重新发明轮子”的原则，可以与其他流行技术如Hibernate、MyBatis等无缝集成，简化了J2EE中的事务管理、对象关系...
JDBC中conn手动控制事务失败的原因
qq_42195589的博客
06-23 484
JDBC 事务
Java JDBC程序中对于数据库事务的处理详解
路宇的博客
05-05 891
一、JDBC中对于事务的介绍 二、使用事务模拟经典的转账业务 下面代码中演示JDBC中没有使用事务，和使用事务的两种情况 //演示jdbc 中如何使用事务 public class Transaction_ { //没有使用事务 @Test public void noTransaction() { //1.得到连接 Connection connection = null; //2.组织一个sql //更新记录
Jdbc执行存储过程报数据库事务无法执行的异常
weixin_30608131的博客
04-11 231
Jdbc执行存储过程报数据库事务无法执行的异常 环境： Eclipse+Jdk1.7+spring-jdbc-3.0.7+同版本的jdbctemplate+Sqlserver 2012 问题： 一个小接口采用jdbctemplate进行对sqlserver的存储过程操作，一般过程执行没问题，但个别存储过程第一次可以执行，第二次再执行就异常； 原因参考： https://blo...
JDBC之【事务的控制】
weixin_48485216的博客
04-17 864
JDBC事务机制 1、JDBC中的事务是自动提交的，只要执行任意一条SQL语句，则提交一次。这是JDBC默认的事务行为。 2、但是在一般情况下，通常都是N条DML语句共同联合才能完成，必须保证这些DML语句在同一个事务中同时成功或者同时失败。 JDBC实现手动提交事务 开启事务：connection.setAutoCommit(boolean) 提交事务：connection.commit(); 回滚事务：connection.rollback(); public static void
说说事务的概念，在JDBC编程中处理事务的步骤。
weixin_46503633的博客
12-14 202
说说事务的概念，在JDBC编程中处理事务的步骤。 事务是作为单个逻辑工作单元执行的一系列操作，一个逻辑工作单元必须有四个属性，称为原子性、一致性、隔离性和持久性 (ACID) 属性，只有这样才能成为一个事务 。JDBC处理事务有如下操作： conn.setAutoComit(false);设置提交方式为手工提交conn.commit()提交事务 conn.rollback()，回滚 提交与回滚只选择一个执行。正常情况下提交事务，如果出现异常，则回滚。 ...
jdbc事务控制
Akiler的博客
06-17 167
ThreadLocal完成JDBC事务操作
JavaSE JDBC事务控制
Mr青青子衿
12-09 294
JDBC中使用事务 事务概念: 事务概念:在逻辑上一组不可分割的操作,由多个sql语句组成,多个sql语句要么全都执行成功,要么都不执行. 原子性 一致性 隔离性 持久性 JDBC控制事物主要就是在学习如何让多个数据库操作成为一个整体,实现要么全都执行成功,要么全都不执行 在JDBC中，事务操作是自动提交。一条对数据库的DML(insert、update、delete)代表一项事务操作,操作成功后，系统将自动调用commit()提交，否则自动调用rollback()回滚。 在JDBC中
mysql myisam 支持事务吗_mysql事务的坑----MyISAM表类型不支持事务操作
weixin_42469749的博客
01-19 1594
最近需要通过JDBC对数据库做事务型操作，实践时发现，并没有达到想要的效果，表现在：1、每次执行executeUpdate()后，数据就马上能在DB中查到。但按理来说，我还没执行commit()，DB中不应该有这个数据；2、执行rollback()时，数据也没回滚。定位问题后，发现是数据库表类型在作祟：当时设定的“表类型”为MyISAM，而这种类型，是不支持事务操作的。能够支持事务操作的表类型是“...
浅谈JDBC操作MySQL数据库实现事务管理
zgsdlr的博客
02-22 914
JDBC是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。简单来说，JDBC就是用Java对数据库实现一定操作的API。 下面，本文将浅谈用Java语言操作数据库进行事务管理的步骤。 JDBC操作数据库进行事务管理 1. 建立到特定数据库的连接 Connection con =DriverManager.getConnection(url,user,pwd); 此处的url，user，pwd建议在前面以字符串类型设定好，在DriverManager.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值