Spring定时器的配置从1.0到5.0的演进

最新推荐文章于 2022-09-27 22:44:53 发布
最新推荐文章于 2022-09-27 22:44:53 发布
阅读量155 收藏 1
点赞数
文章标签： java
原文链接：https://my.oschina.net/dachengxi/blog/882839
版权

这里主要是记录下从Spring1.0到现在的5.0中定时器的配置方式，关于源码，暂先不解释。主要用作自己记录用，如果有错误的还请指出一起改正学习，免得误导别人，谢谢。

Spring1中定时器的配置

直接看Spring1.1.1的文档，里面都已经给出来了各种配置方式，更高版本的也都包含了这些，但是觉得看1.1.1的更纯粹一些。

Spring1中对定时器的支持有两种方式：

  • jdk的Timer
  • Quartz Scheduler

Quartz Scheduler

Quartz Scheduler使用Triggers，Jobs，JobDetail来实现定时器功能。Spring提供了对Quartz的支持。

使用的大概步骤是：

  1. 定义JobDetail，也就是定义具体的任务。
  2. 定义trigger，就是定义触发器，指定什么任务，在什么时间执行或者隔多久执行。
  3. 定义SchedulerFactoryBean，来执行任务。

下面我们以一个例子来说明，是一个定时的去获取信息和定时统计信息的示例。

定义JobDetail

定义JobDetail有两种方式，一种是使用JobDetailBean，一种是使用MethodInvokingJobDetailFactoryBean，后者可以指定要执行的具体方法。

使用JobDetailBean

CountUserJob：

package me.cxis.spring.scheduling.quartz;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * Created by cheng.xi on 2017-04-19 11:00.
 * 定时的统计信息的JOb
 * 比如这里是定时的统计系统中总的用户数，总的用户数是我查询到的数和我在xml指定的数的总和
 */
public class CountUserJob extends QuartzJobBean{

    private int adminUser;

    public void setAdminUser(int adminUser) {
        this.adminUser = adminUser;
    }

    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        //执行真正的统计任务
        System.out.println("开始统计系统中人数");
        System.out.println("统计完成，共有101人");
        System.out.println("加上系统管理员之后共有" + (adminUser + 101) + "人");
    }
}

xml中声明一个job：

<!--定义一个JobDetailBean类型的Job，用来统计系统中总的人数，adminUser指的是系统中预先留的管理员数目-->
<bean name="countUserJob" class="org.springframework.scheduling.quartz.JobDetailBean">
    <property name="jobClass">
        <value>me.cxis.spring.scheduling.quartz.CountUserJob</value>
    </property>
    <property name="jobDataAsMap">
        <map>
            <entry key="adminUser">
                <value>10</value>
            </entry>
        </map>
    </property>
</bean>
使用MethodInvokingJobDetailFactoryBean

MethodInvokingJobDetailFactoryBean可以指定方法。直接看例子。

GetJob：

package me.cxis.spring.scheduling.quartz;

/**
 * Created by cheng.xi on 2017-04-19 11:01.
 * 定时的获取信息的Job，定时从文件中获取数据
 */
public class GetJob {
    public void getSomethingFromFile(){
        System.out.println("从文件中获取数据。。。。");
    }
}

xml中配置：

<!--从文件中获取信息的bean-->
<bean id="getJob" class="me.cxis.spring.scheduling.quartz.GetJob"/>

<!--定义一个MethodInvokingJobDetailFactoryBean，从文件中获取数据的Job-->
<bean id="getJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="targetObject"><ref bean="getJob"/></property>
    <property name="targetMethod"><value>getSomethingFromFile</value></property>
</bean>

定义Triggers

上面我们把JobDetail都定义好了，也都配置好了，但是怎么去执行，多长时间执行一次都没有说明，这时候需要定义Triggers来描述任务什么时候执行等。只需要在xml中配置就可以了。

Triggers也有两种方式，一种是SimpleTriggerBean，一种是CronTriggerBean。我们的例子中，统计用户数使用SimpleTriggerBean，从文件中获取信息使用CronTriggerBean。

<!--定义Triggers，统计用户数-->
<bean id="countUserTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
    <property name="jobDetail">
        <ref bean="countUserJob"/>
    </property>
    <!--第一次执行之前需要等待的时间-->
    <property name="startDelay">
        <!--10秒-->
        <value>10000</value>
    </property>
    <!--任务重复时间，每隔多少时间执行一次-->
    <property name="repeatInterval">
        <value>20000</value>
    </property>
</bean>

<!--定义Triggers，定时从文件中获取数据-->
<bean id="getJobTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
    <property name="jobDetail">
        <ref bean="getJobDetail"/>
    </property>
    <property name="cronExpression">
        <!--cron表达式，这里是每隔两分钟执行一次-->
        <value>0 0/2 * * * ?</value>
    </property>
</bean>

定义SchedulerFactoryBean

<!--定义SchedulerFactoryBean-->
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref local="countUserTrigger"/>
            <ref local="getJobTrigger"/>
        </list>
    </property>
</bean>

测试

Main：

package me.cxis.spring.scheduling.quartz;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by cheng.xi on 2017-04-19 11:34.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-quartz.xml");
    }
}

JDK Timer

使用JDK Timer，也跟上面类似，大概的步骤是：

  1. 创建一个TimerTask，里面是执行任务的逻辑。
  2. 创建ScheduledTimerTask，就是什么时候或者隔多久执行任务。
  3. 创建TimerFactoryBean，来执行任务。

创建TimerTask

同样，创建一个Task也有两种方式，一种是继承TimerTask，另外一种是使用MethodInvokingTimerTaskFactoryBean，后者可以指定具体方法。

继承TimerTask

CountUserTask：

package me.cxis.spring.scheduling.timer;

import java.util.TimerTask;

/**
 * Created by cheng.xi on 2017-04-19 11:00.
 * 定时的统计信息的 task
 * 比如这里是定时的统计系统中总的用户数，总的用户数是我查询到的数和我在xml指定的数的总和
 */
public class CountUserTask extends TimerTask{

    private int adminUser;

    public void setAdminUser(int adminUser) {
        this.adminUser = adminUser;
    }

    public void run() {
        //执行真正的统计任务
        System.out.println("开始统计系统中人数");
        System.out.println("统计完成，共有101人");
        System.out.println("加上系统管理员之后共有" + (adminUser + 101) + "人");
    }
}

在xml中配置bean：

<!--统计用户数的bean-->
<bean id="countUserTask" class="me.cxis.spring.scheduling.timer.CountUserTask">
    <property name="adminUser">
        <value>10</value>
    </property>
</bean>
使用MethodInvokingTimerTaskFactoryBean

GetTask:

package me.cxis.spring.scheduling.timer;

/**
 * Created by cheng.xi on 2017-04-19 11:01.
 * 定时的获取信息的task，定时从文件中获取数据
 */
public class GetTask {
    public void getSomethingFromFile(){
        System.out.println("从文件中获取数据。。。。");
    }
}

xml中配置：

<!--从文件中获取信息的bean-->
<bean id="getTaskBean" class="me.cxis.spring.scheduling.timer.GetTask"></bean>

<!--使用MethodInvokingTimerTaskFactoryBean-->
<bean id="getTask" class="org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean">
    <property name="targetObject"><ref bean="getTaskBean"/> </property>
    <property name="targetMethod"><value>getSomethingFromFile</value></property>
</bean>

创建ScheduledTimerTask

定义ScheduledTimerTask来描述任务什么时候执行等。只需要在xml中配置就可以了。

使用Timer的方式，就这么一种配置，没法使用cron的方式。

<!--创建统计用户的ScheduledTimerTask，描述任务怎么运行-->
<bean id="countUserScheduledTimerTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    <property name="delay">
        <value>10000</value>
    </property>
    <property name="period">
        <value>20000</value>
    </property>
    <property name="timerTask">
        <ref local="countUserTask"/>
    </property>
</bean>

<!--创建从文件获取信息的ScheduledTimerTask，描述任务怎么运行-->
<bean id="getScheduledTimerTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
    <property name="period">
        <value>60000</value>
    </property>
    <property name="timerTask">
        <ref local="getTask"/>
    </property>
</bean>

创建TimerFactoryBean

任务执行的配置：

<!--创建TimerFactoryBean，执行任务-->
<bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
    <property name="scheduledTimerTasks">
        <list>
            <ref local="countUserScheduledTimerTask"/>
            <ref local="getScheduledTimerTask"/>
        </list>
    </property>
</bean>

测试

package me.cxis.spring.scheduling.timer;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;
import java.io.InputStream;

/**
 * Created by cheng.xi on 2017-04-19 11:34.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-timer.xml");
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

上面就是Spring1.x中关于定时器的配置方式，配置清晰，易懂，但是任务多了之后，就会发现配置文件会迅速变得臃肿。

Spring2中定时器的配置

What's new in Spring 2.0?

  • 增加对Executors的支持

上面就是AOP在2.0版本新增的特性，1.0的所有AOP配置方式在2.0中都支持，下面主要看看2.0中新增的一些方法。

Spring2.0中新定义了一个TaskExecutor接口，增加了对线程池的支持，这个接口的功能跟JDK1.5中的Executor接口一样。那么2.0中线程池的增加，对定时器有什么影响呢？其实就是可以在定时任务执行的时候，使用线程池来执行任务，我们不用关心其他的实现。

Spring2中配置示例

直接看示例，我们定时，每隔5分钟，每次都从20个文件中同时获取数据。

首先写实际执行业务的类，

package me.cxis.spring.scheduling.executor;

/**
 * Created by cheng.xi on 2017-04-19 14:51.
 * 从文件中获取数据的Task
 */
public class GetDataFromFileTask implements Runnable {

    private int fileId;

    public GetDataFromFileTask(int fileId){
        this.fileId = fileId;
    }

    public void run() {
        //真正执行从文件中获取数据的逻辑
        System.out.println("从文件" + fileId + "中获取数据");
    }
}

然后是执行任务的定时器：

package me.cxis.spring.scheduling.executor;

import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

import java.util.TimerTask;

/**
 * Created by cheng.xi on 2017-04-19 14:54.
 * 批量从文件中获取数据的定时器
 */
public class GetDataFromFileScheduler extends TimerTask {

    private ThreadPoolTaskExecutor executor;

    public void setExecutor(ThreadPoolTaskExecutor executor) {
        this.executor = executor;
    }

    public void run() {
    	System.out.println("CorePoolSize:" + taskExecutor.getCorePoolSize() + ";MaxPoolSize:" + taskExecutor.getMaxPoolSize());
        //每次都会同时执行从20个文件中获取数据
        for(int i = 0; i < 20;i++){
            executor.execute(new GetDataFromFileTask(i));
        }
    }
}

接着是xml的配置：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
    <!--线程池taskExecutor-->
    <bean id="taskExecutor" class="org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor">
        <!--核心线程数-->
        <property name="corePoolSize">
            <value>5</value>
        </property>
        <!--最大线程数-->
        <property name="maxPoolSize">
            <value>10</value>
        </property>
        <!--队列最大长度-->
        <property name="queueCapacity">
            <value>40</value>
        </property>
    </bean>

    <!--GetDataFromFileScheduler，获取数据的定时器-->
    <bean id="getDataFromFileScheduler" class="me.cxis.spring.scheduling.executor.GetDataFromFileScheduler">
        <property name="taskExecutor">
            <ref local="taskExecutor"/>
        </property>
    </bean>

    <!--创建统计用户的ScheduledTimerTask，描述任务怎么运行-->
    <bean id="getDataFromFileTimerTask" class="org.springframework.scheduling.timer.ScheduledTimerTask">
        <property name="delay">
            <value>10000</value>
        </property>
        <property name="period">
            <value>20000</value>
        </property>
        <property name="timerTask">
            <ref local="getDataFromFileScheduler"/>
        </property>
    </bean>

    <!--创建TimerFactoryBean，执行任务-->
    <bean id="timerFactory" class="org.springframework.scheduling.timer.TimerFactoryBean">
        <property name="scheduledTimerTasks">
            <list>
                <ref local="getDataFromFileTimerTask"/>
            </list>
        </property>
    </bean>

</beans>

测试类：

package me.cxis.spring.scheduling.executor;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Created by cheng.xi on 2017-04-19 15:11.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-executor.xml");
    }
}

上面就是结合线程池的示例。也就是在执行任务的时候多了线程池，基本的配置方式使用方法基本没变。

Spring3中定时器的配置

  • Spring3中TaskExecutor继承了JDK的Executor。使用方面还是跟原来2.0一样。
  • Spring3中还引入了新的接口TaskScheduler，Trigger，TriggerContext等。
  • Spring3中还引入了task的命名空间<task:scheduler/>，<task:executor/>，<task:scheduled-tasks/>等。
  • Spring3中还支持注解的方式@Scheduled，@Async，使配置更加简化。使用注解的方式，需要在配置文件中先开启注解支持<task:annotation-driven/>

注解方式的示例如下。

CountUserTask：

package me.cxis.spring.scheduling.annotation;


import org.springframework.scheduling.annotation.Scheduled;

/**
 * Created by cheng.xi on 2017-04-19 11:00.
 * 定时的统计信息的Task
 *
 */
public class CountUserTask{

    //@Scheduled(cron="*/5 * * * * MON-FRI") cron的方式
    //下面是固定时间，每隔5秒执行一次
    @Scheduled(fixedRate = 5000)
    public void countUser(){
        //执行真正的统计任务
        System.out.println("开始统计系统中人数");
        System.out.println("统计完成，共有101人");
    }
}

配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:task="http://www.springframework.org/schema/task"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

    <!--开启task的注解支持-->
    <task:annotation-driven />

    <!--执行任务的bean-->
    <bean id="countUserTask" class="me.cxis.spring.scheduling.annotation.CountUserTask"/>
</beans>

测试：

package me.cxis.spring.scheduling.annotation;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * Created by cheng.xi on 2017-04-19 16:08.
 */
public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:scheduling-annotation.xml");
        try {
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

可以看到，使用注解的方式简化了很多很多。

Spring4和Spring5中定时器的配置

Spring4中增加了@EnableScheduling注解来启用对@Scheduled注解的支持。其他的基本没有什么变化，使用方式还是跟以前一样，现在使用注解更多。

原文链接

转载于:https://my.oschina.net/dachengxi/blog/882839

chijunmei7041
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Spring5自带的定时任务
辣椒炒肉~的博客
04-17 231
对Spring5自带的定时任务 SpringTask 进行总结： @Scheduled(cron=“0 */5 * * * ?”)
spring 5.x 系列第21篇 —— spring 定时任务 (xml配置方式)
黑白影的博客
01-29 1352
源码Gitub地址：https://github.com/heibaiying/spring-samples-for-all 一、说明 1.1 项目结构说明 关于任务的调度配置定义在springApplication.xml中，为方便观察项目定时执行的情况，项目以web的方式构建。 1.2 依赖说明 导入基本依赖 &amp;amp;lt;?xml version=&amp;quot;1.0&amp;quot; encoding=&amp;quot;UTF-
spring 配置触发器
Liaq325的专栏
12-07 1万+
在Spring中配置Quartz 前面介绍过了Timer在Spring中的实现，今天接前文介绍Quartz在Spring中的配置.       而Quartz类库不但有着上述JDK的Timer类库类似的配置，更重要的，它还有着类似于unix的cron服务的配置;  正是基于cron服务的配置使Quartz能方便、清晰指定启动时间，让开发者更青睐于它。       在调度方式上，不同于Time
在properties.xml中定义变量，在application.xml中取值问题
weixin_33895657的博客
04-20 424
如果为application.xml中的变量赋默认值，同时又在properties.xml中变量赋值，而加载后是取不到properties.xml中的值的问题。 解决这个问题需要加上黑体部分配置： &lt;bean id="sysConfiguration" class="org.springframework.beans.factory.config.PropertyPlaceholderC...
spring定时器配置方便以后使用
不懂就问
12-28 388
<bean id="lctcBiz" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"> 调度工厂实例化后，经过0秒开始执行调度 每10秒调度一次 -->
spring-framework-1.0-m1.zip源码
06-03
2. 控制反转：IoC是指应用程序的控制权从应用程序本身转移到框架，Spring容器根据配置文件动态地创建、装配和管理对象。这种设计模式使得组件之间解耦，降低了系统复杂度。 三、核心组件分析 1. ...
JAVA中 Spring定时器的两种实现方式
09-03
这两种定时器在Spring中的使用和配置有所不同，各有优缺点，适合不同的应用场景。 1. **Java Timer定时** Java Timer定时器是Java标准库的一部分，使用相对简单。要在Spring中使用，首先需要创建一个继承自`...
Spring定时器配置详解（附demo）
03-20
本篇将详细介绍如何在Spring中配置定时器，并通过一个实际的Demo来加深理解。 一、Spring定时任务概述 Spring提供了两种主要的定时任务实现方式：`TaskScheduler`和`TaskExecutor`，以及基于Quartz的`Spring...
Spring定时器配置详解
01-17
Spring 定时器配置详解 Spring 定时器是一种基于 Quartz 的任务调度框架，它提供了一个灵活的方式来管理和控制任务的执行。下面是 Spring 定时器配置的详细解释。 配置 CronTriggerBean CronTriggerBean 是 ...
spring定时器配置
06-14
Spring定时任务配置是Spring框架中实现定时任务调度的重要部分，主要使用了Quartz库来管理定时任务。在Spring XML配置文件中...通过这种方式，Spring定时器可以方便地集成到任何Spring应用中，实现定时执行的业务逻辑。
Spring定时任务的几种实现
weixin_30516243的博客
01-21 1600
近日项目开发中需要执行一些定时任务，比如需要在每天凌晨时候，分析一次前一天的日志信息，借此机会整理了一下定时任务的几种实现方式，由于项目采用spring框架，所以我都将结合spring框架来介绍。一．分类从实现的技术上来分类，目前主要有三种技术（或者说有三种产品）：Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的...
Spring的两种定时器
热门推荐
奇华资料的博客
08-21 4万+
1. spring学习系列 -- 定时器一TimerTask spring定时器一般有两种： TimerTask、Quartz。本节只讲TimerTask 需要的包： aopalliance-1.0.jar commons-logging-1.1.1.jar spring-aop-3.0.6.RELEASE.jar spring-asm-3.0.6.RELEASE.jar spri...
不明觉厉的spring(5)---Spring定时调度服务
Senssic
10-17 2570
spring3之前的定时调度服务 spring3对定时调度的新支持 使用Quartz任务调度 SimpleTriggerBean（可以周期性地执行Job） CronTriggerBean（功能更为强大,能指定何时执行Job）
使用Spring的定时器@Scheduled注解实现定时任务
Mr__Viking的博客
07-03 1151
在很多时候我们在项目中需要周期性地执行一些操作，并且这些操作不能通过简单的for循环和while循环来实现，因此我们需要有一个可以实现定时操作的方法，在spring中就有这么一个非常方便的方法，下面就简单记录下@Scheduled注解的使用方法。1、首先我们需要一个spring项目，这个是前提条件。然后我们需要在.xml的配置文件中引入xmlns:task="http://www.springfr...
【Spring学习】spring提供的三种定时任务
lmb55的专栏
01-18 1568
在spring中我们有三种不同的定时任务：基于Quartz的定时机制、基于Timer的定时机制、基于Executor的定时机制。 1、基于Quartz的定时任务机制 下面详细解释这个类图中涉及的关键类及其使用场景 1.1. SchedulerFactoryBean 这是Spring中基于Quartz的定时机制入口，只要Spring容器装载了这个类，Quartz定时机制就会启动，并加载定...
Spring使用TimerTask配置调度事务
我的世界我的梦
06-05 5725
首先我们编写调度服务,继承java.util.TimerTask package TimerTest;import java.util.Date;import java.util.TimerTask;public class TimerService extends TimerTask ...{        public void run() ...{        System.o
Spring定时器的两种实现方式
李熠专用博客_白帽子一枚，人称低危终结者
02-22 1945
有两种流行Spring定时器配置：Java的Timer类和OpenSymphony的Quartz。 1.Java Timer定时 首先继承java.util.TimerTask类实现run方法 import java.util.TimerTask; public class EmailReportTask extends TimerTask{ @Override
spring 1.0-5.0版本注解发展史(一)
ChengXugu111的博客
09-27 786
spring 1.0-5.0版本注解发展史： @Required 注解， spring 引入InitializinBean 接口。通过实现该接口 afterpropertiesSet() 方法 ，完成属性的校验，ApplicationContextAware
spring定时器的两种配置方式
w592376568的博客
02-06 3084
1、加入依赖包： org.quartz-scheduler quartz 2.2.1 org.quartz-scheduler quartz-jobs 2.2.1  2、第一种方式： 写一个方法，并在其上方加入@Scheduled注释即可，如： @Scheduled(cron = "0 0 0/2 * * ?") public voi
Spring-从入门到精通.ppt
最新发布
11-19
Spring的安装过程相对简单，只需从官方网站下载相应版本，将其jar包添加到项目类路径中，并配置ApplicationContext.xml文件来定义bean和它们的依赖关系。随着Java社区的发展，Spring也在不断进化，现在还有Spring ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值