JavaWeb(三)之数据库连接池，Spring JDBC

最新推荐文章于 2021-04-22 22:17:45 发布
最新推荐文章于 2021-04-22 22:17:45 发布
阅读量285 收藏
点赞数
分类专栏： JavaWeb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32719221/article/details/102711027
版权

目录

  1. 数据库连接池

  2. Spring JDBC : JDBC Template

数据库连接池

1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。

当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。
解决原来用完连接，就释放连接。再来连接数据库还得新创建连接

2. 好处：

  1. 节约资源
  2. 用户访问高效，用户直接从申请好的对象访问数据库
    在这里插入图片描述

3. 实现：

  1. 标准接口：DataSource javax.sql包下的
    1. 方法：
    * 获取连接：getConnection()。从连接池获取连接
    * 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Connection.close()方法，则不会再关闭连接了。而是归还连接

  2. 一般我们不去实现它，有数据库厂商来实现
    1. C3P0：数据库连接池技术
    2. Druid：数据库连接池实现技术，由阿里巴巴提供的

4. C3P0：数据库连接池技术

  • 步骤：
    1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar(这个jar包是个依赖) ,千万不要忘记mysql的驱动jar包mysql-connector-java-bin.jar无论再怎么用连接池，也得调用驱动jar包
    * 不要忘记导入数据库驱动jar包,右键add as libary
    2. 定义配置文件：
    * 名称： c3p0.properties 或者 c3p0-config.xml
    * 路径：直接将文件放在src目录下即可。默认在类路径下(也就是ClassPath)
    3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
    4. 获取连接： getConnection

  • 配置文件

<c3p0-config>
  <!-- 使用默认的配置读取连接池对象 -->
  <default-config>
  	<!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/bookmanager</property>
    <property name="user">root</property>
    <property name="password">xgh961120</property>
    
    <!-- 连接池参数 -->
    <!-- 初始化连接对象-->
    <property name="initialPoolSize">5</property>
    <!-- 最大的连接对象-->
    <property name="maxPoolSize">10</property>
    <!-- 超时时间-->
    <property name="checkoutTimeout">3000</property>
  </default-config>

 <!-- 一个配置文件可以构造多个连接池对象，可以自己配置一个连接池对象 -->
  <named-config name="otherc3p0"> 
    <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/day25</property>
    <property name="user">root</property>
    <property name="password">root</property>
    
    <!-- 连接池参数 -->
    <property name="initialPoolSize">5</property>
    <property name="maxPoolSize">8</property>
    <property name="checkoutTimeout">1000</property>
  </named-config>
</c3p0-config>
  • 代码：
 //1.创建数据库连接池对象
        DataSource ds  = new ComboPooledDataSource();
		//获取DataSource，使用指定名称配置文件中的连接池对象
        DataSource ds1  = new ComboPooledDataSource("otherc3p0");
        //2. 获取连接对象
        Connection conn = ds.getConnection();

5. Druid：数据库连接池实现技术，由阿里巴巴提供的

1. 步骤：
  1. 导入jar包 druid-1.0.9.jar
  2. 定义配置文件：
    • 是properties形式的
    • 可以叫任意名称，可以放在任意目录下，不会自动加载，需要手动指定名称和路径加载进来（区别与c3p0.xml放在src目录下可以自动加载）
  3. 加载配置文件。Properties
  4. 获取数据库连接池对象：通过工厂类来获取（区别于C3p0是直接new的） DruidDataSourceFactory
  5. 获取连接：getConnection
2.代码：
 //3.加载配置文件
        Properties pro = new Properties();
        InputStream is = DruidDemo.class.getClassLoader().getResourceAsStream("druid.properties");
        pro.load(is); //将配置文件加载到内存的Properties对象中
        //4.获取连接池对象
        DataSource ds = DruidDataSourceFactory.createDataSource(pro);
        //5.获取连接
        Connection conn = ds.getConnection();
3.配置文件
driverClassName=com.mysql.jdbc.Driver
	url=jdbc:mysql://127.0.0.1:3306/bookmanager
	username=root
	password=xgh961120
	#初始化连接数量
	initialSize=5
	#最大连接数
	maxActive=10
	#最大等待时间
	maxWait=3000
4. 定义数据库连接池_druid_工具类
  1. 定义一个类 JDBCUtils
  2. 提供静态代码块加载配置文件，初始化连接池对象
  3. 提供方法
    1. 获取连接方法：通过数据库连接池获取连接
    2. 释放资源
    3. 获取连接池的方法

4.代码：

public class JDBCUtils {

		    //1.定义一个静态成员变量连接池DataSource
		    private static DataSource ds ;
			//在静态代码块中对静态成员变量进行赋值
		    static{
		        try {
		            //1.加载配置文件，将配置文件加载到内存中的pro中
		            Properties pro = new Properties();
		            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
		            //2.获取DataSource，通过工厂类来获取连接池对象并赋值于静态变量
		            ds = DruidDataSourceFactory.createDataSource(pro);
		        } catch (IOException e) {
		            e.printStackTrace();
		        } catch (Exception e) {
		            e.printStackTrace();
		        }
		    }
		
		    /**
		     * 获取连接
		     */
		    public static Connection getConnection() throws SQLException {
		        return ds.getConnection();
		    }
		
		    /**
		     * 释放资源有两种情况
		     */
		    public static void close(Statement stmt,Connection conn){
		       /* if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }*/
		
		       close(null,stmt,conn); //简化编程，如果是两个参数的方法调用三个参数的方法
		    }
		
		
		    public static void close(ResultSet rs , Statement stmt, Connection conn){
		
		
		        if(rs != null){
		            try {
		                rs.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		
		        if(stmt != null){
		            try {
		                stmt.close();
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		
		        if(conn != null){
		            try {
		                conn.close();//归还连接
		            } catch (SQLException e) {
		                e.printStackTrace();
		            }
		        }
		    }
		
		    /**
		     * 获取连接池方法
		     */
		
		    public static DataSource getDataSource(){
		        return  ds;
		    }
		
		}
  1. 使用新的工具类
/**
 * 使用新的工具类
 */
public class DruidDemo2 {

    public static void main(String[] args) {
        /*
         * 完成添加操作：给account表添加一条记录
         */
        Connection conn = null;
        PreparedStatement pstmt = null;
        try {
            //1.调用工具类获取连接
            conn = JDBCUtils.getConnection();
            //2.定义sql
            String sql = "insert into account values(null,?,?)";
            //3.获取pstmt对象
            pstmt = conn.prepareStatement(sql);
            //4.给？赋值
            pstmt.setString(1,"王五");
            pstmt.setDouble(2,3000);
            //5.执行sql
            int count = pstmt.executeUpdate();
            System.out.println(count);
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            //6. 调用工具类释放资源
            JDBCUtils.close(pstmt,conn);
        }
    }

}

Spring JDBC

  • Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发

1.步骤：

  1. 导入jar包，Spring的5个jar包，连接池的jar包，连接Mysql的驱动jar包

  2. 创建JdbcTemplate对象。依赖于数据源DataSource（数据库连接池）
    * JdbcTemplate template = new JdbcTemplate(ds);

  3. 调用JdbcTemplate的方法来完成CRUD的操作
    * update():执行DML语句。增、删、改语句
    * queryForMap():查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合
    * 注意：这个方法查询的结果集长度只能是1
    * queryForList():查询结果将结果集封装为list集合
    * 注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中
    * query():查询结果，将结果封装为JavaBean对象
    * query的参数：RowMapper
    * 一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
    * new BeanPropertyRowMapper<类型>(类型.class)
    * queryForObject：查询结果，将结果封装为对象
    * 一般用于聚合函数的查询

2.JdbcTemplate入门

/**
 * JdbcTemplate入门
 */
public class JdbcTemplateDemo1 {

    public static void main(String[] args) {
        //1.导入jar包
        //2.创建JDBCTemplate对象
        JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
        //3.调用方法
        String sql = "update account set balance = 5000 where id = ?";
        int count = template.update(sql, 3);//3与第一个?对应
        System.out.println(count);
    }
}

3. 练习：

  • 需求：
    1. 修改1号数据的 salary 为 10000
    2. 添加一条记录
    3. 删除刚才添加的记录
    4. 查询id为1的记录，将其封装为Map集合
    5. 查询所有记录，将其封装为List
    6. 查询所有记录，将其封装为Emp对象的List集合
    7. 查询总记录数
    123用update()方法
    4用queryForMap()方法
    5用queryForList()方法
    6用query()方法
    7用queryForObject方法

创建一个EMP类和数据库字段一一对应
数据库字段有:id,ename,job_id,mqr,joindate,salary,bonus,dept_id

public class Emp {
    private Integer id;
    private String ename;
    private Integer job_id;
    private Integer mgr;
    private Date joindate;
    private Double salary;
    private Double bonus;
    private Integer dept_id;


    public Integer getId() {
        return id;
    }

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

    public String getEname() {
        return ename;
    }

    public void setEname(String ename) {
        this.ename = ename;
    }

    public Integer getJob_id() {
        return job_id;
    }

    public void setJob_id(Integer job_id) {
        this.job_id = job_id;
    }

    public Integer getMgr() {
        return mgr;
    }

    public void setMgr(Integer mgr) {
        this.mgr = mgr;
    }

    public Date getJoindate() {
        return joindate;
    }

    public void setJoindate(Date joindate) {
        this.joindate = joindate;
    }

    public Double getSalary() {
        return salary;
    }

    public void setSalary(Double salary) {
        this.salary = salary;
    }

    public Double getBonus() {
        return bonus;
    }

    public void setBonus(Double bonus) {
        this.bonus = bonus;
    }

    public Integer getDept_id() {
        return dept_id;
    }

    public void setDept_id(Integer dept_id) {
        this.dept_id = dept_id;
    }

    @Override
    public String toString() {
        return "Emp{" +
                "id=" + id +
                ", ename='" + ename + '\'' +
                ", job_id=" + job_id +
                ", mgr=" + mgr +
                ", joindate=" + joindate +
                ", salary=" + salary +
                ", bonus=" + bonus +
                ", dept_id=" + dept_id +
                '}';
    }
}

技巧：
单元测试技巧，可以让方法独立执行，不再依赖主方法。在方法上加注解@Test,报错后点红色小灯泡，选择Add"JUnit4"to classpath 选择ok,点击旁边的绿色小箭头即可执行

代码：

import cn.tju.domain.Emp;
			import cn.tju.utils.JDBCUtils;
			import org.junit.Test;
			import org.springframework.jdbc.core.BeanPropertyRowMapper;
			import org.springframework.jdbc.core.JdbcTemplate;
			import org.springframework.jdbc.core.RowMapper;
			
			import java.sql.Date;
			import java.sql.ResultSet;
			import java.sql.SQLException;
			import java.util.List;
			import java.util.Map;
			
			public class JdbcTemplateDemo2 {
			
			    //Junit单元测试，可以让方法独立执行
			
			
			    //1. 获取JDBCTemplate对象（因为这个JDBCTemplate对象在每个方法都要使用，所以把它定义为成员变量）
			    private JdbcTemplate template = new JdbcTemplate(JDBCUtils.getDataSource());
			    /**
			     * 1. 修改1号数据的 salary 为 10000
			     */
			    @Test
			    public void test1(){
			
			        //2. 定义sql
			        String sql = "update emp set salary = 10000 where id = 1001";
			        //3. 执行sql
			        int count = template.update(sql); //没有?就没有第二个参数
			        System.out.println(count);
			    }
			
			    /**
			     * 2. 添加一条记录
			     */
			    @Test
			    public void test2(){
			        String sql = "insert into emp(id,ename,dept_id) values(?,?,?)";
			        int count = template.update(sql, 1015, "郭靖", 10); //具体的值用从第二个起的参数替代?
			        System.out.println(count);
			
			    }
			
			    /**
			     * 3.删除刚才添加的记录
			     */
			    @Test
			    public void test3(){
			        String sql = "delete from emp where id = ?";
			        int count = template.update(sql, 1015); //1015代替第一个?
			        System.out.println(count);
			    }
			
			    /**
			     * 4.查询id为1001的记录，将其封装为Map集合
			     * 注意：这个方法查询的结果集长度只能是1
			     */
			    @Test
			    public void test4(){
			        String sql = "select * from emp where id = ? or id = ?";
			        Map<String, Object> map = template.queryForMap(sql, 1001,1002);
			        System.out.println(map);
			        //{id=1001, ename=孙悟空, job_id=4, mgr=1004, joindate=2000-12-17, salary=10000.00, bonus=null, dept_id=20} 将数据库字段的名称和字段的值封装成了一个map集合
			
			    }
			
			    /**
			     * 5. 查询所有记录，将其封装为List，注意看这个时候的泛型，将每一条记录装到了Map里头，最后再将Map装到了List里
			     */
			    @Test
			    public void test5(){
			        String sql = "select * from emp";
			        List<Map<String, Object>> list = template.queryForList(sql);
			
			        for (Map<String, Object> stringObjectMap : list) {
			            System.out.println(stringObjectMap);
			        }
			    }
			
			    /**
			     * 6. 查询所有记录，将其封装为Emp对象的List集合，我们可以自己实现RoMapper这个接口，下面这个方法使用匿名内部类来实现，从数据集rs中获取数据库对应列的值，封装到emp对象的成员变量中
			     */
			
			    @Test
			    public void test6(){
			        String sql = "select * from emp";
			
			        List<Emp> list = template.query(sql, new RowMapper<Emp>() {
			
			            @Override
			            public Emp mapRow(ResultSet rs, int i) throws SQLException {
			                Emp emp = new Emp();
			                int id = rs.getInt("id");
			                String ename = rs.getString("ename");
			                int job_id = rs.getInt("job_id");
			                int mgr = rs.getInt("mgr");
			                Date joindate = rs.getDate("joindate");
			                double salary = rs.getDouble("salary");
			                double bonus = rs.getDouble("bonus");
			                int dept_id = rs.getInt("dept_id");
			
			                emp.setId(id);
			                emp.setEname(ename);
			                emp.setJob_id(job_id);
			                emp.setMgr(mgr);
			                emp.setJoindate(joindate);
			                emp.setSalary(salary);
			                emp.setBonus(bonus);
			                emp.setDept_id(dept_id);
			
			                return emp;
			            }
			        });
			
			
			        for (Emp emp : list) {
			            System.out.println(emp);
			        }
			    }
			
			    /**
			     * 6. 查询所有记录，将其封装为Emp对象的List集合，利用template.query中自己实现接口的实现类，自动对rs中的数据进行封装到JavaBean对象里，最后返回JavaBean对象组成的列表
			     */
			
			    @Test
			    public void test6_2(){
			        String sql = "select * from emp";
			        List<Emp> list = template.query(sql, new BeanPropertyRowMapper<Emp>(Emp.class));
			        for (Emp emp : list) {
			            System.out.println(emp);
			        }
			    }
			
			    /**
			     * 7. 查询总记录数
			     */
			
			    @Test
			    public void test7(){
			        String sql = "select count(id) from emp";
			        Long total = template.queryForObject(sql, Long.class);
			        System.out.println(total);
			    }
			
			}
菜菜的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring集成数据库连接池到Wowza示例代码
03-25
本资源是博客《使用 spring 集成 dbcp 数据库连接池到 Wowza 插件》中的示例代码，博客地址：http://blog.csdn.net/defonds/article/details/22102561。
JavaWeb Spring轻量级数据库操作
qq_43498164的博客
04-06 169
在这里记录下Spring管理数据库的常用函数和方法，做设计的时候多用用看看。
JavaWeb 之 数据库连接池
qq_37795916的博客
04-22 304
数据库连接池 1. 是什么 其实就是一个容器（集合），里面存放数据库连接的容器。能节约资源，让用户高效的访问。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户访问数据库时，直接从容器中获得连接对象，用户访问完在归还给容器，而不必在跟计算机底层打交道。 实现： 标准接口：DataSource javax.sql包下的 方法： 获取连接：getConnection() 归还连接：Connection.close()。如果连接对象Connection是从连接池中获取的，那么调用Co
JDBC 数据库连接池 实现代码一（介绍）
sakyoneone的专栏
04-12 344
文章转自：http://hi.baidu.com/cpmroom/blog/item/4e9a8490cf23628aa977a4a0.html 虽然 J2EE 程序员一般都有现成的应用服务器所带的JDBC 数据库连接池，不过对于开发一般的 Java Application 、 Applet 或者 JSP、velocity 时，我们可用的JDBC 数据库连接池并不多，并且一般性...
Java Web基础入门第五十七讲 数据库连接池
李阿昀的博客
08-29 1360
应用程序直接获取数据库连接的缺点用户每次请求都需要向数据库获得链接，而数据库创建连接通常需要消耗相对较大的资源，创建时间也较长。假设网站一天10万访问量，数据库服务器就需要创建10万次连接，极大的浪费数据库的资源，并且极易造成数据库服务器内存溢出、拓机。如下图所示： 使用数据库连接池优化程序性能数据库连接池的基本概念数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现的尤为突
Druid数据库连接池+Spring JDBC+BeanUtils简单实现登录功能
12-10
JavaWeb Druid数据库连接池+Spring JDBC+BeanUtils简单实现登录功能，博客地址：https://blog.csdn.net/qq_44515800/article/details/121856426
JavaWeb连接数据库MySQL的操作技巧
08-31
在实际开发中，为了提高代码的可维护性和安全性，通常会采用连接池管理数据库连接，如Apache DBCP或C3P0，以及使用预编译的PreparedStatement防止SQL注入。此外，现代JavaWeb开发往往会选择Spring Boot框架，它提供...
MySql_JDBC, Druid数据库连接池以及Template技术所需jar包.zip
11-16
MySQL JDBC、Druid数据库连接池和Template技术是Java Web开发中的关键组件，它们极大地提高了数据库操作的效率和便捷性。让我们深入探讨这些知识点。 首先，MySQL JDBC（Java Database Connectivity）是Java与MySQL...
durid数据库连接池的使用方式，定义了工具类，可以通过durid方式访问数据库，实现对数据库的添加
10-02
Durid，全称为 Distributed Universal JDBC，是阿里巴巴开源的一个高性能、分布式、可扩展的数据库连接池组件。它在设计上借鉴了C3P0、DBCP等成熟的数据源管理方案，并在此基础上进行了优化和增强，提供了更强大的...
数据库连接池
03-22
数据库连接池主要有三种常见的实现：Apache的DBCP、C3P0和HikariCP。每种连接池都有其特点和适用场景。 1. DBCP（Apache BasicDataSource）：它是Apache Commons的一个组件，提供了基本的数据库连接池功能。DBCP...
javaweb （含有数据库脚本文件myBlog.rar
08-06
基于javaWeb的一个博客系统，实现的主要功能有游客的注册登陆修改信息在线发送留言以及回复留言等，含有数据库脚本文件。博主可以操作游客，对其信息的改删查等，另外界面很精美大方，可以下载一起学习学习
java web总结(数据库连接池)
u014469691的专栏
09-24 406
连接池需要 commons 中dbcp 与pool包，还需要数据库包（底层是装饰者模式） public class dbcplianjiechi { /** * 创建连接池对象 * 配置连连接池(四大对象) *得到连接对象 * @throws SQLException **/ @Test public void fun1() throws SQLException{ Basi
JDBC之Druid工具类
whyfive4的博客
08-04 422
Druid工具类： 0.定义静态成员变量：DataSource 1.定义静态代码块，加载配置文件，初始化连接池对象 2.定义方法： 1.获取连接对象 2.释放连接 3.获取连接池方法 3.使用工具类,需要自己定义sql，执行sql并处理结果 0.定义静态成员变量：DataSource private static DataSource dSource; 1.定义静态代码块，加载配置文件...
第三十三天：JDBC高级 DataSource连接池（引入设计者模式，静态代理，动态代理）
qq_38250571的博客
12-05 494
1. 数据源 1.1 概念 初始化并维护多个连接对象，当其他地方需要时，从连接池获取；用完之后，归还到连接池。以此实现连接的复用，提高效率。 1.2 池化思想（重要） 以空间换时间的做法。 游戏背包、新闻客户端。 提供更好的使用体验 对资源的消耗会更少。不会频繁的创建和销毁对象。 1.3 自定义数据源思路 自定义一个连接池的整体思路 准备一个保存多个连接的容器ArrayList 一开始就创建多个连接，并存入上述容器 自己写一个类，封装上述的容器ArrayList对象，对外提供获取连接、归还
Spring工具类：WebApplicationContextUtils
weixin_30821731的博客
05-16 211
当 Web 应用集成 Spring 容器后，代表 Spring 容器的WebApplicationContext对象将以 WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE 为键存放在ServletContext的属性列表中。您当然可以直接通过以下语句获取 WebApplicationContext： WebApplic...
JavaWeb入门实战—数据库连接池(数据源)
Ricky
08-17 2368
上一篇文章中讲到了通过Connection去连接数据库，
JavaWeb：JDBC之数据库连接池
热门推荐
JackChan
10-31 1万+
系列阅读 JavaWeb：用JDBC操作数据库 JavaWeb：JDBC之事务 JavaWeb：JDBC之数据库连接池 池参数（所有池参数都有默认值） 初始大小：10个 最小空闲连接数：3个 增量：一次创建的最小单位（5个） 最大空闲连接数：12个 最大连接数：20个 最大的等待时间：1000毫秒 四大连接参数连接池也是使用四大连接参数来完成创建连接对象！实现的接口连接池必须实现：javax.sql
JavaEE（JavaWeb）——数据库连接池及工具类封装
weixin_42067873的博客
02-26 427
Druid（alibaba）是源码开源的一个JDBC 连接池组件，支持克隆/下载，功能主要包括三部分： Driver 代理Driver，能够提供基于Filter－Chain模式的插件体系； DataSource 高效可管理的数据库连接池； SQLParser。内置提供了一个功能强大的StatFilter 配置文件（druid.properties） url=jdbc:mysql://localhost:3306/aaa username=root password=hanmenghao dr.
JavaWeb学生考勤管理系统实操：JDBC+Spring+JSP+MySQL
4. 分层架构与框架应用：采用分层架构模式，结合Spring框架简化数据库操作，并利用Druid数据库连接池提高效率。 在技术原理与方案部分，详细阐述了系统的关键组件： - JDBC连接池（Druid）：作为数据库连接管理工具...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值