springboot整合druid和mybatis完成数据库主写从读功能

最新推荐文章于 2024-05-26 15:40:05 发布
最新推荐文章于 2024-05-26 15:40:05 发布
阅读量786 收藏 6
点赞数 1
分类专栏： 数据库 小项目实践 框架工具 文章标签： mybatis mysql java 数据库 sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38650808/article/details/106649515
版权

一、导入pom包

       <!--阿里数据库连接池 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid-spring-boot-starter</artifactId>
            <version>1.1.14</version>
        </dependency>
        <!-- Mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!-- aop依赖 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>

二、yml文件配置

# MyBatis配置
mybatis:
    # 搜索指定包别名
    typeAliasesPackage: com.test.demo.**.druidtest
    # 配置mapper的扫描，找到所有的mapper.xml映射文件
    mapperLocations: classpath*:mybatis/**/*Mapper.xml

# 数据源配置
spring:
  datasource:
      type: com.alibaba.druid.pool.DruidDataSource
      driverClassName: com.mysql.jdbc.Driver
      druid:
          # 主库数据源
          master:
              url: jdbc:mysql://主库ip:3306/test?useUnicode=true&characterEncoding=utf8
              username: root
              password: pi3.14@D
          # 从库数据源
          slave:
              # 从数据源开关/默认关闭
              enabled: true
              url: jdbc:mysql://从库ip:3306/test?useUnicode=true&characterEncoding=utf8
              username: root
              password: pi3.14@D
          # 初始连接数
          initialSize: 5
          # 最小连接池数量
          minIdle: 10
          # 最大连接池数量
          maxActive: 20
          # 配置获取连接等待超时的时间
          maxWait: 60000
          # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
          timeBetweenEvictionRunsMillis: 60000
          # 配置一个连接在池中最小生存的时间，单位是毫秒
          minEvictableIdleTimeMillis: 300000
          # 配置一个连接在池中最大生存的时间，单位是毫秒
          maxEvictableIdleTimeMillis: 900000
          # 配置检测连接是否有效
          validationQuery: SELECT 1 FROM DUAL
          testWhileIdle: true
          testOnBorrow: false
          testOnReturn: false
          webStatFilter:
              enabled: true
          statViewServlet:
              enabled: true
              # 设置白名单，不填则允许所有访问
              allow:
              url-pattern: /druid/*
              # 控制台管理用户名和密码
              login-username:
              login-password:
          filter:
              stat:
                  enabled: true
                  # 慢SQL记录
                  log-slow-sql: true
                  slow-sql-millis: 1000
                  merge-sql: true
              wall:
                  config:
                      multi-statement-allow: true
server:
  port: 8080

三、创建数据源切换类

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author X.X
 * @date 2020/6/9
 */
public class DynamicDataSourceContextHolder {
    public static final Logger log = LoggerFactory.getLogger(DynamicDataSourceContextHolder.class);

    /**
     * 使用ThreadLocal维护变量，ThreadLocal为每个使用该变量的线程提供独立的变量副本，
     * 所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。
     */
    private static final ThreadLocal<String> CONTEXT_HOLDER = new ThreadLocal<>();

    /**
     * 设置数据源的变量
     */
    public static void setDataSourceType(String dataSourceType) {
        log.info("切换到{}数据源", dataSourceType);
        CONTEXT_HOLDER.set(dataSourceType);
    }

    /**
     * 获取数据源的变量
     */
    public static String getDataSourceType() {
        return CONTEXT_HOLDER.get();
    }

    /**
     * 清空数据源变量
     */
    public static void clearDataSourceType() {
        CONTEXT_HOLDER.remove();
    }
}

四、创建动态数据源

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import javax.sql.DataSource;
import java.util.Map;

/**
 * @author X.X
 * @date 2020/6/9
 */
public class DynamicDataSource  extends AbstractRoutingDataSource {

    public DynamicDataSource(DataSource defaultTargetDataSource, Map<Object, Object> targetDataSources) {
        super.setDefaultTargetDataSource(defaultTargetDataSource);
        super.setTargetDataSources(targetDataSources);
        super.afterPropertiesSet();
    }

    @Override
    protected Object determineCurrentLookupKey() {
        return DynamicDataSourceContextHolder.getDataSourceType();
    }
}

五、创建druid参数配置类

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Configuration;

/**
 * @author X.X
 * @date 2020/6/9
 */
@Configuration
public class DruidProperties {
    @Value("${spring.datasource.druid.initialSize}")
    private int initialSize;

    @Value("${spring.datasource.druid.minIdle}")
    private int minIdle;

    @Value("${spring.datasource.druid.maxActive}")
    private int maxActive;

    @Value("${spring.datasource.druid.maxWait}")
    private int maxWait;

    @Value("${spring.datasource.druid.timeBetweenEvictionRunsMillis}")
    private int timeBetweenEvictionRunsMillis;

    @Value("${spring.datasource.druid.minEvictableIdleTimeMillis}")
    private int minEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.maxEvictableIdleTimeMillis}")
    private int maxEvictableIdleTimeMillis;

    @Value("${spring.datasource.druid.validationQuery}")
    private String validationQuery;

    @Value("${spring.datasource.druid.testWhileIdle}")
    private boolean testWhileIdle;

    @Value("${spring.datasource.druid.testOnBorrow}")
    private boolean testOnBorrow;

    @Value("${spring.datasource.druid.testOnReturn}")
    private boolean testOnReturn;

    public DruidDataSource dataSource(DruidDataSource datasource) {
        /** 配置初始化大小、最小、最大 */
        datasource.setInitialSize(initialSize);
        datasource.setMaxActive(maxActive);
        datasource.setMinIdle(minIdle);

        /** 配置获取连接等待超时的时间 */
        datasource.setMaxWait(maxWait);

        /** 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒 */
        datasource.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

        /** 配置一个连接在池中最小、最大生存的时间，单位是毫秒 */
        datasource.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
        datasource.setMaxEvictableIdleTimeMillis(maxEvictableIdleTimeMillis);

        /**
         * 用来检测连接是否有效的sql，要求是一个查询语句，常用select
         * 'x'。如果validationQuery为null，testOnBorrow、testOnReturn、testWhileIdle都不会起作用。
         */
        datasource.setValidationQuery(validationQuery);
        /**
         * 建议配置为true，不影响性能，并且保证安全性。申请连接的时候检测，如果空闲时间大于timeBetweenEvictionRunsMillis，执行validationQuery检测连接是否有效。
         */
        datasource.setTestWhileIdle(testWhileIdle);
        /** 申请连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnBorrow(testOnBorrow);
        /** 归还连接时执行validationQuery检测连接是否有效，做了这个配置会降低性能。 */
        datasource.setTestOnReturn(testOnReturn);
        return datasource;
    }
}

六、创建druid配置类

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import com.alibaba.druid.spring.boot.autoconfigure.properties.DruidStatProperties;
import com.alibaba.druid.util.Utils;
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;

import javax.servlet.*;
import javax.sql.DataSource;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @author X.X
 * @date 2020/6/9
 */
@Configuration
public class DruidConfig {
    @Bean
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource masterDataSource(DruidProperties druidProperties) {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean
    @ConfigurationProperties("spring.datasource.druid.slave")
    @ConditionalOnProperty(prefix = "spring.datasource.druid.slave", name = "enabled", havingValue = "true")
    public DataSource slaveDataSource(DruidProperties druidProperties) {
        DruidDataSource dataSource = DruidDataSourceBuilder.create().build();
        return druidProperties.dataSource(dataSource);
    }

    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dataSource(DataSource masterDataSource, DataSource slaveDataSource) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        targetDataSources.put(DataSourceType.SLAVE.name(), slaveDataSource);
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }

    /**
     * 去除监控页面底部广告
     * @param properties
     * @return
     */
    @SuppressWarnings({"rawtypes", "unchecked"})
    @Bean
    @ConditionalOnProperty(name = "spring.datasource.druid.statViewServlet.enabled", havingValue = "true")
    public FilterRegistrationBean removeDruidFilterRegistrationBean(DruidStatProperties properties) {
        //获取web监控页面的参数
        DruidStatProperties.StatViewServlet config = properties.getStatViewServlet();
        //提取common.js的配置路径
        String pattern = config.getUrlPattern() != null ? config.getUrlPattern() : "/druid/*";
        String commonJsPattern = pattern.replaceAll("\\*", "js/common.js");
        final String filePath = "support/http/resources/js/common.js";
        //创建filter进行过滤
        Filter filter = new Filter() {

            @Override
            public void init(FilterConfig filterConfig) throws ServletException {

            }

            @Override
            public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
                    throws IOException, ServletException {
                chain.doFilter(request, response);
                //重置缓冲区，响应头不会被重置
                response.resetBuffer();
                //获取common.js
                String text = Utils.readFromResource(filePath);
                //正则替换banner, 除去底部广告信息
                text = text.replaceAll("<a.*?banner\"></a><br/>", "");
                text = text.replaceAll("powered.*?shrek.wang</a>", "");
                response.getWriter().write(text);
            }

            @Override
            public void destroy() {

            }
        };

        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(filter);
        registrationBean.addUrlPatterns(commonJsPattern);
        return registrationBean;
    }
}

七、定义主从库名枚举类

/**
 * @author X.X
 * @date 2020/6/9
 */
public enum  DataSourceType {

    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE

}

八、创建工具类

public class StringUtils
{
    /**
     * * 判断一个对象是否为空
     * 
     * @param object Object
     * @return true：为空 false：非空
     */
    public static boolean isNull(Object object)
    {
        return object == null;
    }

    /**
     * * 判断一个对象是否非空
     * 
     * @param object Object
     * @return true：非空 false：空
     */
    public static boolean isNotNull(Object object)
    {
        return !isNull(object);
    }
 }

九、创建切面类

import java.lang.reflect.Method;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;


/**
 * @author X.X
 * @date 2020/6/9
 */

@Aspect
@Order(1) // 优先级
@Component
public class DataSourceAspect {
    protected Logger logger = LoggerFactory.getLogger(getClass());

    /**
     * 通过自定义注解@DataSource定义切点
     */
    @Pointcut("@annotation(com.test.demo.druidtest.DataSource)"
            + "|| @within(com.test.demo.druidtest.DataSource)")
    public void dsPointCut() {
    }

    /**
     * 切点环绕
     * @param point
     * @return
     * @throws Throwable
     */
    @Around("dsPointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        DataSource dataSource = getDataSource(point);
        if (StringUtils.isNotNull(dataSource)) {
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point) {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Class<? extends Object> targetClass = point.getTarget().getClass();
        DataSource targetDataSource = targetClass.getAnnotation(DataSource.class);
        if (StringUtils.isNotNull(targetDataSource)) {
            return targetDataSource;
        } else {
            Method method = signature.getMethod();
            DataSource dataSource = method.getAnnotation(DataSource.class);
            return dataSource;
        }
    }
}

十、创建DataSource注解

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource {
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.MASTER;

}

十一、进行测试
创建实体、dao、service和controller

/**
 * @author X.X
 * @date 2020/6/9
 */
public class TestPojo {
    private String userId;
    private String roleId;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getRoleId() {
        return roleId;
    }

    public void setRoleId(String roleId) {
        this.roleId = roleId;
    }
}

@Mapper
public interface TestMapper {
    List<TestPojo> select();
    
    int insert(TestPojo testPojo);
}

@Service
public class TestService {
    @Autowired
    private TestMapper testMapper;

     List<TestPojo> select(){
        return testMapper.select();
    }

     int insert(TestPojo testPojo){
        return testMapper.insert(testPojo);
    }

}

@RestController
@RequestMapping("test")
public class TestController {
    @Autowired
    private TestService testService;

    @GetMapping("select")
    @DataSource(value = DataSourceType.SLAVE)
    public List<TestPojo> select() {
        return testService.select();
    }

    @PostMapping("insert")
    @DataSource(value = DataSourceType.MASTER)
    public int insert(@RequestBody TestPojo testPojo) {
        return testService.insert(testPojo);
    }

}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.test.demo.druidtest.TestMapper">

    <resultMap type="com.test.demo.druidtest.TestPojo" id="BaseResultMap">
        <result property="userId"    column="user_id"    />
        <result property="roleId"    column="role_id"    />
    </resultMap>


    <select id="select" resultMap="BaseResultMap">
      select * from sys_user_role
  </select>

    <insert id="insert" parameterType="com.test.demo.druidtest.TestPojo">
    insert into sys_user_role (user_id, role_id)
    values (#{userId}, #{roleId})
  </insert>

</mapper>

在这里插入图片描述

临月十四
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot+druid+mybatis配置操作数据库
yh_1021的博客
02-22 1272
一、创建spring-starter工程 加入mysql驱动器+jdbc+web+mybatis 二、druid配置 参考： https://blog.csdn.net/yh_1021/article/details/104434205 三、数据库建表：将工程文件夹中的sql文件添加到Navicat中 在resource文件夹中有两个sql文件 在application.yml文件中修改配...
SpringBoot整合Mybatis和Druid数据源介绍使用
关注我~分享更多技术干货
02-25 527
刚开始学习了SSM组合架构上起手来中规中矩，不是怎么便捷和简易。 而对于SpringBoot来说，真是轻而易举！ 对于这么强大的框架而说，整合起来那真叫一个爽呀。就算不整合，使用底层的JDBC都使用的舒服！ 传送门文章 ： Swagger的介绍使用 ： Swagger介绍和使用 设计模式中的创建型模式：23种设计模式的创建型模式 话不多说，直接正题： IDE: IDEA DB: MySQ...
springboot+mybatis+druid实现mysql主从读写分离(三)
qq_40749830的博客
11-18 609
一、如何自定义注解 1、使用格式 修饰符 访问修饰符必须为public，不写默认为public 关键字 关键字为@interface; 注解名称 自定义名称 注解类型元素 注解类型元素是注解中内容，可以理解成自定义接口的实现部分； @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface DataSourceSign { /** * 切换数据
springboot+mybatis+druid 配置单实例多数据源
最新发布
WonderKing'blog
05-26 274
第二步：配置application-dev.yml。第四步：使用@DS注解在Dao层指定数据库。第一步：pom中添加依赖。
SpringBoot MySql Druid配置主从数据源(多个数据源)
热门推荐
BlueKitty的博客
12-08 1万+
1 . POM依赖 mysql mysql-connector-java org.mybatis.spring.boot mybatis-spring-boot-starter 1.1.1 com.alibaba druid 1.0.28 2 . SpringBoot数据源配置 spring: datasource: type: com.alib
springboot+mybatis+druid实现mysql主从读写分离
weixin_40240756的博客
03-16 2097
jdbc动态数据源实现操作数据库读写分离 以下一、二缺一不可 一.mysql服务器配置一主多从 mysql主从复制配置，这里以两台虚拟机为例进行配置： 环境准备 1.克隆一个centos 网络配置 2.mysql主从复制配置： 2.1主节点 2.1.1创建用户 create user 'taibai'@'192.168.204...
springboot整合druid、mybatis连接gbase8s.doc
09-23
在本文中，我们将深入探讨如何将SpringBoot与Druid数据源和MyBatis集成，以连接到Gbase8s v8.7数据库。Gbase8s是一款高性能的关系型数据库管理系统，特别适合处理大规模数据。我们将使用Spring Boot 2.1.11版本，...
Springboot整合Druid与Mybatis的多数据源切换
10-17
本教程将详细介绍如何在Spring Boot项目中整合Druid数据源池与Mybatis，实现多数据源切换的功能，并提供一个亲测可用的解决方案。 首先，让我们了解Spring Boot、Druid和Mybatis这三大组件的基础知识： **Spring ...
springboot+druid+mybatis plus整合demo
12-13
在本项目中，我们主要探讨的是如何将SpringBoot、Druid和MyBatis Plus这三大组件进行有效的整合，创建一个高效、简洁的Java Web应用程序。首先，让我们逐一了解这三个组件的核心功能，然后深入讨论它们如何协同工作...
SpringBoot(七)SpringBoot整合Druid实现数据库密码加密.pdf
03-07
SpringBoot(七)SpringBoot整合Druid实现数据库密码加密 SpringBoot(七)SpringBoot整合Druid实现数据库密码加密 SpringBoot(七)SpringBoot整合Druid实现数据库密码加密
SpringBoot整合Druid数据库连接池的方法
08-18
SpringBoot整合Druid数据库连接池的方法 在本文中，我们将讨论如何在SpringBoot项目中整合Druid数据库连接池。Druid是Java语言中最好的数据库连接池，能够提供强大的监控和扩展功能。 什么是Druid？ Druid是Java...
springmvc-mybatis 整合druid多数据源配置读写实现读写分离，windows上mysql主从复制
10-27
springmvc mybatis 整合druid多数据源配置 实现简单的读写分离，windows上mysql主从复制
springboot+mybatis+druid+redis实现数据库读写分离和缓存
04-12
springboot+mybatis+druid+redis实现数据库读写分离和缓存
SpringBoot集成Druid 动态切换数据源
qq_46237915的博客
07-14 864
SpringBoot集成Druid 动态切换数据源 主要逻辑 通过继承 AbstractRoutingDataSource 类覆写其 determineCurrentLookupKey() 方法来设置数据源，动态切换则基于aop实现。通过自定义一个注解，传入我们需要的数据源名称，在切面中获取到数据源名称并将其存储到当前线程的私有内存（ThreadLocal）中。在调用方法时读取当前线程存储的数据源名称，并根据这个名称去设置数据源. 依赖： <parent> <groupId>
SpringBoot配置多数据源（动态切换，主从复制，读写分离）
qq_39380737的博客
01-09 3698
SpringBoot2.x整合多数据源，基于注解动态切换数据源,主从复制，读写分离，多数据源的事务处理 1.多数据源实现主从复制，读写分离？ 这里介绍的是MYSQL的主从复制实现及其原理，数据源分为主从，主数据源用于写操作，从数据源用于读操作，实现了读写分离 MYSQL主从复制实现以及原理 2.在配置文件里面配置主从数据源相关信息以及连接池相关信息 ##############配置端口 serve...
采用aop进行数据库读写分离
lwy572039941的博客
07-15 905
采用aop进行数据库读写分离 转自： https://mp.weixin.qq.com/s__biz=MzA5NzgzODI5NA==&mid=2454036042&idx=2&sn=723a3855a586237938f256f7267703f4&chksm=872b8bf3b05c02e52b56b9f2bd46b6e1a6656fba41942b6fd9a0...
mybatis通过自定义插件方式实现主从库读写分离
一不小心的程序员
01-24 806
1. 首先我们在本地创建test_master主库 和 test_slave从数据库 在各自里面创建数据表 CREATE TABLE `test_user` ( `id` bigint(20) NOT NULL AUTO_INCREMENT, `name` varchar(255) DEFAULT NULL, `sex` varchar(255) DEFAULT NULL, ...
springboot 整合mybatis-plus+dynamic-datasource实现读写分离
sky_20131213的博客
08-31 698
当未加@DS注解时，查询操作默认使用从库，修改删除和添加操作默认使用主库，如果添加@DS注解，则以注解为准。数据源使用druid，这里druid和mybatis-plus版本不是最新，可自行选择。这里数据库使用的SqlServer，自行修改，oracle或mysql见。
Spring Boot + Mybatis + Druid 实现MySQL一主多从读写分离
weixin_34137799的博客
08-04 893
2019独角兽企业重金招聘Python工程师标准>>> ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值