数据库连接JDBC

已于 2022-05-05 10:06:00 修改
阅读量1.7k 收藏
点赞数
分类专栏： JavaEE 文章标签： JDBC CRUD JavaEE 事务 SQL注入攻击
于 2021-11-28 15:21:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45477086/article/details/121575842
版权
本文详细介绍了JDBC的概念、用途及快速入门程序，包括注册驱动、获取连接、执行SQL语句等步骤。同时，讨论了JDBC的异常处理，指出旧版驱动已弃用，建议使用新版驱动。还展示了JDBC如何实现CRUD操作，并提供了完整的代码示例，包括StudentDao和StudentService的接口与实现。最后提到了SQL注入攻击及其防范措施——使用PreparedStatement。
摘要由CSDN通过智能技术生成
JDBC：
  • JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系型数据库提供统一访问，它是由一组用Java语言编写的类和接口组成的。
  • 其实就是java官方提供的一套规范(接口)。用于帮助开发人员快速实现不同关系型数据库的连接！
jdbc的快速入门程序：

需要先导入JDBC的jar包

public class JdbcDemo {
    public static void main(String[] args) throws ClassNotFoundException, SQLException {
        // 注册驱动
        Class.forName("com.mysql.cj.jdbc.Driver");

        // 获取连接
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db2", "root", "itzhuzhu");

        // 获取执行者对象
        Statement statement = connection.createStatement();

        // 执行sql语句，并接收返回结果
        String sql = "SELECT * FROM user";
        ResultSet resultSet = statement.executeQuery(sql);

        // 处理结果
        while (resultSet.next()) {
            System.out.println(resultSet.getInt("id") + "\t" + resultSet.getString("name"));
        }
        // 释放资源
        connection.close();
        statement.close();
        resultSet.close();
    }
}

运行异常：

提示“com.mysql.jdbc.Drive”已经被弃用了，有新的驱动类可以使用，换成这个就可以了“com.mysql.cj.jdbc.Driver”，即使不换也不会影响运行，只是会提示。

Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.

如果遇到这个异常，可能是你的版本问题，idea和mysql的版本要对应，驱动也是，下载个新的驱动https://dev.mysql.com/downloads/file/?id=500651

Exception in thread "main" com.mysql.jdbc.exceptions.jdbc4.CommunicationsException: Communications link failure   The last packet sent successfully to the server was 0 milliseconds ago. The
JDBC各个功能类详解：
DriverManager:

1. DriverManager：驱动管理对象

注册驱动(告诉程序该使用哪一个数据库驱动)

  • static void registerDriver(Driver driver)：注册与给定的驱动程序 DriverManager
  • 写代码使用：Class.forName(“com.mysql.jdbc.Driver”)，因为Driver类中已经写了注册驱动
  • 通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块
static {
	try {
		java.sql.DriverManager.registerDriver(new Driver());
	} catch (SQLException E) {
		throw new RuntimeException("Can't register driver!");
	}
}

注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。在jar包中，存在一个java.sql.Driver配置文件，文件中指定了com.mysql.jdbc.Driver

2. 获取数据库连接(获取到数据库的连接并返回连接对象)

  • static Connection getConnection(String url, String user, String password);
    • 返回值：Connection数据库连接对象
    • 参数
      • url：指定连接的路径。语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
      • user：用户名
      • password：密码
Connection：

Connection：数据库连接对象

  • 获取执行者对象
    • 获取普通执行者对象：Statement createStatement();也就是执行SQL语句的
    • 获取预编译执行者对象：PreparedStatement prepareStatement(String sql);
  • 管理事务
    • 开启事务：setAutoCommit(boolean autoCommit); 参数为false，则开启事务。
    • 提交事务：commit();
    • 回滚事务：rollback();
  • 释放资源
    • 立即将数据库连接对象释放：void close();
Statement：

Statement：执行sql语句的对象

  • 执行DML(增删改)语句：int executeUpdate(String sql);
    • 返回值int：返回影响的行数。
    • 参数sql：可以执行insert、update、delete语句。
  • 执行DQL(查询)语句：ResultSet executeQuery(String sql);
    • 返回值ResultSet：封装查询的结果。
    • 参数sql：可以执行select语句。
  • 释放资源
    • 立即将执行者对象释放：void close();
ResultSet：

ResultSet：结果集对象

  • 判断结果集中是否还有数据：boolean next();
    • 有数据返回true，并将索引向下移动一行
    • 没有数据返回false
  • 获取结果集中的数据：XXX getXxx(“列名”);
    • XXX代表数据类型(要获取某列数据，这一列的数据类型)
    • 例如：String getString(“name”); int getInt(“age”);
  • 释放资源
    • 立即将结果集对象释放：void close();
JDBC练习CRUD：
数据准备：

sql语句：

-- 创建student表
CREATE TABLE student(
	sid INT PRIMARY KEY AUTO_INCREMENT,	-- 学生id
	NAME VARCHAR(20),					-- 学生姓名
	age INT,							-- 学生年龄
	birthday DATE						-- 学生生日
);

-- 添加数据
INSERT INTO student VALUES (NULL,'张三',23,'1999-09-23'),(NULL,'李四',24,'1998-08-10'),(NULL,'王五',25,'1996-06-06'),(NULL,'赵六',26,'1994-10-20');

实体类：

自定义类的功能是为了封装表中每列数据，成员变量和列要保持一致
注意：所有的基本数据类型需要使用包装类，以防null值无法赋值

public class Student {
    private Integer sid;
    private String name;
    private Integer age;
    private Date birthday;

    public Student() {
    }

    public Student(Integer sid, String name, Integer age, Date birthday) {
        this.sid = sid;
        this.name = name;
        this.age = age;
        this.birthday = birthday;
    }

    public Integer getSid() {
        return sid;
    }

    public void setSid(Integer sid) {
        this.sid = sid;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "Student{" +
                "sid=" + sid +
                ", name='" + name + '\'' +
                ", age=" + age +
                ", birthday=" + birthday +
                '}';
    }
}

StudentDao

public interface StudentDao {
    
    /**
     * 查询所有学生信息
     *
     * @return 返回一个学生数组
     */
    ArrayList<Student> findAll();

    /**
     * 根据id查询学生信息
     *
     * @param id 根据id查询
     * @return 返回学生类对象，根据id查询
     */
    Student findById(Integer id);

    /**
     * 添加学生
     *
     * @param stu：学生类
     * @return 返回int类型的结果，也就是影响行数
     */
    int insert(Student stu);

    /**
     * 修改学生
     *
     * @param stu：学生类
     * @return 返回int类型的结果，也就是影响行数
     */
    int update(Student stu);

    /**
     * 删除学生
     *
     * @param id:根据指定id删除
     * @return 返回int类型的结果，也就是影响行数
     */
    int delete(Integer id);
}

StudentDaoImpl

public class StudentDaoImpl implements StudentDao {

    @Override
    public ArrayList<Student> findAll() {
        ArrayList<Student> list = new ArrayList<>();
        Connection conn = null;
        PreparedStatement pstm = null;
        ResultSet rs = null;
        try {
            // 获取连接
            conn = JDBCUtils.getConnection();
            pstm = conn.prepareStatement("SELECT * FROM student");
            // 执行sql语句，并接收返回结果
            rs = pstm.executeQuery();
            // 处理结果
            while (rs.next()) {
                int sid = rs.getInt("sid");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                Date birthday = rs.getDate("birthday");

                // 封装student对象,把student对象保存到结合中
                Student stu = new Student(sid, name, age, birthday);
                list.add(stu);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(conn, pstm, rs);
        }
        return list;
    }

    @Override
    public Student findById(Integer id) {
        Student stu = new Student();
        PreparedStatement pstm = null;
        Connection conn = null;
        ResultSet rs = null;
        try {
            conn = JDBCUtils.getConnection();
            // 获取执行者对象
            pstm = conn.prepareStatement("SELECT * FROM student WHERE sid='" + id + "'");
            // 执行sql语句，并接收返回结果
            rs = pstm.executeQuery();
            // 处理结果
            while (rs.next()) {
                int sid = rs.getInt("sid");
                String name = rs.getString("name");
                int age = rs.getInt("age");
                Date birthday = rs.getDate("birthday");

                // 封装student对象,把student对象保存到结合中
                stu.setSid(sid);
                stu.setName(name);
                stu.setAge(age);
                stu.setBirthday(birthday);
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(conn, pstm, rs);
        }
        return stu;
    }


    @Override
    public int insert(Student stu) {
        Connection conn = null;
        PreparedStatement pstm = null;
        int result = 0;
        try {
            conn = JDBCUtils.getConnection();
            // 获取执行者对象
            // 执行sql语句，并接收返回结果
            Date d = stu.getBirthday();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            String birthday = sdf.format(d);
            pstm = conn.prepareStatement("INSERT INTO student VALUES ('" + stu.getSid() + "','" + stu.getName() + "','" + stu.getAge() + "','" + birthday + "')");
            // executeUpdate可以返回影响的行数，赋值给result
            result = pstm.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(conn, pstm);
        }
        return result;
    }

    @Override
    public int update(Student stu) {
        Connection conn = null;
        PreparedStatement pstm = null;
        int result = 0;
        try {
            conn = JDBCUtils.getConnection();
            // 获取执行者对象
            // 执行sql语句，并接收返回结果
            Date d = stu.getBirthday();
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
            String birthday = sdf.format(d);
            pstm = conn.prepareStatement("UPDATE student SET sid='" + stu.getSid() + "',name='" + stu.getName() + "',age='" + stu.getAge() + "',birthday='" + birthday + "' WHERE sid='" + stu.getSid() + "'");
            result = pstm.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(conn, pstm);
        }
        return result;
    }

    @Override
    public int delete(Integer id) {
        Connection conn = null;
        PreparedStatement pstm = null;
        int result = 0;
        try {
            conn = JDBCUtils.getConnection();
            // 获取执行者对象
            pstm = conn.prepareStatement("DELETE FROM student WHERE sid='" + id + "'");
            // 执行sql语句，并接收返回结果 + id + "
            result = pstm.executeUpdate();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            JDBCUtils.close(conn, pstm);
        }
        return result;
    }
}

StudentService

public interface StudentService {
    /**
     * 查询所有学生信息
     *
     * @return 返回一个学生数组
     */
    ArrayList<Student> findAll();

    /**
     * 根据id查询学生信息
     *
     * @param id 根据id查询
     * @return 返回学生类对象，根据id查询
     */
    Student findById(Integer id);

    /**
     * 添加学生
     *
     * @param stu：学生类
     * @return 返回int类型的结果，也就是影响行数
     */
    int insert(Student stu);

    /**
     * 修改学生
     *
     * @param stu：学生类
     * @return 返回int类型的结果，也就是影响行数
     */
    int update(Student stu);

    /**
     * 删除学生
     *
     * @param id:根据指定id删除
     * @return 返回int类型的结果，也就是影响行数
     */
    int delete(Integer id);
}

StudentServiceImpl

public class StudentServiceImpl implements StudentService {
    private StudentDao dao = new StudentDaoImpl();

    @Override
    public ArrayList<Student> findAll() {
        return dao.findAll();
    }

    @Override
    public Student findById(Integer id) {
        return dao.findById(id);
    }

    @Override
    public int insert(Student stu) {
        return dao.insert(stu);
    }

    @Override
    public int update(Student stu) {
        return dao.update(stu);
    }

    @Override
    public int delete(Integer id) {
        return dao.delete(id);
    }
}

JDBCUtils：工具类

public class JDBCUtils {
    /**
     * 1.私有构造方法
     */
    private JDBCUtils() {
    }

    // 2.声明配置信息变量
    private static String driverClass;
    private static String url;
    private static String username;
    private static String password;
    private static Connection con;

    // 3.静态代码块中实现加载配置文件和注册驱动
    static {
        try {
            // 通过类加载器返回配置文件的字节流
            // getClassLoader().getResourceAsStream:通过给定名称查找资源，查询资源的规则由给定的类的class load来实现，这个方法由类的loader来执行；如果这个类由bootstrap加载，那么方法由ClassLoader.getSystemResourceAsStream代理执行。
            InputStream is = JDBCUtils.class.getClassLoader().getResourceAsStream("config.properties");

            // 创建Properties集合，加载流对象的信息
            Properties prop = new Properties();
            prop.load(is);

            // 获取信息为变量赋值
            driverClass = prop.getProperty("driverClass");
            url = prop.getProperty("url");
            username = prop.getProperty("username");
            password = prop.getProperty("password");

            // 注册驱动
            Class.forName(driverClass);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    //4.获取数据库连接的方法
    public static Connection getConnection() {
        try {
            con = DriverManager.getConnection(url, username, password);
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return con;
    }

    //5.释放资源的方法
    public static void close(Connection con, Statement stat, ResultSet rs) {
        if (con != null) {
            try {
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (stat != null) {
            try {
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }

        if (rs != null) {
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static void close(Connection con, Statement stat) {
        close(con, stat, null);
    }
}

config.properties：配置文件

driverClass=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/db2
username=root
password=itzhuzhu

Controller

public class StudentControllerTest {
    StudentService service = new StudentServiceImpl();

    @Test
    public void findAll() {
        ArrayList<Student> list = service.findAll();
        for (Student stu : list) {
            System.out.println(stu);
        }
    }

    @Test
    public void findById() {
        Student student = service.findById(3);
        System.out.println(student);
    }

    @Test
    public void insert() {
        Student stu = new Student(5,"周七",27,new Date());
        int result = service.insert(stu);
        if(result != 0) {
            System.out.println("新增成功");
        }else {
            System.out.println("新增失败");
        }
    }

    @Test
    public void update() {
        Student stu = service.findById(5);
        stu.setName("周七七");

        int result = service.update(stu);
        if(result != 0) {
            System.out.println("修改成功");
        }else {
            System.out.println("修改失败");
        }
    }

    @Test
    public void delete() {
        int result = service.delete(5);

        if(result != 0) {
            System.out.println("删除成功");
        }else {
            System.out.println("删除失败");
        }
    }
}
SQL注入攻击：

sql注入攻击案例：

在登录界面，输入一个错误的用户名/密码，但是使用任意字符 'or '1' = '1就可以登录成功

sql注入攻击的原理：

  • 按照正常道理来说，我们在密码处输入的所有内容，都应该认为是密码的组成
  • 但是现在Statement对象在执行sql语句时，将一部分内容当做查询条件来执行了，就会出现SQL注入攻击
PreparedStatement：
  • 预编译sql语句的执行者对象。在执行sql语句之前，将sql语句进行提前编译。明确sql语句的格式后，就不会改变了。剩余的内容都会认为是参数！参数使用?作为占位符
  • 为参数赋值的方法：setXxx(参数1,参数2);
    • 参数1：?的位置编号(编号从1开始)
    • 参数2：?的实际参数
  • 执行sql语句的方法
    • 执行insert、update、delete语句：int executeUpdate();
    • 执行select语句：ResultSet executeQuery();
@Override
public User findByLoginNameAndPassword(String loginName, String password) {
    //定义必要信息
    Connection conn = null;
    PreparedStatement pstm = null;
    ResultSet rs = null;
    User user = null;
    try {
        //1.获取连接
        conn = JDBCUtils.getConnection();
        //2.创建操作SQL对象
        String sql = "SELECT * FROM user WHERE loginname=? AND password=?";
        pstm = conn.prepareStatement(sql);
        //3.设置参数
        pstm.setString(1,loginName);
        pstm.setString(2,password);
        System.out.println(sql);
        //4.执行sql语句，获取结果集
        rs = pstm.executeQuery();
        //5.获取结果集
        if (rs.next()) {
            //6.封装
            user = new User();
            user.setUid(rs.getString("uid"));
            user.setUcode(rs.getString("ucode"));
            user.setUsername(rs.getString("username"));
            user.setPassword(rs.getString("password"));
            user.setGender(rs.getString("gender"));
            user.setDutydate(rs.getDate("dutydate"));
            user.setBirthday(rs.getDate("birthday"));
            user.setLoginname(rs.getString("loginname"));
        }
        //7.返回
        return user;
    }catch (Exception e){
        throw new RuntimeException(e);
    }finally {
        JDBCUtils.close(conn,pstm,rs);
    }
}
JDBC事务：

管理事务的功能类：Connection

  • 开启事务：setAutoCommit(boolean autoCommit);参数为false，则开启事务。
  • 提交事务：commit();
  • 回滚事务：rollback();
itzhuzhu.
关注
专栏目录
完整java连接数据库步骤
qq_44231628的博客
01-11 437
完整java连接数据库步骤
JDBC数据库连接
weixin_67707901的博客
06-08 139
JDBC相关知识
JDBC（Java数据库连接）
qq_51234063的博客
10-19 495
1、JDBC快速入门 1.1 jdbc的概念 - JDBC（Java DataBase Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，可以为多种关系型数据库提供统一访问，它是由一组用Java语言编写的类和接口组成的。 1.2 jdbc的本质 - 其实就是java官方提供的一套规范(接口)。用于帮助开发人员快速实现不同关系型数据库的连接！ 1.3 jdbc的快速入门程序 1.3.1 导入jar包 1.3.2 注册驱动 Class.forNa..
数据库连接jdbc
08-03
几种常用的数据库jdbc: oracle:ojdbc6.jar; mysql:mysql-connector-java-5.1.43-bin.jar; sqlserver:sqlServer-jdbc-6.2.1.jre8.jar
第11章 Java 数据库连接JDBC.ppt
06-08
第11章 Java 数据库连接JDBC
数据库连接 jdbc
11-10
数据库连接是计算机应用程序与数据库系统之间建立通信的桥梁，使得数据能够被检索、处理和存储。在Java中，我们通常使用Java Database Connectivity (JDBC) API来实现这种连接。JDBC是一个Java API，它允许Java应用...
达梦数据库JDBC连接驱动
02-15
达梦数据库JDBC连接驱动： 1. dm8-oracle-jdbc16-wrapper.jar 2. DmJdbcDriver16.jar 3. DmJdbcDriver17.jar 4. DmJdbcDriver18.jar
【Java|数据库】使用JDBC连接数据库 (超详细)
Xav Pun的博客
12-08 3万+
目录【Java|数据库】使用JDBC连接数据库 (超详细)1. 基础概念架构规范2. 连接数据库准备工作导入jar包加载驱动建立连接执行语句释放连接3. 连接数据库实例在程序里配置连接信息在配置文件里配置连接信息4. 增删改查查询增加、修改、删除Statement接口PreparedStatement接口ResultSet接口ResultSetMetaData接口参考文章 【Java|数据库】使用JDBC连接数据库 (超详细) 1. 基础 概念 JDBC的全称是Java Database Connecti
jdbc连接数据库
10-15
java连接数据库，从连接驱动到数据库用户到连接最后的datebase，sql语句对数据库的操作。
JDBC —— 数据库连接
m0_62969222的博客
06-24 321
JDBC全称为,直译过来就是Java数据库连接。它由一组用Java语言编写的类和接口组成。各种不同类型的数据库都有相应的实现。我们要连接数据库，就要去相应的数据库官网下载驱动，驱动都是以jar包的形式存在，jar包当中有很多.class文件，这些class文件就是JDBC接口的实现。本文针对MySQL数据库的连接实现。数据库连接完整代码如下： 在注册驱动时，我们现在并不会这样写，因为com.mysql.cj.jdbc.Driver类的源码中有如下静态代码块： 我们在这里简单的利用数据库实现一个账号的登录。
JDBC 和数据库连接
最新发布
业精于勤，荒于嬉
06-24 811
JDBC程序中当一个Connection对象创建时，默认情况下是自动提交事务：每次执行一个SQL语句时，如果执行成功，就会向数据库自动提交，而不能回滚。JDBC程序中为了让多个SQL语句作为一个整体执行，需要使用事务调用 Connection的 setAutoCommit（false）可以取消自动提交事务在所有的SQL语句都成功执行后，调用Connection的commit（）；方法提交事务在其中某个操作失败或出现异常时，调用Connection的 rollback（）；方法回滚事务。
JDBC连接数据库的方式
jzzw的博客
05-30 236
JDBC连接数据库的方式： Oracle篇： 1.jdbc:oracle:thin:@host:port:SID 2.jdbc:oracle:thin:@//host:port/service_name 3.jdbc:oracle:thin:@TNSName Mysql篇： jdbc:mysql://host:port/dbname?
JDBC 连接 MySQL
热门推荐
程序猿追的博客
04-18 10万+
JDBC 是 Java DataBase Connectivity (Java 数据连接)技术的简称，是一种可用于执行SQL 语句的 Java API。它由一些 java 语言编写的类和接口组成；程序员通过使用 jdbc 可以方便地将 SQL 语句传送给几乎任何一种数据库。......
java如何通过jdbc连接数据库_如何用jdbc连接数据库 java连接数据库的五步
weixin_42497772的博客
03-01 292
用JDBC连接数据库本文用sqlserver2000为例先简述JDBC连接数据库的五步1，加载驱动。这里的驱动是根据各个数据的情况有所不同，但是格式一样，一般用Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");2，创建连接。DriverManager.getConnection(url, userName, password...
idea连接MySQL出现com.mysql.jdbc.Driver已被弃用，错误解决两种方法
weixin_45917610的博客
06-01 2038
Loading class com.mysql.jdbc.Driver'. This is deprecated. The new driver class iscom.mysql.cj.jdbc.Driver’. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary. 翻译： 加载类com.mysql.jdbc.Driver'。 这
Java数据库连接JDBC全面解析
4. **面向对象**：JDBC允许开发者将数据库连接和操作封装到自定义类中，提高代码复用和管理性。 然而，JDBC也存在一些不足： 1. **性能影响**：相比直接使用数据库提供的原生API，JDBC的性能可能稍逊一筹，因为多...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

itzhuzhu.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值