oracle达梦数据迁移功能开发

最新推荐文章于 2024-05-15 12:21:34 发布
最新推荐文章于 2024-05-15 12:21:34 发布
阅读量219 收藏
点赞数
分类专栏： javaweb 文章标签： oracle java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/machangfengjia/article/details/108646730
版权

在使用达梦的迁移工具dts迁移oracle数据时有个数据表一直未能迁移成功，找达梦技术支持未能解决，遂开发此功能。可在此基础之上扩展其他数据库应用及迁移的数据类型。用到的包有ojdbc6.jar，fastjson-1.2.73.jar，Dm7JdbcDriver18.jar，暂时解决问题，供以后使用。

package cn.topnet;


import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;

import java.io.*;
import java.sql.*;
import java.sql.Date;
import java.text.SimpleDateFormat;
import java.util.*;

public class Main {

    static int onceReadRows = 8000;//每次读取8000条默认
    static List<String> columnsList = null;
    static List<String> columnsTypeList = null;
    static SimpleDateFormat simpleDateFormat = null;

    static int onceCurrRows = 0;

    public static void main(String[] args) {
        Connection fromCon, toCon;
        int fromDBType = 0, toDBType = 0;
        PageEntity pageEntity = new PageEntity();
        // write your code here
        String currPath = null, tempFiles = null;
        try {
            currPath = new File(".").getCanonicalPath();
        } catch (IOException e) {
            e.printStackTrace();
        }
        if (currPath != null && currPath.length() > 0) {
            tempFiles = currPath + "\\temp\\temp.config";
        }
        simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
        //读取配置文件
        BufferedReader reader = null;
        if (tempFiles != null) {
            System.out.println("config path:" + tempFiles);
            File file = new File(tempFiles);
            Long fileLengthLong = file.length();
            char[] fileContent = new char[fileLengthLong.intValue()];
            try {
                String config = "", tempStr = null;
                String[] tempArr = null;
                reader = new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
                while ((tempStr = reader.readLine()) != null) {
                    config += tempStr;
                }
                if (config != null) {
                    //解析配置文件
                    JSONObject jsonObject = JSON.parseObject(config);
                    if (jsonObject.containsKey("fromDB") && jsonObject.containsKey("toDB") && jsonObject.containsKey("tables")) {
                        fromCon = getJdbcCon(jsonObject.getJSONObject("fromDB"));
                        fromDBType = jsonObject.getJSONObject("fromDB").getIntValue("dbtype");
                        if (fromCon != null && !fromCon.isClosed()) {
                            System.out.println("source DB Connectioned");
                        } else {
                            System.out.println("source DB Open err!");
                        }
                        toCon = getJdbcCon(jsonObject.getJSONObject("toDB"));
                        toDBType = jsonObject.getJSONObject("toDB").getIntValue("dbtype");
                        if (toCon != null && !toCon.isClosed()) {
                            System.out.println("aim DB Connectioned");
                        } else {
                            System.out.println("aim DB Open err!");
                        }
                        if (fromCon != null && toCon != null) {
                            JSONArray tables = jsonObject.getJSONArray("tables");

                            if (tables != null) {
                                for (int i = 0; i < tables.size(); i++) {
                                    String tabName = tables.getJSONObject(i).getString("name");
                                    //数据开始条数
                                    int startRows = 0;
                                    onceReadRows = 8000;
                                    if (tables.getJSONObject(i).containsKey("startrows")) {
                                        startRows = tables.getJSONObject(i).getIntValue("startrows");
                                    }
                                    if (tables.getJSONObject(i).containsKey("oncereadrows") && tables.getJSONObject(i).getIntValue("oncereadrows") > 0) {
                                        onceReadRows = tables.getJSONObject(i).getIntValue("oncereadrows");
                                    }
                                    pageEntity.setNextReadRows(startRows);
                                    pageEntity.setCurrRows(startRows);
                                    JSONArray columns = tables.getJSONObject(i).getJSONArray("columns");
                                    //查询语句
                                    String selSql = "";
                                    String selcolu = "";
                                    //取总条数
                                    String selCountSql = "select count(*) from " + tabName + " ";
                                    columnsList = new ArrayList<>();
                                    columnsTypeList = new ArrayList<>();
                                    for (int j = 0; j < columns.size(); j++) {
                                        tempArr = columns.getString(j).split("_");
                                        columnsList.add(tempArr[0]);
                                        columnsTypeList.add(tempArr[1]);
                                        selcolu += tempArr[0] + ",";
                                    }
                                    if (selcolu != null && selcolu.length() > 0) {
                                        selSql = "select " + selcolu.substring(0, selcolu.length() - 1) + " from " + tabName + " ";
                                    }
                                    if (columnsList.size() == columnsTypeList.size() || columnsTypeList.size() > 0) {
                                        System.out.println("ready migration table data table name:" + tabName);
                                        int totalRows = getDataCount(fromCon, selCountSql);
                                        PreparedStatement statement = null;
                                        PreparedStatement writeStatement = null;
                                        ResultSet rs = null;

                                        //取总条数
                                        pageEntity.setTotalRows(totalRows);
                                        while (pageEntity.getTotalRows() > pageEntity.getNextReadRows()) {
                                            tempStr = getPageSql(pageEntity, selSql, fromDBType);
                                            if (tempStr != null && tempStr.length() > 0) {
                                                System.out.println("ready:" + pageEntity.getCurrRows() + "~" + pageEntity.getNextReadRows() + "  total:" + pageEntity.getTotalRows() + "  surplus:" + (pageEntity.getTotalRows() - pageEntity.getCurrRows()));
                                                //读数据时的
                                                statement = fromCon.prepareStatement(tempStr);
                                                //获取数据
                                                rs = getSqlResult(statement, tempStr);
                                                //获取插入数据模板
                                                writeStatement = GetInsertPreparedStatement(tabName, columnsList, columnsTypeList, rs, toCon);
                                                onceCurrRows = 0;
                                                while (rs.next()) {
                                                    //拼装单条插入数据
                                                    GetDataStatement(writeStatement, columnsList, columnsTypeList, rs);
                                                    writeStatement.addBatch();
                                                    //SaveSelSql(tabName, columnsList, columnsTypeList, rs, toCon);
                                                    onceCurrRows++;
                                                }

                                                if (rs != null) {
                                                    rs.close();
                                                }
                                                if (writeStatement != null) {
                                                    writeStatement.executeBatch();
                                                    writeStatement.close();
                                                }
                                                if (statement != null) {
                                                    statement.close();
                                                }
                                                System.out.println(simpleDateFormat.format(new java.util.Date()) + "  insert:" + pageEntity.getCurrRows() + "~" + pageEntity.getNextReadRows() + "completed" + "  total:" + pageEntity.getTotalRows() + "  surplus:" + (pageEntity.getTotalRows() - pageEntity.getCurrRows()));
                                            }
                                        }
                                        System.out.println("table name:" + tabName + " import data completed！ready check data");
                                        totalRows = getDataCount(toCon, selCountSql);
                                        int differCount = 0;
                                        boolean dataInsertSucess = true;
                                        differCount = pageEntity.getTotalRows() - totalRows;
                                        if (differCount != 0) {
                                            dataInsertSucess = false;
                                        }
                                        System.out.println("source rows total:" + pageEntity.getTotalRows() + "  aim rows total:" + totalRows + " differ:" + differCount);
                                        int stotalRows = 0;
                                        for (int j = 0; j < columnsList.size(); j++) {
                                            totalRows = getDataCount(toCon, selCountSql + " where " + columnsList.get(j) + " is null");
                                            stotalRows = getDataCount(fromCon, selCountSql + " where " + columnsList.get(j) + " is null");
                                            differCount = stotalRows - totalRows;
                                            System.out.printf("source rowsName :%s total null:%d  aim total null:%d differ:%d ", columnsList.get(j), stotalRows, totalRows, differCount);
                                            System.out.println();
                                            if (differCount != 0) {
                                                dataInsertSucess = false;
                                            }
                                        }
                                        if (dataInsertSucess) {
                                            System.out.println("*********** tablename " + tabName + " data migration sucess!!");
                                        } else {
                                            System.out.println("*********** tablename " + tabName + " Data migration may be wrong please checked!!");
                                        }
                                        System.out.println();
                                        System.out.println();
                                    }
                                }

                            }
                        }
                        if (fromCon != null && !fromCon.isClosed()) {
                            fromCon.close();
                        }

                        if (toCon != null && !toCon.isClosed()) {
                            toCon.close();
                        }
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 获取数据条数
     *
     * @param conn
     * @param sql
     * @return
     */
    private static int getDataCount(Connection conn, String sql) {
        PreparedStatement statement = null;
        ResultSet rs = null;
        int rtn = 0;
        try {
            statement = conn.prepareStatement(sql);
            rs = getSqlResult(statement, sql);
            if (rs.next()) {
                rtn = rs.getInt(1);
            }
            if (rs != null) {
                rs.close();
            }
            if (statement != null) {
                statement.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return rtn;
    }

    /**
     * 获取插入的PreparedStatement单条数据
     *
     * @param statement
     * @param columns
     * @param columnsTypeList
     * @param rs
     * @return
     */
    private static boolean GetDataStatement(PreparedStatement statement, List<String> columns, List<String> columnsTypeList, ResultSet rs) {
        for (int i = 0; i < columnsTypeList.size(); i++) {
            getPrepart(statement, columns.get(i), i + 1, columnsTypeList.get(i), rs);
        }
        return true;
    }

    /**
     * 获取原始PreparedStatement模板
     *
     * @param tableName       表名
     * @param columns         列表list
     * @param columnsTypeList 列typelist
     * @param rs              要插入的数据游标
     * @param conn            目标库连接
     * @return
     */
    private static PreparedStatement GetInsertPreparedStatement(String tableName, List<String> columns, List<String> columnsTypeList, ResultSet rs, Connection conn) {
        String sql = "insert into " + tableName + "(";
        String valSql = "values(";
        PreparedStatement statement = null;
        try {
            if (rs != null) {
                for (int i = 0; i < columns.size(); i++) {
                    sql += columns.get(i) + ",";
                    valSql += "?,";
                }
                if (sql.endsWith(",")) {
                    sql = sql.substring(0, sql.length() - 1) + ")";
                }
                if (valSql.endsWith(",")) {
                    valSql = valSql.substring(0, valSql.length() - 1) + ")";
                }
                sql = sql + valSql;
                statement = conn.prepareStatement(sql);
                return statement;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 保存单条数据
     *
     * @param tableName
     * @param columns
     * @param columnsTypeList
     * @param rs
     * @param conn
     * @return
     */
    private static boolean SaveSingleSql(String tableName, List<String> columns, List<String> columnsTypeList, ResultSet rs, Connection conn) {
        String sql = "insert into " + tableName + "(";
        String valSql = "values(";
        PreparedStatement statement = null;
        try {
            if (rs != null) {
                for (int i = 0; i < columns.size(); i++) {
                    sql += columns.get(i) + ",";
                    valSql += "?,";
                }
                if (sql.endsWith(",")) {
                    sql = sql.substring(0, sql.length() - 1) + ")";
                }
                if (valSql.endsWith(",")) {
                    valSql = valSql.substring(0, valSql.length() - 1) + ")";
                }
                sql = sql + valSql;
                statement = conn.prepareStatement(sql);
                for (int i = 0; i < columnsTypeList.size(); i++) {
                    getPrepart(statement, columns.get(i), i + 1, columnsTypeList.get(i), rs);
                }
                int rtn = statement.executeUpdate();
                if (rtn > 0) {
                    return true;
                } else {
                    return false;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (statement != null) {
                try {
                    statement.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
        }
        return true;
    }

    /**
     * 根据数据类型获取单条数据
     *
     * @param statement
     * @param name
     * @param index
     * @param type
     * @param rs
     */
    private static void getPrepart(PreparedStatement statement, String name, int index, String type, ResultSet rs) {
        try {
            Object obj = rs.getObject(index);

            if (obj != null) {
                switch (type) {
                    case "Long":
                        statement.setLong(index, Long.parseLong(obj.toString()));
                        break;
                    case "String":
                        statement.setString(index, obj.toString());
                        break;
                    case "Date":
                        if (obj.toString().toLowerCase().indexOf("timestamp") >= 0) {
                            statement.setTimestamp(index, rs.getTimestamp(index));
                        } else if (obj.toString().toLowerCase().indexOf("date") >= 0) {
                            statement.setDate(index, rs.getDate(index));
                        } else {
                            statement.setTimestamp(index, rs.getTimestamp(index));
                        }
                        break;
                    case "Double":
                        if (obj != null) {
                            Double doubleObj = Double.parseDouble(obj.toString());
                            statement.setDouble(index, doubleObj);
                        }
                        break;
                    case "BLOB":
                        statement.setBlob(index, rs.getBlob(index));
                        break;
                    default:
                        throw new Exception("db columns type err name" + columnsList.get(index - 1) + "index:" + (index - 1) + " error rows:" + onceCurrRows);

                }
            } else {
                statement.setObject(index, null);
            }
        } catch (Exception e) {
            try {
                throw new Exception("data turn error e" + " error rows:" + onceCurrRows + ":" + e.toString());
            } catch (Exception e1) {
                e1.printStackTrace();
            }
        }
    }

    private static String getPageSql(PageEntity pageEntity, String sql, int DBType) {
        String tempSql = "";
        pageEntity.setCurrRows(pageEntity.getNextReadRows());
        pageEntity.setNextReadRows(pageEntity.getCurrRows() + onceReadRows);
        if (pageEntity.getNextReadRows() > pageEntity.getTotalRows()) {
            pageEntity.setNextReadRows(pageEntity.getTotalRows());
        }
        switch (DBType) {
            case 1:
                tempSql = "select * from (select * from (select a.*,ROWNUM AS rowno from (" + sql + ") a)c where c.rowno<=" + pageEntity.getNextReadRows() + ")b where b.rowno>" + pageEntity.getCurrRows();
                break;
            case 2:
                break;
        }
        return tempSql;
    }

    private static Connection getJdbcCon(JSONObject jdbcstr) {
        Connection conn = null;
        String URL = "";
        String USER = "";
        String PASSWORD = "";
        if (!jdbcstr.containsKey("dbtype") || !jdbcstr.containsKey("service") || !jdbcstr.containsKey("prot") || !jdbcstr.containsKey("sid") || !jdbcstr.containsKey("user") || !jdbcstr.containsKey("pwd")) {
            try {
                throw new Exception("DB Error");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        try {
            switch (jdbcstr.getIntValue("dbtype")) {
                case 1://oracle
                    Class.forName("oracle.jdbc.driver.OracleDriver");
                    URL = "jdbc:oracle:thin:@" + jdbcstr.getString("service") + ":" + jdbcstr.getString("prot") + ":" + jdbcstr.getString("sid");
                    break;
                case 2://dm
                    Class.forName("dm.jdbc.driver.DmDriver");
                    URL = "jdbc:dm://" + jdbcstr.getString("service") + ":" + jdbcstr.getString("prot") + "/" + jdbcstr.getString("sid");
                    break;
            }
            USER = jdbcstr.getString("user");
            PASSWORD = jdbcstr.getString("pwd");
            conn = DriverManager.getConnection(URL, USER, PASSWORD);
        } catch (Exception e) {
            System.out.printf("data connection err:%s", e.toString());
            System.out.println();
        }
        return conn;
    }

    private static ResultSet getSqlResult(PreparedStatement statement, String sql) {
        ResultSet rs = null;
        try {
            //statement.setString(1, name);
            rs = statement.executeQuery();
        } catch (Exception e) {
            try {
                throw new Exception("sql err sql:" + sql + "\r\n" + e.toString());
            } catch (Exception es) {
                es.printStackTrace();
            }
        }
        return rs;
    }
}

以下为配置文件

{
  "fromDB": {
    "dbtype":1,
    "service": "127.0.0.1",
    "prot": 1522,
    "sid": "sesss",
    "user": "wwmh",
    "pwd": "oracle"
  },
  "toDB": {
    "dbtype": 2,
    "service": "127.0.0.1",
    "prot": 5238,
    "sid": "ORACLETEST",
    "user": "wwmh",
    "pwd": "123456789"
  },
  "tables": [
    {
      "name": "ENTSVR_ADM_APP_BANNER",
      "oncereadrows":20000,
      "startrows":4,
      "columns": [
        "ID_String",
        "TITLE_String",
        "PICURI_String",
        "IMAGE_BLOB",
        "TOURI_String",
        "DISORDER_String",
        "CHOSIGN_String"
      ]
    }
  ]
}

 

码一周
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
将Oracle数据库迁移到达梦数据库
查拉图斯特拉面条的博客
09-07 2357
　　公司某产品在项目现场上常用到的数据库有Oracle和达梦。 　　做性能测试需要根据项目现场预埋大量的基础数据和业务数据，耗费时间、精力。故完成Oracle数据库的性能测试之后，采用直接将Oracle数据库迁入达梦数据库的方式，节约时间。 1. 环境说明 　　源数据库 Oracle：V11.2.0.4 　　目标数据库 DM：V8 2. 迁移工具介绍 　　达梦数据库自带的DTS工具，迁移方式分...
Oracle迁移到达梦
m0_67269899的博客
11-02 2692
Oracle迁移达梦
Oracle数据库到达梦数据库的迁移
qq_45842167的博客
09-22 4808
Oracle数据库到达梦数据库的迁移。
数据库迁移·Oracle--＞Dm(达梦)、Kingbase-pg(人大金仓)、Vastbase-g100(海量)
最新发布
kft1314的博客
05-15 1353
本节内容：如何使用工具，将Oracle数据库数据正确迁移到达梦、人大金仓、海量数据库。迁移工具获取地址：链接：https://pan.baidu.com/s/1KybSgyjwjhGBaDkahJeaHA?pwd=1024提取码：1024含dm8+Kingbase Windows安装包。
DM数据迁移——从oracle迁移到达梦
m0_72514662的博客
07-30 4522
本文介绍了Oracle数据库到DM数据库的迁移方式，并进行了实操讲解。
Oracle数据库迁移到达梦数据库两种方法
FANGHAOWEN_的博客
09-07 1万+
达梦数据库作为国产数据库，受到国内许多公司的推崇，尤其是一些国企。在目前所作的项目中，本来使用的是Oracle数据库，但是甲方爸爸要求后期使用达梦数据库，因为已经建立了许多表，再重新在达梦数据库中建表，写数据也不太现实，所以就考虑将oracle数据库中的数据迁移到达梦数据库中。 目前来说，有两种方法。 1、一种是利用达梦数据库中自带的数据迁移工具直接从Oracle数据库迁移到达梦数据库，这种方...
瀚高数据库专用迁移工具
05-11
瀚高数据库专用迁移工具是一款专为数据迁移设计的软件，主要功能是帮助用户将MySQL、Oracle等常见数据库系统中的数据安全、高效地迁移到瀚高数据库。这款工具旨在解决跨数据库平台的数据迁移难题，确保在迁移过程中...
达梦数据库官方手册.zip
12-22
达梦提供了一系列配套的管理工具，如数据库管理工具DMTool、数据迁移工具DTS、性能监控工具等，这些工具可以帮助管理员进行数据库维护、性能优化、数据迁移等工作。 五、高级特性 1. 并行查询：达梦数据库支持SQL...
达梦数据库JDBC驱动包合集包含MYSQL驱动包
09-16
在“在mysql数据库导入达梦的的时候导入工具需要用到”这个描述中，我们可以理解为在特定情况下，可能需要从MySQL数据库迁移到达梦数据库，或者两个数据库之间进行数据同步。这时，可能需要使用特定的工具，而这些...
达梦各个版本jdbc驱动：DmJdbcDriver.7z
01-10
- `dm8-oracle-jdbc16-wrapper.jar`：此文件可能是一个针对达梦8版本的Oracle兼容驱动，用于在Java应用中模拟Oracle JDBC驱动的行为，以便于迁移或兼容Oracle数据库的代码。 - `DmDictionary.jar`：这个文件可能是...
达梦数据库驱动包DmJdbcDriver16-18
01-20
这种包装器通常用于兼容性目的，使得应用可以使用与Oracle类似的接口来操作达梦数据库，简化了代码迁移和维护工作。 使用这些驱动包的过程大致包括以下步骤： 1. 将对应的DmJdbcDriver.jar文件添加到项目的类路径中...
数据迁移 说明 oracle 数据迁移完整手册
11-20
oracle 数据迁移技术汇总，各种姿势都行。需要数据迁移的技术完整手册
Oracle数据库迁移操作指南
08-01
Oracle数据库迁移操作指南
有一种神奇的性格叫——INTJ
热门推荐
濯君
03-23 2万+
2.3.1 沙箱 要了解 INTJ 的性格，首先要明确一个叫做沙箱的概念。 INTJ，我们从这四个字母就能看出他的性格特点：内向的人本身就不喜欢与人交往，直觉让他们倾向于自己冥想，理性的思维使他们只关注事物的本身逻辑，判断的的特性让他们很少做出理解他人感受的举动。这四个功能都是那种较少和外界接触，相对独立的功能，合在一起自然使 INTJ成了十六种性格里最独立也最封闭的一种性格。 大多数人的功能是为了适应和认识外在的世界，INTJ 就完全走向另一个极端，纯粹的构建一个心中的完美的世界，也就是他...
oracle迁移达梦操作流程记录
qq_31034951的博客
09-20 850
使用达梦数据库提供的DTS工具将oracle数据库中的数据迁移到达梦数据库中
Oracle数据库迁移至达梦8数据库（windows图文讲解）
li836779537的博客
03-12 850
https://blog.csdn.net/li836779537/article/details/136641411?spm=1001.2014.3001.5502 填写完相关信息， 主机名：你Oracle安装的ip地址 端口：1521（Oracle默认端口号，你要是改了就改成你自己的） 角色：不管它 用户名：连接 Oracle 的用户名 密码： 连接Oracle的密码 使用默认驱动就行，我之前测试的时候用过指定驱动会出现表迁移过去了，但是没有数据，各种字段类型转换报错，所以用默认驱动就行。我把指定
达梦数据库部分数据迁移
qq_35760885的博客
07-05 1742
如何使用达梦迁移工具有条件的将表中的部分数据进行迁移
oracle到达梦数据库迁移基本步骤
Smile
07-28 934
数据迁移数据迁移。
DM8达梦数据库:DTS数据迁移工具异构数据库数据类型映射
qq_37358909的博客
09-18 1850
DM8达梦数据库:DTS数据迁移工具异构数据类型映射 DM 数据迁移工具 > 数据类型映射 默认数据类型映射关系 系统对应各迁移选项给出默认的数据类型映射关系。 1.ORACLE 到 DM ORACLE DM 注释 VARCHAR2 VARCHAR2 NVARCHAR2 NVARCHAR NCHAR CHAR LONG TEXT RAW VARBINARY LONG RAW LONGVARBINARY NCLOB CLOB DATE TIMES
达梦迁移oracle,达梦数据迁移工具的使用
05-27
达梦是一种国产的关系型数据库管理系统，它提供了一套数据迁移工具，可以将Oracle数据库的数据迁移到达梦数据库中。下面是迁移过程的大致步骤： 1. 在达梦数据库中创建一个新的数据库实例。 2. 在Oracle数据库中...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值