SpringBoot+Mybatis-plus的整合,多数据源增删改查

最新推荐文章于 2023-10-16 11:02:15 发布
最新推荐文章于 2023-10-16 11:02:15 发布
阅读量1.1k 收藏 7
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42614150/article/details/124382054
版权

1: 创建数据库表

-- 数据库demo1创建student库表
CREATE TABLE `student` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `name` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '姓名',
  `age` int(2) DEFAULT NULL COMMENT '年龄',
  `address` varchar(255) COLLATE utf8_bin DEFAULT NULL COMMENT '地址',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='学生信息表'
-- 数据库demo2创建student_score库表
CREATE TABLE `student_score` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `student_id` int(11) DEFAULT NULL COMMENT '学生id',
  `course` varchar(100) DEFAULT NULL COMMENT '课程',
  `score` int(10) DEFAULT NULL COMMENT '成绩',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=utf8 COMMENT='学生课程成绩表'

2: 创建springboot项目(省略)，引入相应依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.3</version>
        <relativePath/>
    </parent>
    <groupId>com.abc</groupId>
    <artifactId>springboot-mybatisPlus</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot-mybatisPlus</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>

        <!--多数据源-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
            <version>3.4.0</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

3: 编写application.yml配置文件

server:
  port: 9001

# 打印SQL语句到控制台
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

spring:
  datasource:
    dynamic:
      primary: one #设置默认的数据源或者数据源组,默认值即为one
      strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源
      datasource:
        one:  # 数据源1标志
          url: jdbc:mysql://127.0.0.1:3306/demo1
          username: root
          password: 12345
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource
          # 下面为连接池的补充设置，应用到上面所有数据源中
          initialSize: 1  # 初始化大小
          minIdle: 3      # 最小
          maxActive: 10   # 最大
          # 配置获取连接等待超时的时间
          maxWait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
          timeBetweenEvictionRunsMillis: 60000
          # 配置一个连接在池中最小生存的时间，单位是毫秒
          minEvictableIdleTimeMillis: 30000
          validationQuery: select 'x'
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          # 打开PSCache，并且指定每个连接上PSCache的大小
          poolPreparedStatements: true
          maxPoolPreparedStatementPerConnectionSize: 20
        two:  # 数据源2标志
          url: jdbc:mysql://127.0.0.1:3306/demo2
          username: root
          password: 12345
          driver-class-name: com.mysql.cj.jdbc.Driver
          type: com.alibaba.druid.pool.DruidDataSource
          # 下面为连接池的补充设置，应用到上面所有数据源中
          initialSize: 1  # 初始化大小
          minIdle: 3      # 最小
          maxActive: 10   # 最大
          # 配置获取连接等待超时的时间
          maxWait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
          timeBetweenEvictionRunsMillis: 60000
          # 配置一个连接在池中最小生存的时间，单位是毫秒
          minEvictableIdleTimeMillis: 30000
          validationQuery: select 'x'
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          # 打开PSCache，并且指定每个连接上PSCache的大小
          poolPreparedStatements: true
          maxPoolPreparedStatementPerConnectionSize: 20

4: 创建实体类

/**
 * 学生实体类
 * 实体类字段和数据库库表字段保持一致
 */
@Data
@AllArgsConstructor
public class Student {
  	//主键自增
    @TableId(type = IdType.AUTO)
    private Integer id;
    private String name;
    private Integer age;
    private String address;
}
/**
 * 学生成绩实体类
 * 实体类字段和数据库库表字段保持一致
 */
@Data
@AllArgsConstructor
public class Student_score {
  	//主键自增
    @TableId(type = IdType.AUTO)
    private Integer id;
    private Integer student_id;
    private String course;
    private Integer score;
}

5: 编写Mapper数据库交互层

/**
 * 学生类数据交互层
 * 使用数据源1
 */
@Mapper
@DS("one")  //和application.yml中的数据源1标志保持一致
public interface StudentMapper extends BaseMapper<Student> {
}

/**
 * 学生成绩类数据交互层
 * 使用数据源2
 */
@Mapper
@DS("two")  //和application.yml中的数据源2标志保持一致
public interface Student_scoreMapper extends BaseMapper<Student_score> {
}

6: 编写Service层接口


/**
 * 学生Service层接口
 */
public interface StudentService {

    //新增学生信息
    int addStudent(Student student);

    //新增学生成绩信息
    int addStudentScore(Student_score student_score);

    //修改学生信息
    int updateStudent(Student student);

    //修改学生成绩信息
    int updateStudentScore(Student_score student_score);

    //根据学生ID删除学生信息
    int deleteStudent(Integer id) ;

    //根据学生ID删除学生成绩信息
    int deleteStudentScore(Integer student_id) ;

    //根据id查询学生信息
    Student queryStudentById(Integer id);

    //查询全部学生信息
    List<Student> queryAllStudent();

    //根据学生ID查询学生成绩信息
    List<Student_score> queryStudentScoreById(Integer student_id);
}

7: 编写Service层接口实现类

/**
 * 学生Service层接口实现类
 */
@Service
public class StudentServiceImpl implements StudentService {

    @Autowired
    private StudentMapper studentMapper;

    @Autowired
    private Student_scoreMapper student_scoreMapper;

    /**
     * 新增学生信息
     * @param student  学生信息
     */
    @Override
    public int addStudent(Student student) {
        return studentMapper.insert(student);
    }
    /**
     * 新增学生成绩信息
     * @param student_score 学生成绩信息
     */
    @Override
    public int addStudentScore(Student_score student_score) {
        return student_scoreMapper.insert(student_score);
    }

    /**
     * 修改学生信息
     * @param student 学生信息
     */
    @Override
    public int updateStudent(Student student) {
        //更新条件, 根据id更新
        UpdateWrapper<Student> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", student.getId())
                .set("name", student.getName())
                .set("age", student.getAge())
                .set("address", student.getAddress());
        return studentMapper.update(null, updateWrapper);
    }
    /**
     * 修改学生成绩信息
     *
     * @param student_score 学生成绩信息
     */
    @Override
    public int updateStudentScore(Student_score student_score) {
        //根据学生成绩id, 学生ID，课程名称，更新学生成绩信息
        UpdateWrapper<Student_score> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", student_score.getId())
                .eq("student_id", student_score.getStudent_id())
                .eq("course", student_score.getCourse())
                .set("score", student_score.getScore());
        return student_scoreMapper.update(null, updateWrapper);
    }

    /**
     * 根据学生ID删除学生信息
     * @param id 学生ID
     */
    @Override
    public int deleteStudent(Integer id) {
        return studentMapper.deleteById(id);
    }

    /**
     * 根据学生ID删除学生成绩信息
     *
     * @param student_id 学生ID
     */
    @Override
    public int deleteStudentScore(Integer student_id) {
        QueryWrapper<Student_score> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("student_id", student_id);
        return student_scoreMapper.delete(queryWrapper);
    }
    /**
     * 根据id查询学生信息
     *
     * @param id 学生ID
     */
    @Override
    public Student queryStudentById(Integer id) {
        return studentMapper.selectById(id);
    }

    /**
     * 查询全部学生信息
     */
    @Override
    public List<Student> queryAllStudent() {
        return studentMapper.selectList(null);
    }

    /**
     * 根据学生ID查询学生成绩信息
     *
     * @param student_id 学生ID
     */
    @Override
    public List<Student_score> queryStudentScoreById(Integer student_id) {
        //每个学生有可能存在多个成绩
        QueryWrapper<Student_score> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("student_id", student_id);
        return student_scoreMapper.selectList(queryWrapper);
    }
}

8: 编写Controller层


/**
 * 学生控制器层
 */
@RestController
@RequestMapping("/student")
public class StudentController {

    @Autowired
    private StudentService studentService;

    /**
     * 新增学生信息
     */
    @PostMapping(value = "/saveOne")
    public Map<String, Object> saveOne(@RequestBody Student student) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            int num = studentService.addStudent(student);
            if (num > 0) {
                resultMap.put("code", 200);
                resultMap.put("msg", "新增学生成功, 入库条数：" + num + "条");
            } else {
                resultMap.put("code", 500);
                resultMap.put("msg", "新增学生失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "新增学生信息异常");
        }
        return resultMap;
    }


    /**
     * 新增学生成绩信息
     */
    @PostMapping(value = "/saveTwo")
    public Map<String, Object> saveTwo(@RequestBody Student_score student_score) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            int num = studentService.addStudentScore(student_score);
            if (num > 0) {
                resultMap.put("code", 200);
                resultMap.put("msg", "新增学生成绩成功, 入库条数：" + num + "条");
            } else {
                resultMap.put("code", 500);
                resultMap.put("msg", "新增学生成绩失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "新增学生成绩信息异常");
        }
        return resultMap;
    }
    /**
     * 修改学生信息
     */
    @PutMapping(value = "/saveThree")
    public Map<String, Object> saveThree(@RequestBody Student student) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            int num = studentService.updateStudent(student);
            if (num > 0) {
                resultMap.put("code", 200);
                resultMap.put("msg", "修改学生信息成功");
            } else {
                resultMap.put("code", 500);
                resultMap.put("msg", "修改学生信息失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "修改学生信息异常");
        }
        return resultMap;
    }
    /**
     * 修改学生成绩信息
     */
    @PutMapping(value = "/saveFour")
    public Map<String, Object> saveFour(@RequestBody Student_score student_score) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            int num = studentService.updateStudentScore(student_score);
            if (num > 0) {
                resultMap.put("code", 200);
                resultMap.put("msg", "修改学生成绩信息成功");
            } else {
                resultMap.put("code", 500);
                resultMap.put("msg", "修改学生成绩信息失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "修改学生成绩信息异常");
        }
        return resultMap;
    }
    /**
     * 根据学生ID删除学生信息,并且删除对应学生的成绩信息
     */
    @DeleteMapping(value = "/saveFive")
    public Map<String, Object> saveFive(@RequestBody JSONObject jsonObject) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            //获取请求学生id
            Integer id = jsonObject.getInteger("id");
            //删除学生信息
            int num = studentService.deleteStudent(id);
            //删除学生成绩信息
            int i = studentService.deleteStudentScore(id);
            if (num > 0) {
                resultMap.put("code", 200);
                resultMap.put("msg", "删除学生信息成功");
            } else {
                resultMap.put("code", 500);
                resultMap.put("msg", "删除学生信息失败");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "删除学生信息异常");
        }
        return resultMap;
    }



    /**
     * 根据id查询学生信息
     */
    @GetMapping(value = "/saveSix")
    public Map<String, Object> saveSix(@RequestParam("id") Integer id) {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            //存放查询结果
            Map<String, Object> map = new HashMap<>();
            //根据id查询学生信息
            Student student = studentService.queryStudentById(id);
            map.put("student", student);
            //查询学生成绩信息
            List<Student_score> student_scores = studentService.queryStudentScoreById(id);
            map.put("student_scores", student_scores);
            if (student != null) {
                resultMap.put("code", 200);
                resultMap.put("msg", "查询成功");
                resultMap.put("data", map);
            } else {
                resultMap.put("code", 200);
                resultMap.put("msg", "学生信息不存在");
            }
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "查询学生信息异常");
        }
        return resultMap;
    }


    /**
     * 查询全部学生信息
     */
    @GetMapping(value = "/saveSeven")
    public Map<String, Object> saveSeven() {
        //记录入库信息
        Map<String, Object> resultMap = new HashMap<>();
        try {
            //查询全部学生信息
            List<Student> studentList = studentService.queryAllStudent();
            resultMap.put("code", 200);
            resultMap.put("msg", "查询成功");
            resultMap.put("data", studentList);
        } catch (Exception e) {
            e.printStackTrace();
            resultMap.put("code", 400);
            resultMap.put("msg", "查询学生信息异常");
        }
        return resultMap;
    }
}

小宇宙清歡渡
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
springboot+mybatis-plus+gradle+mysql+swagger基础增删改查、树形查询
02-20
springboot+mybatis-plus+gradle+mysql+swagger基础增删改查、树形查询，含SQL脚本
mybatis-plus 从数据库加载多数据源，以及往spring动态添加数据源
weixin_43576468的博客
08-31 444
【代码】mybatis-plus 从数据库加载多数据源，以及往spring动态添加数据源。
SpringBoot+Mybatis-Plus多数据源使用
jike11231的博客
10-03 4953
在实际开发中项目很容易就遇到使用多数据源的情形，比如：在新增数据时除了给自己的库保留一份，还需要同步到别人的库；转移程序需要将A库的数据转到B库等等。。这里介绍下mybatis-plus-dynamic的使用。
mybatis-plus配置多数据源
吴兴亚的专栏
07-24 430
补充：这里面因为默认使用的是HikariCP数据源,目前也推荐使用这个，相比于druid有更高的性能，但是不能忽略下面的配置，否则服务会不断抛出异常，原因是数据库的连接时常和连接池的配置没有做好。@Transactional 是声明式事务管理 编程中使用的注解，实质是使用了 JDBC 的事务来进行事务控制的，基于Spring 的动态代理的机制。strict: false #严格匹配数据源,默认false. true未匹配到指定数据源时抛异常,false使用默认数据源。可以注解在方法上或类上，
基于mybatis plus实现数据源动态添加、删除、切换，自定义数据源
starsray的博客
11-19 6911
简介 基于springboot，mybatis plus集成了一套多数据源的解决方案，在使用时引入相应的插件dynamic-datasource-spring-boot-starter，可以实现数据源的动态添加、删除等功能，对于多租户或者分库等操作可以根据AOP切面代理到不同的数据源、实现单一系统数据隔离的目的。 代码示例 mavne依赖 <!--mybatis-plus--> &l...
mysql多数据源事务_多数据源一致性事务解决方案
weixin_34652034的博客
01-19 941
spring 多数据源配置spring 多数据源配置一般有两种方案：1、在spring项目启动的时候直接配置两个不同的数据源，不同的sessionFactory。在dao 层根据不同业务自行选择使用哪个数据源的session来操作。2、配置多个不同的数据源，使用一个sessionFactory,在业务逻辑使用的时候自动切换到不同的数据源，有一个种是在拦截器里面根据不同的业务现切换到不同的datas...
mybatis-plus 批量插入/新增
瞅你咋滴。
06-01 2401
建表 SET NAMES utf8mb4; SET FOREIGN_KEY_CHECKS = 0; -- ---------------------------- -- Table structure for rewrite_sql -- ---------------------------- DROP TABLE IF EXISTS `rewrite_sql`; CREATE TABLE ...
全网最细SpringBoot多数据源及事务解决方案，你学会了吗？
Javatutouhouduan的博客
04-12 2742
4.2.1 定义管理接口通过继承即可实现。为了方便对数据源进行操作，我们定义一个接口，为业务提供操作数据源的统一接口。该接口主要是对数据表中定义的数据源，提供基础管理功能。4.2.2 自定义数据源的实现如下图所示：根据前面的分析，是在容器启动的时候，执行注入数据源对象，完成之后无法对数据源进行修改。则实现接口，可以将数据表中的数据源加载到dataSources。4.2.3 切面处理这一块的处理跟配置文件数据源方案处理方式相同，都是通过AOP技术切换lookup key。
springboot多数据源,DruidDataSource多数据源切换，不重启项目，修改数据库名解决方案
杜盟恩的博客
01-04 5234
springboot多数据源,DruidDataSource多数据源切换，不重启项目，修改数据库名解决方案
完美解决Mybatis-plus多数据源情况下Batch操作数据源操作不对的问题
小李的博客
03-14 2975
报错情况多半就是在调用saveBatch、updateBatchById等方法时，它会去找主数据源的路径（这种情况@Ds注解根本不好使），就可能会出现找不到表乃至找错表的情况。好了以上就是全部代码了，解决方式也比较粗暴，直接重写sqlSessionBatch的获取，网上也看到过另外的解决方案--就是把xml的路径分开放，通过注入datasource bean的时候，自己去指定对应数据源的xml路径来配置bean。这种方案我没试过，比较麻烦，感兴趣的可以自己去试试。
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip
12-20
基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 基于Springboot+MyBatis-Plus实现多租户动态数据源模式源码.zip 【备注】 主要针对...
springboot + mybatis-plus + oracle + 多数据源 + redis + hutool
04-06
springboot + mybatis-plus + database+ 多数据源 + redis + hutool 框架干净，没有其他冗余的成分； 配置了MP的代码生成器，意见生成代码，节省开发时间！ 可用于各种定时任务处理，各种夸库操作， 多数据源支持...
SpringBoot+mybatis-plus+VUE民宿管理系统后台-毕业设计
08-08
SpringBoot+mybatis-plus+VUE民宿管理系统后台-毕业设计 升级为mybatis-plus 加入启动页面类。 修改了一些VUE的其它问题。 本系列环境 环境 win11 工具 idea 2018 jdk 1.8 数据库 mysql5.5 maven 3.6.0 项目导入...
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
01-12
SpringBoot + mybatis-plus + druid 实现mySql与Orcl双数据源
MyBatis-plus 批量新增方法性能测试及优化学习
热门推荐
weixin_41645817的博客
02-05 1万+
最近对myBatis-plus 中的两个批量新增方法进行了简单的性能测试，并尝试对其速率进行优化。
Mybatis-plus 动态添加/删除数据源
javaloverkehui的专栏
11-11 1121
mybatis-plus version : 3.4.3.1 spring-boot version : 2.3.5.RELEASE @Service public class DynamaicRoutingDataSourceManagerImpl implements IDynamaicRoutingDataSourceManager { @Autowired private DataSource dataSource; @Autowired private
MyBatisPlus 多数据源配置
深圳市多克创新科技有限公司
10-16 3963
MyBatisPlus 多数据源配置
MyBatis-Plus多数据源——如何在一个项目中使用多个MySQL数据库
Arya的博客，专注后端领域
09-27 4029
本篇博客介绍如何基于mybatisPlus实现在一个项目中使用多数据源。
SpringBoot+Mybatis-Plus实现增删改查（配视频讲解）--项目阶段1
快乐学习
08-13 5965
本篇文章通过springboot整合mybatis-plus去实现后端对数据库的增删改查以及响应给前端的url，让前端获得数据。mybatis-plus技术是简化了繁琐的代码操作，把增删改查的语句都内置了，直接调用就可以实现数据库的增删改查了。还可以一定程度上防止SQL注入。缺点就是不够灵活，不过这个灵活的问题也可以自己去创建代码去弥补这个。
Springboot+MyBatis-Plus实现多租户动态数据源模式
最新发布
12-23
Springboot+MyBatis-Plus实现多租户动态数据源模式是一种在Spring Boot框架下使用MyBatis-Plus插件实现多租户数据隔离的方法。它可以根据不同的租户动态切换数据源，实现不同租户之间的数据隔离。 实现多租户动态...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值