【总结】在SpringBoot项目中如何动态切换数据源、数据库？（可直接CV）

已于 2024-06-25 20:35:03 修改
阅读量810 收藏 8
点赞数 6
分类专栏： 学习总结 文章标签： 学习 java spring 数据库
于 2024-06-24 18:42:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cyuyanya__/article/details/139605809
版权

注意：文章若有错误的地方，欢迎评论区里面指正 🍭 

前言

本文参考若依源码，介绍了如何在SpringBoot项目中使用AOP和自定义注解实现MySQL主从数据库的动态切换，当从库故障时，能自动切换到主库，确保服务的高可用性。

实现效果：如果服务器搭建的是一主多从多个mysql数据源，主服务器用来读。从服务器用来写。此时你在代码层面用注解指定了一个增删改方法到从数据源，但是碰巧此时从数据源失效了，那么就会自动的切换到其它服务器。

为什么要切换数据源，有哪些应用场景？

动态切换数据源通常是为了满足以下需求：

  1. 读写分离：在数据库架构中，为了提高性能和可用性，常常使用主从复制的方式。主数据库处理写操作，而从数据库处理读操作。动态切换数据源可以在不同的操作中使用不同的数据库，以达到优化性能的目的。

  2. 多租户架构：在SaaS（Software as a Service）应用中，不同的租户可能需要操作不同的数据库。动态数据源允许系统根据租户的身份来切换到对应的数据源。

  3. 分库分表：在处理大规模数据时，可能会采用分库分表的策略来分散数据存储的压力。动态切换数据源可以在执行跨库或跨表操作时，根据需要切换到正确的数据源。

  4. 环境隔离：在开发、测试和生产环境中，可能需要连接到不同的数据库。动态数据源可以在不同环境之间无缝切换，以确保数据的隔离和安全性。

  5. 灵活的数据库管理：在复杂的业务场景下，可能需要根据不同的业务逻辑来选择不同的数据源。动态数据源提供了这种灵活性，允许开发者根据运行时的条件来选择最合适的数据源。

  6. 故障转移和高可用性：当主数据库不可用时，动态切换数据源可以自动或手动切换到备用数据库，以保证服务的连续性和数据的可用性。

如何切换数据源？

SpringBoot版本：3.0.4

jdk版本：JDK17

1.pom文件

<dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
    </dependency>
    <!-- aop切面-->
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-aop</artifactId>
    </dependency>
    <!--druid连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid-spring-boot-starter</artifactId>
      <version>1.2.20</version>
    </dependency>
    <!--mysql驱动-->
    <dependency>
      <groupId>com.mysql</groupId>
      <artifactId>mysql-connector-j</artifactId>
    </dependency>
    <!--MybatisPlus-->
    <dependency>
      <groupId>com.baomidou</groupId>
      <artifactId>mybatis-plus-boot-starter</artifactId>
      <version>3.5.3.1</version>
    </dependency>

2.配置文件：application.yml、application-druid.yml

application.yml配置文件：

#application.yml

server:
  port: 8000
spring:
  profiles:
    active: druid

 application-druid.yml配置文件：

# 数据源配置
spring:
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    driverClassName: com.mysql.cj.jdbc.Driver
    druid:
      # 主库数据源
      master:
        url: jdbc:mysql://localhost:3306/study?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: 123456
      # 从库数据源
      slave:
        # 从数据源开关/默认关闭
        enabled: true
        url: jdbc:mysql://localhost:3306/t_lyj?useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&useSSL=true&serverTimezone=GMT%2B8
        username: root
        password: 123456
      # 初始连接数
      initialSize: 5
      # 最小连接池数量
      minIdle: 10
      # 最大连接池数量
      maxActive: 20
      # 配置获取连接等待超时的时间
      maxWait: 60000
      # 配置连接超时时间
      connectTimeout: 30000
      # 配置网络超时时间
      socketTimeout: 60000
      # 配置间隔多久才进行一次检测，检测需要关闭的空闲连接，单位是毫秒
      timeBetweenEvictionRunsMillis: 60000
      # 配置一个连接在池中最小生存的时间，单位是毫秒
      minEvictableIdleTimeMillis: 300000
      # 配置一个连接在池中最大生存的时间，单位是毫秒
      maxEvictableIdleTimeMillis: 900000

 3、数据源名称枚举DataSourceType

/**
 * 数据源
 * 
 * @author ruoyi
 */
public enum DataSourceType
{
    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE
}

 4、Bean工具类SpringUtils

@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware 
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    private static ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException 
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException 
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     * 
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 获取当前的环境配置，无配置返回null
     *
     * @return 当前的环境配置
     */
    public static String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 获取当前的环境配置，当有多个环境配置时，只获取第一个
     *
     * @return 当前的环境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringUtils.isNotEmpty(Arrays.toString(activeProfiles)) ? activeProfiles[0] : null;
    }

    /**
     * 获取配置文件中的值
     *
     * @param key 配置文件的key
     * @return 当前的配置文件的值
     *
     */
    public static String getRequiredProperty(String key)
    {
        return applicationContext.getEnvironment().getRequiredProperty(key);
    }
}

 

5、多数据源切换注解DataSource

/**
 * 自定义多数据源切换注解
 *
 * 优先级：先方法，后类，如果方法覆盖了类上的数据源类型，以方法的为准，否则以类上的为准
 *
 * @author lyj
 */
@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
public @interface DataSource
{
    /**
     * 切换数据源名称
     */
    public DataSourceType value() default DataSourceType.MASTER;
}

 6、数据源解析配置类DruidConfig

@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) {
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceType.MASTER.name(), masterDataSource);
        setDataSource(targetDataSources, DataSourceType.SLAVE.name(), "slaveDataSource");
        return new DynamicDataSource(masterDataSource, targetDataSources);
    }


    /**
     * 设置数据源
     *
     * @param targetDataSources 备选数据源集合
     * @param sourceName 数据源名称
     * @param beanName bean名称
     */
    public void setDataSource(Map<Object, Object> targetDataSources, String sourceName, String beanName) {
        try {
            DataSource dataSource = SpringUtils.getBean(beanName);
            targetDataSources.put(sourceName, dataSource);
        } catch (Exception e) {
        }
    }
}

 7、数据源注入核心类DynamicDataSource

/**
 * 动态数据源
 * 
 * @author lyj
 */
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();
    }
}

8、数据源切换处理类DynamicDataSourceContextHolder

/**
 * 数据源切换处理
 * 
 * @author lyj
 */
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 dsType)
    {
        log.info("切换到{}数据源", dsType);
        CONTEXT_HOLDER.set(dsType);
    }

    /**
     * 获得数据源的变量，默认使用主数据源
     */
    public static String getDataSourceType()
    {
        return CONTEXT_HOLDER.get() == null ? DataSourceType.MASTER.name() : CONTEXT_HOLDER.get();
    }

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

9、Aop切面类

@Aspect
@Order(1)
@Component
public class DataSourceAspect {


    @Pointcut("@annotation(com.LYJ.study.DynamicDataSource.annocation.DataSource)"
            + "|| @within(com.LYJ.study.DynamicDataSource.annocation.DataSource)")
    public void dsPointCut(){}

    @Around("dsPointCut()")

    public Object around(ProceedingJoinPoint joinPoint) throws Throwable{
        DataSource dataSource = getDataSource(joinPoint);
        if (dataSource != null){
            DynamicDataSourceContextHolder.setDataSourceType(dataSource.value().name());
        }
        try {
            return joinPoint.proceed();
        }
        finally {
            // 销毁数据源 在执行方法之后
            DynamicDataSourceContextHolder.clearDataSourceType();
        }
    }

    /**
     * 获取需要切换的数据源
     */
    public DataSource getDataSource(ProceedingJoinPoint point)
    {
        MethodSignature signature = (MethodSignature) point.getSignature();
        com.LYJ.study.DynamicDataSource.annocation.DataSource dataSource = AnnotationUtils.findAnnotation(signature.getMethod(), com.LYJ.study.DynamicDataSource.annocation.DataSource.class);
        if (Objects.nonNull(dataSource)) {
            return dataSource;
        }
        return AnnotationUtils.findAnnotation(signature.getDeclaringType(), DataSource.class);
    }
}

10、在业务中使用

047da38f2fbf4c12bd08862b9eb125cb.png

@Service
@RequiredArgsConstructor
@DataSource(value=DataSourceType.MASTER)
//@DataSource(value=DataSourceType.SLAVE)
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements UserService {

    private final UserMapper userMapper;
    @Override
    @DataSource(value=DataSourceType.MASTER)
    //@DataSource(value=DataSourceType.SLAVE)
    public List<User> queryAll() {
        return userMapper.selectList(null);
    }
}

我们在service、mapper的类和方法上使用都可以。 

补充：有很多从数据源怎么办？ 

我们上面已经配置了一个从数据源了，接下来我们继续配置多个从数据源

首先在application-druid.yml文件添加新的数据源

4f889c09f9854a06bdfb41bf03773d3f.png

在枚举添加数据源名称


//如果配置多数据源，继续添加即可
public enum DataSourceType
{
    /**
     * 主库
     */
    MASTER,

    /**
     * 从库
     */
    SLAVE,
    /**
     * 从库2
     */
    SLAVE2
}

 4a6c1e4cb24d44e6ba4a167b377cc2b0.png

如何切换数据库？

我们就以Oracle为例

 <!--oracle驱动-->
    <dependency>
      <groupId>com.oracle</groupId>
      <artifactId>ojdbc6</artifactId>
      <version>11.2.0.3</version>
    </dependency>

在application-druid.yml添加

      slave3:
        # 从数据源开关/默认关闭
        enabled: true
        url: jdbc:oracle:thin:@127.0.0.1:1521:oracle
        username: root
        password: password

 然后删除指定的mysql驱动，默认会自动寻找驱动7b37f9d30cbe4cdfb4c61b174a47fb13.png

添加数据源和用法参考上面即可，都是一样的。 

注意：在切换数据库时，因为mysql跟Oracle的sql语法有差别，启动时可能报错。

 

 

小杰不秃头
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
基于SpringBoot框架搭建的物联网数据采集系统服务器端（源码+项目说明）.zip
01-09
* 默认请求路径 http://localhost:8080/ 8080为SpringBoot内置Tomcat端口，可在application.yml文件中修改。 * 以下所有API除测试、用户相关的/login、/info、/exit之外，都会被登录拦截器所拦截，调用其他API需要...
springboot+mybatisPlus+druid实现动态数据源切换，使用Aop+注解实现
weixin_58569348的博客
04-05 1935
以上的就是mybatisPlus+druid实现多数据源的步骤，步骤仅做参考，有不对的地方，欢迎大家交流指导。
springboot多数据源dynamic-datasource方式
北风浊酒
02-07 3257
背景 项目中需要连接多个数据源，可能是一主多从，或者不同的多数据源，或者多个不同类型的数据源如项目中有mysql库也有oracle库 具体配置 1.pom配置 <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.0.1</vers
Spring Boot应用中如何动态指定数据库，实现不同用户不同数据库的场景
qq_38140936的博客
06-11 322
当在 Spring Boot 应用程序中使用进行数据库操作时，配置Schema名称是一种常见的做法。然而，在某些情况下，模式名称需要是动态的，可能会在应用程序运行时发生变化。比如：需要做数据隔离的SaaS应用。所以，这篇博文将帮助您解决了在 Spring Boot 应用程序中如何设置动态 Schema。
springboot实现数据库故障自动切换
欧气满满大顺顺的博客
12-27 1630
通过以上配置和代码，系统会定期检测主数据库的可用性，如果主数据库不可用，则自动切换到备用数据库，保证系统的可用性。在 application.properties 或 application.yml 文件中设置主备数据库的配置，包括连接信息和其他相关配置。创建一个动态数据源，根据具体情况选择使用主数据库或备用数据库。可以使用 Spring Boot 提供的。实现数据库故障自动切换的方案可以借助数据库连接池和心跳检测机制。配置两个数据源并分别创建对应的数据库连接池对象，例如使用 HikariCP 连接池。
基于SpringBoot+Vue+计算机视觉的餐厅自助结算系统源码+数据库(毕业设计).zip
07-05
数据库连接及后端端口号在application.yaml文件中修改。 首次运行前需首先在后台设置支付宝接口的相关配置。 测试账号： 管理员：admin 123456 终端机器：东餐厅一号机 123456 ## 改进方向 毕业设计项目，时间...
基于Java+Springboot+vue的智能停车场管理系统(源代码+数据库.zip
03-05
例如，通过计算机视觉技术，可以实现自动识别车辆的车牌号码，实现无感出入；通过机器学习算法，可以预测停车场的车位使用情况，为用户提供最佳停车建议。 六、系统分析与设计 在系统分析阶段，需明确系统的目标、...
Android 卡片层叠式可动态切换布局-IT计算机-毕业设计.zip
04-05
在Android开发领域，卡片层叠式可动态切换布局是一种常见的用户界面设计模式，它能够提供丰富的视觉效果和交互体验。这种布局方式常用于展示信息集合，例如新闻、图片或者产品列表，用户可以通过滑动或者点击来切换...
基于openvc，车牌号识别以及图像处理springboot项目-java
10-12
【标题】中的“基于OpenCV，车牌号识别以及图像处理SpringBoot项目”是一个结合了计算机视觉库OpenCV、车牌识别技术和SpringBoot框架的Java开发项目。这个项目的主要目的是实现一个图像处理服务，能够自动识别图像中...
Lumos学习王佩丰Excel第四讲：排序与选择
Sunshine_XX的博客
07-10 369
自定义排序演示：工资条拆分的演示：如果遇到很长的表，标题只存在于顶端，打印出来观感不好，可以这样做：有些版本的excel复制筛选数据容易把背后隐藏的所有数据都复制上去，这时可选中定位条件的“可见单元格”选项，复制粘贴即可。并排表示且，错排表示或。ctrl+shift+↓+→全选，演示说明：回头学原理，先记住一句话，要想筛选对，条件表头不要对。
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
cy1641395022的博客
07-10 686
Autoware.universe 高效学习第三章 -- 智驾技术务虚会之智驾技术栈讨论 其一
ROS基础学习-ROS运行管理
周陽讀書
07-11 754
ROS运行管理。
昇思MindSpore 25天学习打卡营|day20
weixin_42036358的博客
07-13 541
生成式对抗网络(Generative Adversarial Networks，GAN)是一种生成式机器学习模型，是近年来复杂分布上无监督学习最具前景的方法之一。最初，GAN由Ian J. Goodfellow于2014年发明，并在论文生成器的任务是生成看起来像训练图像的“假”图像；判别器需要判断从生成器输出的图像是真实的训练图像还是虚假的图像。GAN通过设计生成模型和判别模型这两个模块，使其互相博弈学习产生了相当好的输出。GAN模型的核心在于提出了通过对抗过程来估计生成模型这一全新框架。
Python 学习中什么是异常处理，如何使用 try、except、finally ？
Itmastergo的博客
07-12 727
异常是程序执行过程中发生的非正常事件，这些事件会中断正常的程序指令流。当程序遇到错误时，Python 会抛出一个异常对象，异常对象包含了错误的类型和相关的信息。
Qt/QML学习-动画元素
QT、QML
07-12 1127
Qt/QML学习-动画元素
学懂C#编程：常用框架学习（二）——初学者如何学习WPF之MVVM模式
martian665的专栏
07-10 560
初学者如何学习WPF之MVVM模式
7.11日学习打卡----初学Redis（六）
m0_74436895的博客
07-11 1006
在现有企业中80%公司大部分使用的是Redis单机服务，在实际的场景当中单一节点的Redis容易面临风险。
昇思25天学习打卡营第19天|ShuffleNet图像分类
randomize0的专栏
07-12 1035
在第15-18日的学习内容中，我们陆陆续续学习了计算机视觉相关的模型包括图像语义分割、图像分类、目标检测等内容，这些模型的运算往往都是在大算力设备上运行的，今天学习一种可以在移动设备上运行的图像分类模型-“ShuffleNet”。ShuffleNetV1是旷视科技提出的一种计算高效的CNN模型，和MobileNet, SqueezeNet等一样主要应用在移动端，所以模型的设计目标就是利用有限的计算资源来达到最好的模型精度。
node.js的安装及学习（node/nvm/npm的区别）
最新发布
Future_yzx的博客
07-14 291
node.js 一种Javascript编程语言的运行环境，能够使得javascript能够脱离浏览器运行。以前js只能在浏览器（也就是客户端）上运行，node.js将浏览器中的javascript运行环境进行封装的，使得该语言也可以在服务端运行。node.js=Google的V8引擎+内置基本模块（大多用JavaScript编写），类似JRE=JVM+java标准库node.js诞生之前，JavaScript只能运行于浏览器，现在也可以在服务器端运行于node.js;
springboot+mybatis中怎么获取数据库中某一个字段的所有值并把它封装起来
03-29
在Spring Boot中使用MyBatis可以通过以下步骤获取数据库中某一个字段的所有值并将其封装起来： 1. 在Mapper中定义一个方法，用于查询某一个字段的所有值： ``` @Mapper public interface MyMapper { List<String> getColumnValues(); } ``` 2. 在Mapper.xml中编写SQL语句，查询某一个字段的所有值： ``` <select id="getColumnValues" resultType="java.lang.String"> SELECT column_name FROM table_name; </select> ``` 3. 在Service层中调用Mapper中的方法，获取某一个字段的所有值： ``` @Service public class MyService { @Autowired private MyMapper myMapper; public List<String> getColumnValues() { return myMapper.getColumnValues(); } } ``` 4. 在Controller层中调用Service层中的方法，将某一个字段的所有值封装起来并返回给前端： ``` @RestController public class MyController { @Autowired private MyService myService; @GetMapping("/columnValues") public List<String> getColumnValues() { return myService.getColumnValues(); } } ``` 这样就可以获取数据库中某一个字段的所有值并将其封装起来返回给前端。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小杰不秃头

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

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

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

打赏作者

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

抵扣说明：

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

余额充值