Javaweb学习笔记之DbUtils(一)：增删改查

最新推荐文章于 2023-03-20 16:19:58 发布
最新推荐文章于 2023-03-20 16:19:58 发布
阅读量382 收藏 3
点赞数 1
分类专栏： javaweb学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_29331365/article/details/98875546
版权

 

package com.jdbc.dbutils;

import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.ResultSetHandler;
import org.apache.commons.dbutils.handlers.*;
import org.junit.Test;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * 1、DbUtils 简介：
 *      DbUtils 是 java 编程中的数据库操作实用工具，小巧、简单、实用；
 *      DbUtils 封装了对 JDBC 的操作，简化了 JDBC 操作，可以少写代码；
 *
 *      对于数据库的读操作，DbUtils 可以把结果直接转换成 List、Array、Set 等 java 集合，便于程序员操作；
 *      对于数据库的写操作，也变的很简单，只需要写 sql 语句；
 *      可以使用 数据源、JNDI、数据库连接池 等技术来优化性能 -- 重用已经构建好的数据库连接对象；
 *
 * 2、DbUtils 的核心对象：
 *      QueryRunner 类：提供对 sql 语句操作的 API；
 *          query()：用于执行 select 语句；
 *          update()：用于执行 insert、update、delete 语句；
 *          batch()：批处理；
 *      ResultSetHandler 接口：用于定义 select 操作后，怎样封装结果集；
 *      DbUtils 类：他就是一个工具类，定义了关闭资源与事务处理的方法；
 *
 * 3、DbUtils 导入的 jar 包：
 *      commons-dbutils-1.6.jar
 */
public class Demo1 {

    /**
     * DbUtils 执行 sql 语句 插入数据
     */
    @Test
    public void testInsert() throws Exception{
        // 创建 QueryRunner 对象，传入数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句插入数据
        int num = queryRunner.update("insert into users(username, password) values('lily', '321')");
        if (num > 0){
            System.out.println("插入数据成功，影响了" + num + "行.");
        }

        // 执行 sql 语句插入数据，传入参数
        // 接收参数的方法定义：update(String sql, Object... params)
        // 最后一个参数 Object... 表示是可变参数，是需要传入到参数 1 的 sql 语句中的值；
        num = queryRunner.update("insert into users(username, password) values(?, ?)", "lucy", "456");
        if (num > 0){
            System.out.println("插入数据成功，影响了" + num + "行.");
        }
    }

    /**
     * DbUtils 执行 sql 语句 修改数据
     */
    @Test
    public void testUpdate() throws Exception{
        // 创建 QueryRunner 对象，传入数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，修改数据
        int num = queryRunner.update("update users set username=?, password=? where id=?", "Jack", "789", 24);
        if (num > 0){
            System.out.println("修改数据成功，影响了" + num + "行.");
        }
    }

    /**
     * DbUtils 执行 sql 语句 删除数据
     */
    @Test
    public void testDelete() throws Exception{
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，删除数据
        int num = queryRunner.update("delete from users where id=?", 23);
        if (num > 0){
            System.out.println("删除数据成功，影响了" + num + "行.");
        }
    }

    /**
     * DbUtils 执行 批处理 语句
     * 批处理只能执行相同的 sql 语句
     */
    @Test
    public void testBatch() throws Exception{
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 定义一个 二位数组，作为 批处理语句的 参数
        String[][] param = new String[10][];    // 表示循环 10 次，执行 10 次 sql 语句
        for (int i = 0; i < param.length; i++) {
            param[i] = new String[]{"jerry" + i, "66" + i}; // 给每次执行的 sql 语句中的 ？ 赋值
        }

        // 执行 批处理语句
        int[] num = queryRunner.batch("insert into users(username, password) values(?, ?)", param);
    }

    /**
     * DbUtils 执行 sql 语句查询数据
     * 使用 ResultSetHandler 接口的匿名内部类方式实现
     */
    @Test
    public void testSelect1() throws Exception{
        // 创建一个 QueryRunner 对象，传入一个数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句查询数据，并将结果集封装到 list 集合中返回
        List<User> list = queryRunner.query("select * from users", new ResultSetHandler<List<User>>() {
            // 当 query 方法执行 select 语句后，将结果集以参数的形式传入到 handle 方法中；
            @Override
            public List<User> handle(ResultSet resultSet) throws SQLException {
                // 将 结果集中的数据封装到 list 集合中
                List<User> list = new ArrayList<>();
                while(resultSet.next()){
                    User user = new User();
                    user.setId(resultSet.getInt("id"));
                    user.setUsername(resultSet.getString("username"));
                    user.setPassword(resultSet.getString("password"));
                    list.add(user);
                }
                // 返回 list 集合
                return list;
            }
        });

        // 输出 list 集合中的数据
        for (User user : list) {
            System.out.println(user);
        }
    }

    /*************************************************
    ResultSetHandler 接口定义 select 操作后怎样封装结果集，可以使用下面几个已经实现了该接口的类 更方便的封装结果集：
        1、BeanListHandler：该类会自动 将结果集封装到 list 集合中；
        2、ArrayHandler：该类适合只获取 1 条记录，把该记录每列的值封装到 object[] 数组中；
            如果 sql 语句没有带条件，能够查询到多条记录，则 ArrayHandler 只封装查询到的第一条记录；
        3、ArrayListHandler：获取多条数据，先将每条记录的每列值封装到一个 object[] 数组中，然后再将数组封装到一个 list 集合中；
        4、ColumnListHandler：获取某一列的数据，并将数据封装到 list 中；
        5、MapHandler：适合获取1条记录，把查询到的列名和列值封装到 Map 中；
            如果 sql 语句能够查到多条数据，那么 MapHandler 也只会封装第一条数据；
        6、KeyedHandler：获取多条记录，把每一条记录封装到一个 Map 中，再把这个 Map 封装到另一个 Map 中，key 为指定的字段值；
        7、MapListHandler：获取多条记录，把每条记录封装到一个 Map 中，然后再把这个 Map 封装到 List 集合中；
        8、ScalarHandler：适合获取单行单列数据；
     *************************************************/

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  1、使用 BeanListHandler 类实现，该类会自动 将结果集封装到 list 集合中
     */
    @Test
    public void testSelect2() throws Exception{
        // 创建 QueryRunner 对象，传入一个 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 SQL 语句查询数据，并将结果集封装到 list 集合中；泛型和参数类型为 Javabean 类;
        List<User> list = queryRunner.query("select * from users", new BeanListHandler<User>(User.class));

        // 输出 list 集合中的数据
        for (User user : list) {
            System.out.println(user);
        }


        // 执行 sql 语句，查询数据，并将结果集封装到 list 集合中，传入参数
        // 接收参数的 query 方法定义：query(String sql, ResultSetHandler<T> rsh, Object... params)；
        // 最后一个参数 Object... 表示是可变参数，是需要传入到参数 1 的 sql 语句中的值；
        List<User> list2 = queryRunner.query("select * from users where username=? and password=?", new BeanListHandler<User>(User.class), "rose6", "126");

        // 输出 list2 集合中的数据
        for (User user : list2) {
            System.out.println(user);
        }
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  2、使用 ArrayHandler 类实现：只取 1 条记录，把该记录每列的值封装到 object[] 数组中
     */
    @Test
    public void testSelect3() throws Exception{
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据
//        Object[] arr = queryRunner.query("select * from users where id=?", new ArrayHandler(), 3);

        // 如果 sql 语句不写条件，则只取第一条记录
        Object[] arr = queryRunner.query("select * from users", new ArrayHandler());

        // 遍历数组中 每列的值
        for (Object obj : arr) {
            System.out.print(obj + ",");
        }
        System.out.println();
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  3、使用 ArrayListHandler 类实现：
     *      取多条数据，先将每条记录的每列值封装到一个 object[] 数组中，然后再将数组封装到一个 list 集合中
     */
    @Test
    public void testSelect4() throws Exception{
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据
        List<Object[]> list = queryRunner.query("select * from users", new ArrayListHandler());

        // 遍历结果
        for (Object[] arr : list) {     // list 集合中封装的是 object[] 数组
            for (Object obj : arr) {    // object[] 数组中封装的是 每条记录的 每列的值
                System.out.print(obj + ",");
            }
            System.out.println();
        }
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  4、使用 ColumnListHandler 类实现：
     *      获取某一列的数据，并封装到 list 集合中；
     */
    @Test
    public void testSelect5() throws Exception{
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据
        // 不指定列的时候，默认获取第一列的数据
        List<Object> list1 = queryRunner.query("select * from users", new ColumnListHandler<Object>());
        System.out.println(list1);

        // 可以指定列的序号：获取 第2列 的数据
        List<Object> list2 = queryRunner.query("select * from users", new ColumnListHandler<Object>(2));
        System.out.println(list2);

        // 也可以指定列的名字：获取 username 列的数据
        List<String> list3 = queryRunner.query("select * from users", new ColumnListHandler<String>("username"));
        System.out.println(list3);
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  5、使用 MapHandler 类实现：
     *      适合获取1条记录，把查询到的列名和列值封装到 Map 中
     */
    @Test
    public void testSelect6() throws Exception {
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据；只封装第一条数据
        Map<String, Object> map = queryRunner.query("select * from users", new MapHandler());

        // 遍历：key 为列名，value 为列值
        for (Map.Entry<String, Object> m : map.entrySet()) {
            System.out.println(m.getKey() + "=" + m.getValue());
        }
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  6、使用 KeyedHandler 类实现：
     *      获取多条记录，每一条记录封装到一个 Map 中，再把这个 Map 封装到另一个 Map 中，key 为指定的字段值；
     */
    @Test
    public void testSelect7() throws Exception {
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据
        // 外层 Map 的 key 是第一列的值，所以是 Object 类型(不确定)；内层 Map 的 key 是表的列名，所以是 String 类型(列名只能是字符串)；
        Map<Object, Map<String, Object>> map = queryRunner.query("select * from users", new KeyedHandler<Object>());

        // 遍历
        for (Map.Entry<Object, Map<String, Object>> mapEntry : map.entrySet()) {
            // 外层 Map 的 key 就是 id 列的值
            System.out.println("id: " + mapEntry.getValue());
            // 外层 Map 的 value，也就是内层 Map，封装的就是 一条记录数据
            for (Map.Entry<String, Object> m : mapEntry.getValue().entrySet()) {
                // 内层 Map 就是一条记录：key 就是列名，value 就是列值
                System.out.println(m.getKey() + "=" + m.getValue());
            }
            System.out.println("-----------------");
        }
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  7、使用 MapListHandler 类实现：
     *      适合获取多条记录，把每条记录封装到 Map 中，然后再把 Map 封装到 List 集合中；
     */
    @Test
    public void testSelect8() throws Exception {
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据；
        List<Map<String, Object>> list = queryRunner.query("select * from users", new MapListHandler());

        // 遍历：
        for (Map<String, Object> map : list) {
            for (Map.Entry<String, Object> m : map.entrySet()) {
                System.out.println(m.getKey() + "=" + m.getValue());
            }
            System.out.println("----------------------");
        }
    }

    /**
     * DbUtils 执行 sql 语句，查询数据
     *  8、使用 ScalarHandler 类实现：
     *      适合获取单行单列数据；
     */
    @Test
    public void testSelect9() throws Exception {
        // 创建 QueryRunner 对象，传入 数据库连接池
        QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource());

        // 执行 sql 语句，查询数据；
        // 默认获取 第一行第一列
        Object query = queryRunner.query("select * from users", new ScalarHandler<>());
        System.out.println(query);

        // 获取 第一行第二列
        Object query2 = queryRunner.query("select * from users", new ScalarHandler<>(2));
        System.out.println(query2);

        // 获取 第一行 password 列
        Object query3 = queryRunner.query("select * from users", new ScalarHandler<>("password"));
        System.out.println(query3);
    }
}

其中 C3P0Utils.java：

package com.jdbc.dbutils;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

import javax.sql.DataSource;

import com.mchange.v2.c3p0.ComboPooledDataSource;

public class C3P0Utils {
    /**
     * 创建 C3P0 连接池对象（默认加载 src 下的 c3p0-config.xml 配置文件）
     */
    private static DataSource dataSource = new ComboPooledDataSource();

    /**
     * 传出 DataSource 对象
     */
    public static DataSource getDataSource() {
        return dataSource;
    }

    /**
     * 从连接池中获取一个 数据库连接对象
     */
    public static Connection getConnection() {
        try {
            return dataSource.getConnection();
        } catch (SQLException e) {
            throw new RuntimeException();
        }
    }

    /**
     * 释放资源
     */
    public static void release(Connection conn, Statement stmt, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            rs = null;
        }
        if (stmt != null) {
            try {
                stmt.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            stmt = null;
        }
        if (conn != null) {
            try {
                conn.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
            conn = null;
        }
    }
}

其中 c3p0-config.xml：

<c3p0-config>
    <default-config>
        <property name="jdbcUrl">jdbc:mysql://localhost:3306/day17</property>
        <property name="driverClass">com.mysql.jdbc.Driver</property>
        <property name="user">root</property>
        <property name="password">root</property>
        <property name="initialPoolSize">3</property>
        <property name="maxPoolSize">10</property>
        <property name="maxIdleTime">3000</property>
    </default-config>
</c3p0-config>

其中 数据库：

其中 User.java：

package com.jdbc.dbutils;

public class User {
    private int id;
    private String username;
    private String password;

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

 

秋忆夏伤
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaWeb 使用DBUtils实现增删改查
来自师范的学渣
12-02 1902
1、创建C3p0Utils类 创建cn.itcast.jdbc.utils包 代码如下： package cn.itcast.jdbc.utils; import javax.sql.DataSource; import com.mchange.v2.c3p0.ComboPooledDataSource; public class C3p0Utils { private static D...
javaWeb(十）面向接口编程：实现DBUtils通用增删改查
PizAn的博客
12-24 532
本文涉及知识点： 元数据 面向接口编程 用到的【studentlogin/student】数据库： 元数据知识点： 元数据（Meata data ） 描述sql字符串的数据叫做元数据 数据库元数据 DatabaseMetaData 参数元数据 ParameterMetaData（用到的） 结果集元数据 ResultSetMetaData 1、实现DBUtils通用增删改： 思路...
JavaWeb之DBUtils（一）QueryRunner类对数据表的增、删、查（8种结果集处理方式）、改操作
热门推荐
麦客子
08-30 3万+
一、使用QueryRunner类,实现对数据表的 insert delete update  package com.shuhuadream.queryrunner; import java.sql.Connection; import java.sql.SQLException; import org.apache.commons.dbutils.DbUtils; import org.a
DBUtils的增删改查
彪悍的人生
09-04 342
//通用的增删改，根据args数组的长度 public void update(String sql,Object ... args){ Connection conn = null; PreparedStatement ps = null; try { conn = JDBCUtil.getConn(); ps = conn.prepareStatement(sql); for...
dbutil辅助类进行增删改查
sharesb的博客
03-01 385
Apache dbutil 这个包中有很多类，主要是下面三个 Dbutils 辅助 Queryrunner：增删改查，如果是自动向数据库提交数据，则必须实现有参的构造函数 Update() Query() 如果是查询，需要用resultsetHandler接口，有很多实现类，一个实现类对应一种不同的查询类型 （对应不同的返回值类型） QueryRunner runner=new QueryRunner(getdatasourceClass.getdatasourceFunction());..
javaweb增删改查（含源码）.zip
01-24
总的来说，"javaweb增删改查（含源码）.zip"这个项目为学习者提供了一个完整的JavaWeb应用实例，涵盖了从基础的JSP和Servlet到更高级的MVC设计模式的实践应用，同时涉及数据库操作和数据管理的核心技术。通过深入...
javaweb图书信息增删改查
12-11
在本项目"javaweb图书信息增删改查"中，初学者将有机会学习到Java Web开发的基础知识，包括如何创建一个简单的Web应用程序，以及如何处理数据库中的图书信息。这个项目的核心目标是实现对图书信息的添加、删除、修改...
dao.rar_javaweb增删_javaweb增删改查_增删改查javaweb
09-19
本项目“dao.rar”显然是一个关于使用JSP、SQL和Servlet实现javaweb应用中雇员管理的实例，涵盖了数据的增删改查（CRUD）基本操作。下面我们将详细探讨这些知识点。 1. **JSP（JavaServer Pages）**：JSP是JavaWeb...
javaweb 增删改查实例
01-31
通过以上步骤，你将能构建一个完整的JavaWeb应用，实现对MySQL数据库的增删改查功能。这是一个基础但至关重要的技能，为后续更复杂的应用开发奠定了坚实的基础。在实践中不断学习和提升，你将成为JavaWeb和MySQL的...
javaWeb通过jsp实现增删改查
11-03
接下来是“增删改查”的实现。这通常涉及到后端的数据库操作。在JavaWeb中，我们可能使用JDBC（Java Database Connectivity）来连接和操作数据库。例如，创建新记录需要调用Statement或PreparedStatement的...
31.【任务案例】使用DBUtils实现增删改查
一介书生
10-07 1070
1.创建数据库 /*创建chapter03数据库，然后在数据库中创建一个表user，具体语句如下*/ CREATE DATABASE chapter03; USE chapter03; CREATE TABLE user( id INT(3) PRIMARY KEY AUTO_INCREMENT, name VARCHAR(20) NOT NULL, password VARCHAR(20) NO...
java--使用dbuntils下的通用增删查改操作
qq_34577961的博客
02-12 206
3、自定义handler。
DBUtils之提取增删改查的通用方法(二)
zzq的博客
04-29 432
文章目录 (一)提取增删改的通用方法 (二)修改DBAssit工具类 (三)提取查询的通用方法 (一)提取增删改的通用方法 我们先试试增删改方法 然后编写一个测试类试试 其他两个方法就不测试了，只要SQL语句没有写错就没有问题了 (二)修改DBAssit工具类 (三)提取查询的通用方法 ...
DBUtils增删改查
阳宗德的博客
06-03 1070
一：JDBC的弊端： （1）数据库链接对象、sql语句操作对象，封装结果集对象，这三大对象会重复定义 （2）封装数据的代码重复，而且操作复杂，代码量大 （3）释放资源的代码重复 结果： （1）程序员在开发的时候，有大量的重复劳动。 （2）开发的周期长，效率低 二：Dbutils： 主要是封装了JDBC的代码，简化dao层的操作。 三：Dbutils快速使用指南 （1）需要导入的jar包：①MySq...
JavaWeb——使用DBUtils实现数据库的增删改查操作
最新发布
Liwo4418的博客
03-20 2689
使用DBUtils实现数据库的增删改查操作（1）了解什么是数据库连接池，会使用DBCP和C3P0数据源（2）了解DBUtils工具中常见的API（3）学会用DBUtils工具对数据进行增删改查的操作建立数据库和表，使用数据库连接池技术和DBUtils实现对进行数据库增删改查操作。（1）在JDBC的基本操作中，由于每操作一次数据库，都会执行一次创建和断开Connection对象的操作，频繁的操作Connection对象十分影响数据库的访问效率，并且增加了代码量。
Queryrunner类的使用
qq_35179214的博客
10-13 3451
使用QueryRunner 类来执行sql语句的查询与操作该类简单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。主要有三个方法： query()用于执行select update()用于执行inset/update/delete batch()批处理（不常用） queryrunnet:提供了两个构造方法 默认
DBUtils使用详解一
luxiaoyu_sdc的专栏
03-16 2万+
一, 先熟悉DBUtils的API：  简介： DbUtils是一个为简化JDBC操作的小类库。 以下使用的是最新版的commons-dbutils-1.4，先给个简介，以便迅速掌握API的使用。       整个dbutils总共才3个包： 1、包org.apache.commons.dbutils          接口摘要 ResultSetHandler
QueryRunner 进行查询的操作
qq_41995845的博客
11-18 464
Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库，使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。 import cn.xyh.util.C3P0Utils; import org.apache.commons.dbutils.QueryRunner; QueryRunner queryRunner = new QueryRunner(C3P0Utils.getDataSource()); ...
Java/JavaWeb 连接数据库完成增删改查
qq_46906413的博客
04-11 3万+
连接数据库无非就是和数据库建立连接，和前面的python连接数据库差不多。 首先在连接Java数据库的时候需要数据库的jar包，这点不同于python连接数据库 mysql的jar包 下面让我们来看看数据库是如何让连接的，是如何完成数据库的一系列操作，增删改查等… 💖Java连接数据库。 🎶1、注册驱动 Class.forName("com.mysql.jdbc.Driver"); 🎶2、获取连接 conn = DriverManager.getConnection("jdbc:mysql://

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值