自己写的一个简单的basedao

最新推荐文章于 2023-03-22 22:08:08 发布
最新推荐文章于 2023-03-22 22:08:08 发布
阅读量735 收藏
点赞数
文章标签： jsp servlet jdbc mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012768510/article/details/45179591
版权

首先说一段废话：

     1、以前没写过博客，不知道怎么写；

     2、我写的这个是有幸看了尚学堂马士兵老师的视频，最近做自己的毕业设计，用的jsp，servlet，所以脑袋一抽，就自己模仿马老师模拟hibernate那一段写的。

     3、我不是打广告的，不过火这么大只看马老师的视频，声音好。

     4、我可能水平太次，所以这个东西给初学者看的，大神可以指点，但不要喷谢谢！


下面是代码：


package com.zhao.dao;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import com.zhao.model.Pager;
import com.zhao.model.SystemContext;
import com.zhao.util.BaseDaoUtil;
import com.zhao.util.DB;

public class BaseDao {
    
    public  <T> boolean add(T t){
        
        Field[] fields = BaseDaoUtil.getFields(t);
        String tableName = BaseDaoUtil.getTableName(t);
        String sql = "insert into "+ tableName + " values(null,";
        for(int i = 1; i < fields.length; i++){
            
            if(i < (fields.length - 1)){
                sql += "?,";
            }else{
                sql += "?)";
            }
        }
System.out.println("basedao: " + sql);
        Connection conn = DB.getConn();
        PreparedStatement pstmt = DB.getPStmt(conn, sql);
        
        try {
            BaseDaoUtil.save(pstmt, t);
            pstmt.executeUpdate();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            DB.close(pstmt);
            DB.close(conn);
        }
        
        return true;
    }

    public  <T> boolean delete(int id, T t) {
        
        String tableName = BaseDaoUtil.getTableName(t);
        String sql = "delete from " + tableName + " where id = '" + id + "'";
System.out.println("basedao:" + sql);
        Connection conn = DB.getConn();
        DB.executeUpdate(conn, sql);
        return true;
    }
    
    public  <T> boolean update(T t) {
        Connection conn = DB.getConn();
        PreparedStatement pstmt = null;
        String tableName = BaseDaoUtil.getTableName(t);
        try {
            
            String sql = "update " + tableName + " set ";
            //拿到实体类中所有的属性，全部set，前台界面控制不能set的
            Field[] fields = BaseDaoUtil.getFields(t);
            int paramSize = fields.length;
            
            //拼接sql
            for(int i = 1; i < paramSize; i++){
                if(i < paramSize - 1){
                    sql += fields[i].getName() + "=?,";
                }else{
                    sql += fields[i].getName() + "=? ";
                }
            }
            sql += "where id = ?";
           
    
System.out.println("basedao:" + sql);
            
            pstmt = DB.getPStmt(conn, sql);
            //set的值
            BaseDaoUtil.save(pstmt, t);
            
            //设置where条件的id值
            Method m = t.getClass().getMethod("getId");
            Class type = m.getReturnType();
            pstmt.setInt(paramSize, (Integer) (t.getClass().getMethod("getId")).invoke(t));
            pstmt.executeUpdate();

        } catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
            return false;
        } finally {
            DB.close(pstmt);
            DB.close(conn);
        }
        return true;
    }    
    
    public <T> T loadById(T t, int id) {
        
        String tableName = BaseDaoUtil.getTableName(t);
        
        String sql = "select * from " + tableName + " where id = " + id;
System.out.println("basedao:" + sql);
        Connection conn = DB.getConn();
        ResultSet rs = DB.executeQuery(conn, sql);
        try {
            BaseDaoUtil.load(t, rs);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            DB.close(rs);
            DB.close(conn);
        }
        return t;
    }

    public  <T> T loadByName(T t, String name) {
        
        String tableName = BaseDaoUtil.getTableName(t);

        String sql = "select * from " + tableName + " where name = '" + name + "'";
System.out.print("basedao:" + sql);
        Connection conn = DB.getConn();
        ResultSet rs = DB.executeQuery(conn, sql);
        try {
            BaseDaoUtil.load(t, rs);
        } catch (NoSuchMethodException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SecurityException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IllegalArgumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            DB.close(rs);
            DB.close(conn);
        }
        return t;
    }
 
    
    public <T> List<T> listAll(T t){
        // TODO Auto-generated method stub
                String tableName =BaseDaoUtil.getTableName(t);                
                String sql = "select * from " + tableName ;
                
                Connection conn = DB.getConn();
                ResultSet rsCount = null;
                ResultSet rs = null;
                List<T> list = new ArrayList<T>();
                try {
                    
                    rs = DB.executeQuery(conn, sql);
                    BaseDaoUtil.list(t, rs, list);
            
                }catch(SQLException e){
                    e.printStackTrace();
                }catch(Exception e){
                    e.printStackTrace();
                }finally{
                    DB.close(rsCount);
                    DB.close(rs);
                    DB.close(conn);
                }
            return list;
    }
}



package com.zhao.util;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;


2、这个是配合basedao使用的，分开俩个写原因是，以后碰到dao层自己独有的方法，也可以调用这里面的方法去保存
public class BaseDaoUtil {
    
    //拿到model所有属性，包括继承的属性
    public static <T> Field[] getFields(T t){
     
        return t.getClass().getDeclaredFields();;
    }
    
    //拿到model所有的get方法名字
    public static <T> String[] getMethodsGet(T t){
        Field[] fields = getFields(t);
        //拿到每个属性对应的get方法
        String[] methodNames = new String[fields.length];
        for(int i = 0; i < fields.length; i++){
            methodNames[i] = "get"
                                            + Character.toUpperCase(fields[i].getName().charAt(0))
                                            + fields[i].getName().substring(1);
        }
//System.out.println(Arrays.toString(methodNames));
        return methodNames;
    }
    
    //拿到model中所有的set方法名
    public static <T> String[] getMethodsSet(T t){
        Field[] fields = getFields(t);
        String[] methodNames = new String[fields.length];
        for(int i = 0; i < fields.length; i++){
            methodNames[i] = "set"
                                            + Character.toUpperCase(fields[i].getName().charAt(0))
                                            + fields[i].getName().substring(1);
        }
//System.out.println(Arrays.toString(methodNames));
        return methodNames;
    }
    
    //拿到表名
    public static <T> String getTableName(T t){
        return t.getClass().getName().toLowerCase()
                .substring(t.getClass().getName().toLowerCase().lastIndexOf(".") + 1);
    }
    //通过PreparedStatement往数据库中存入数据
    public static <T> boolean save(PreparedStatement pstmt, T t) throws NoSuchMethodException,
                                                                                                                        SecurityException,
                                                                                                                        IllegalAccessException,
                                                                                                                        IllegalArgumentException,
                                                                                                                        InvocationTargetException,
                                                                                                                        SQLException{
        Field[] fields = getFields(t);
        String[] methodNames = getMethodsGet(t);
        
        for(int i = 1; i < fields.length; i++){
            
                Method m = t.getClass().getMethod(methodNames[i]);
                Class type = m.getReturnType();

//这里通过不同的方法返回值类型使用不同的方法，如果大家的model层中属性的类型都是string类型，可以不用分类，直接setObject（）我见过那样的写法，大家可以试试
                if(type.getName().equals("java.lang.String")){
                    pstmt.setString(i, (String) m.invoke(t));
                }else if(type.getName().equals("int")){
                    pstmt.setInt(i, (Integer) m.invoke(t));
                }else if(type.getName().equals("java.sql.Timestamp")){
                    pstmt.setTimestamp(i, (java.sql.Timestamp)m.invoke(t));
                }else if(type.getName().equals("java.util.Date")){
                    pstmt.setDate(i, new java.sql.Date(((java.util.Date) m.invoke(t)).getTime()));
                }
        }
        return true;
    }
    
    public static <T> void load(T t, ResultSet rs) throws SQLException,
                                                                                        NoSuchMethodException,
                                                                                        SecurityException,
                                                                                        IllegalAccessException,
                                                                                        IllegalArgumentException,
                                                                                        InvocationTargetException{
        Field[] fields = getFields(t);
        String[] methodNames = getMethodsSet(t);
        while(rs.next()){
            Method m = null;
            for(int i = 0; i < fields.length; i++){
                Type type = fields[i].getGenericType();
                if(type.toString().equals("int")){
                    m = t.getClass().getMethod(methodNames[i], int.class);
                    m.invoke(t, rs.getInt(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.lang.String")){
                    m = t.getClass().getMethod(methodNames[i], String.class);
                    m.invoke(t, rs.getString(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.sql.Timestamp")){
                    m =t.getClass().getMethod(methodNames[i], java.sql.Timestamp.class);
                    m.invoke(t, rs.getTimestamp(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.util.Date")){
                    m =t.getClass().getMethod(methodNames[i], java.util.Date.class);
                    m.invoke(t, rs.getDate(fields[i].getName().toLowerCase()));
                }
                
            }
        }
    
    }

    public static <T> void list(T t,ResultSet rs,List<T> list) throws NoSuchMethodException,
                                                                                                                SecurityException,
                                                                                                                IllegalAccessException,
                                                                                                                IllegalArgumentException,
                                                                                                                InvocationTargetException,
                                                                                                                SQLException,
                                                                                                                InstantiationException{
        Field[] fields = getFields(t);
        String[] methodNames = getMethodsSet(t);
        Method m = null;
        while(rs.next()){
            t = (T) t.getClass().newInstance();
            
            for(int i = 0; i < fields.length; i++){
                Type type = fields[i].getGenericType();
                if(type.toString().equals("int")){
                    m = t.getClass().getMethod(methodNames[i], int.class);
                    m.invoke(t, rs.getInt(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.lang.String")){
                    m = t.getClass().getMethod(methodNames[i], String.class);
                    m.invoke(t, rs.getString(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.sql.Timestamp")){
                    m =t.getClass().getMethod(methodNames[i], java.sql.Timestamp.class);
                    m.invoke(t, rs.getTimestamp(fields[i].getName().toLowerCase()));
                }else if(type.toString().equals("class java.util.Date")){
                    m =t.getClass().getMethod(methodNames[i], java.util.Date.class);
                    m.invoke(t, rs.getDate(fields[i].getName().toLowerCase()));
                }
            }
            list.add(t);
        }
    }
    
}



3、数据库

package com.zhao.util;

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

public class DB {
    static{
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static Connection getConn(){
        Connection conn = null;
        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/studentsbbs?user=root&password=root");
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return conn;
    }
    
    public static Statement getStmt(Connection conn){
        Statement stmt = null;
        try {
            stmt = conn.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return stmt;
    }
    
    public static PreparedStatement getPStmt(Connection conn, String sql){
        PreparedStatement pstmt = null;
        try {
            pstmt = conn.prepareStatement(sql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return pstmt;
    }
    public static ResultSet getRs(Statement stmt, String sql){
        ResultSet rs = null;
        try {
            stmt.executeQuery(sql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return rs;
    }
    
    public static void executeUpdate(Statement stmt, String sql) {
        try {
            stmt.executeUpdate(sql);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    
    public static void executeUpdate(Connection conn, String sql){
        Statement stmt = null;
        try {
            stmt = conn.createStatement();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        executeUpdate(stmt,sql);
    }
    
    public static ResultSet executeQuery(Connection conn, String sql){
        ResultSet rs = null;
        try {
            rs = conn.prepareStatement(sql).executeQuery();
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return rs;
    }
    public static void close(Connection conn){
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            conn = null;
        }
    }
    
    public static void close(Statement stmt){
        if(stmt != null){
            try {
                stmt.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            stmt = null;
        }
    }
    
    public static void close(ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            rs = null;
        }
    }
    
    public static int getTotalRecord(ResultSet rs){
        int totalRecord = 0;
        try {
            while(rs.next()){
                totalRecord = rs.getInt(1);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            DB.close(rs);
        }
        return totalRecord;
    }
}


离线de日常
关注
JDBC小结之封装一个简单BaseDao
BlueBee与码小姐的故事
01-14 1616
JDBC的一些简单介绍 JDBC是什么？ JDBC（Java Data Base Connection）可以为多种关系数据库提供统一访问，它由一组用Java编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序，同时，JDBC也是个商标名。 关于JDBC的设计 从一开始Sun公司就Java在数据库应用方面的巨大潜力。数据库开发商们
简单操作mysql数据库：BaseDao
qq_36257790的博客
08-06 637
一个BaseDao.java文件帮助大家简单操作mysql数据库 BaseDao.java代码块 代码： import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.S...
自己写一个DAO 实现对jdbc dbcp封装 开源小组件
09-08
本组件为本人学习研究之产物，可用于小型项目或初学者学习之用 主要实现了对数据库的基本访问，包括oracle，mysql数据库的分页查询
自己写一个BaseDao
虎小币的博客
07-05 143
通过反射可以获得实体的属性和类的名字我们就可以拼接处sql语句： //查询的万能dao public static void select(Object o){ //通过对象获取类对象 Class<? extends Object> c = o.getClass(); //获取类中的属性 Field[] fields...
自己写的Dao框架
dishuyan6762的博客
07-11 123
在使用数据库连接池的时候，每次写Dao都很烦，要写很多重复的Sql语句，还有各种针对查询好的Rs后fetch出Bean，真的让我很不能忍。 于是在经过了一下午的研究，终于针对Dao进行的封装。 废话不多说 先看Dao父类： package com.tim.DaoProject.dao; import java.beans.BeanInfo;import java.beans....
BaseDao的封装以及db.properties配置文件获取
CacaColor的博客
07-17 848
文章目录1. 继承上次的DBUtil的改写BaseDao封装1.1 针对数据库的executeQuery()的处理1.2 针对数据库的executeUpdate()的处理2.如何获取数据库连接 三种方式2.1 傻瓜式操作2.2 进行DBUtil的封装 在里面进行2.1操作2.3 获取db.properties 配置文件2.3.1 创建配置文件 简单的一3.数据库连接成功，实现登录4.总结 1. ...
(菜鸟来动手-第四天)SSM整合之BaseService,BaseDao
热门推荐
能写下来,理解才会更深
07-24 1万+
前面已经实现了SSM的整合, 但是在实际开发中,很多模块都会有增删改查操作.将这些共用操作抽取个公用的出来,能少很多事. 1.实现baseDao 2.实现baseService 3.具体模块实现 4.测试 1.实现baseDao mybatis中,实现sql都是用namespace+上 sql的id, 而namespace一般都是用model的路径+名称. 所以baseDa
自制基于MyBatis简易数据库交互组件（不需要写sql进行数据库的cudr操作）
dhero56的博客
09-19 696
Mybatis自动化生成sql组件 —by 九根刺的刺猬 自制基于mybatis简易数据库交互组件，用户引入jar包后，只要在dao层继承BaseDao类接口，就能实现类似于jpa规划似的数据库操作，无需在配置mapper.xml和写sql代码，数据通过参数传入即可。文章末尾提供jar包的下载地址，有兴趣的小伙伴可以下载试试。 一、需求背景及需求目标 1.需求背景：mybatis提供了便捷的数据库cudr操作的方式，但是传统的mybatis的使用，需要根据数据库表的映射，形成一一对应的实体类，以及创建复杂对
Ajax-简易图书管理系统
a1560231的博客
04-15 1380
初学者的的简易图书管理系统
Mybatis常见的一些面试题
HoneGe的博客
04-06 415
Mybatis一些常见的面试题 1.什么是Mybatis？(重点) （1）Mybatis是一个半ORM（对象关系映射）框架，它内部封装了JDBC，开发时只需要关注SQL语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement等繁杂的过程。程序员直接编写原生态sql，可以严格控制sql执行性能，灵活度高。 （2）MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJ...
JSP basedao
06-29
basedao 操作数据库专用类，可以参考参考哦。其实BASEDAO都是大同小异的。
BaseDao标准模板
07-22
BaseDao标准模板
自己动手写泛型dao
weixin_33951761的博客
11-11 85
在经过一系列的问题得到解决之后，泛型dao终于写出来了。泛型dao相比于以前写的dao最大的好处就是，大大提高了代码的复用性，以往我们要对数据库中表中的数据进行操作的时候，每张表都需要写一个dao来操作，当表非常多的时候，代码量就会很大，还有就是这些代码大部分都是重复的，获取数据库连接、s...
java BaseDao基本代码
CSDN9520的博客
05-31 420
java
#MyBatis入门 @FDDLC
LiuXingchang的博客
10-06 266
入门步骤： 0：新建Maven工程，导入Maven依赖：mysql-connector-java、mybatis、junit。 1.1、准备好数据库，新建account表(id，name，money)，填充若干条记录。 1.2、编写account表对应的实体类Account{Integer id; String name; Double money;} 2.1、编写AccountDao接口：List<Account> findAll(); 2.2、编写AccountMapp..
Java反射机制 完成通用的BaseDao
jjccblws01的博客
08-23 327
通用的BaseDaoConnectionPool 方法BaseDao 接口接口 BaseDao 的实现类 BaseDaoImpl一个工具类 UtilToolsstudent 类测试类 只是简单的练习了一下如何写一个通用的BaseDao的增删改查。 ConnectionPool 方法 两个静态方法： getConnection()，用来得到一个连接。 close(Connection connection, Statement state, ResultSet reS)，用于关闭资源。 package co
刚学的jsp BaseDao
Just_Fine_Blue_Sky的专栏
01-24 638
   感觉这个BaseDao还是挺专业的，是好东西。public class BaseDao { private static final String driverName = "com.microsoft.sqlserver.jdbc.SQLServerDriver"; private static final String url = "jdbc:sqlserver://localhost:1433;databaseName=playlist(数据库名称)"; private static final
oracle BaseDao
zyy871020的专栏
08-03 1372
import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; public class BaseDao { String url="jdbc:ora
【JDBC】如何编写一个通用的BaseDao？
w13346019869的博客
03-22 261
利用反射机制获取类属性信息，进行填充sql。
帮我用java写一个 basedao
最新发布
03-29
抱歉，我无法为您提供完整的基于Java的BaseDao代码，因为BaseDao的实现可能因不同的应用程序而异。 但是，我可以提供一个基本的代码框架，以便您可以开始编写您自己的BaseDao类。 ```java public abstract class BaseDao<T> { private final Connection connection; public BaseDao(Connection connection) { this.connection = connection; } protected abstract String getTableName(); protected abstract T fromResultSet(ResultSet resultSet) throws SQLException; public List<T> findAll() throws SQLException { String query = "SELECT * FROM " + getTableName(); List<T> entities = new ArrayList<>(); try (PreparedStatement statement = connection.prepareStatement(query)) { ResultSet resultSet = statement.executeQuery(); while (resultSet.next()) { T entity = fromResultSet(resultSet); entities.add(entity); } } return entities; } public T findById(int id) throws SQLException { String query = "SELECT * FROM " + getTableName() + " WHERE id = ?"; try (PreparedStatement statement = connection.prepareStatement(query)) { statement.setInt(1, id); ResultSet resultSet = statement.executeQuery(); if (resultSet.next()) { return fromResultSet(resultSet); } } return null; } public void save(T entity) throws SQLException { // implement saving entity to database } public void update(T entity) throws SQLException { // implement updating entity in database } public void delete(T entity) throws SQLException { // implement deleting entity from database } } ``` 这是一个基本的BaseDao类，它使用Java的泛型来支持不同类型的实体对象。它包括以下方法： - `findAll()` - 返回一个包含所有实体对象的列表。 - `findById(int id)` - 根据ID返回一个实体对象。 - `save(T entity)` - 将一个实体对象保存到数据库中。 - `update(T entity)` - 更新一个实体对象在数据库中的记录。 - `delete(T entity)` - 从数据库中删除一个实体对象。 您需要根据您的应用程序的需要实现这些方法，以便BaseDao类能够正常工作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值