quarzt与分布式调度

最新推荐文章于 2023-06-29 15:28:55 发布
最新推荐文章于 2023-06-29 15:28:55 发布
阅读量543 收藏
点赞数
分类专栏： 小记/项目实战记录
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/worn_xiao/article/details/80473996
版权

1.1 java中使用quartz

1.1.1集成jar包

<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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.xiao.it</groupId>
  <artifactId>testJob</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>war</packaging>
     <properties>  
       <springframework.version>4.1.3.RELEASE</springframework.version>  
       <quartz.version>2.2.1</quartz.version>  
   </properties>  
    <dependencies>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-core</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-context-support</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
        <!-- Transaction dependency is required with Quartz integration -->  
        <dependency>  
            <groupId>org.springframework</groupId>  
            <artifactId>spring-tx</artifactId>  
            <version>${springframework.version}</version>  
        </dependency>  
        <dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-webmvc</artifactId>
				<version>${springframework.version}</version>
	    </dependency>
           
        <!-- Quartz framework -->  
        <dependency>  
            <groupId>org.quartz-scheduler</groupId>  
            <artifactId>quartz</artifactId>  
            <version>${quartz.version}</version>  
        </dependency>  
    </dependencies>  
    <build>  
        <pluginManagement>  
            <plugins>  
                <plugin>  
                    <groupId>org.apache.maven.plugins</groupId>  
                    <artifactId>maven-compiler-plugin</artifactId>  
                    <version>3.2</version>  
                    <configuration>  
                        <source>1.6</source>  
                        <target>1.6</target>  
                    </configuration>  
                </plugin>  
            </plugins>  
        </pluginManagement>  
    </build>  
</project>

1.1.2创建job相关的类

public class HelloQuatzJob implements Job{
	@Override
	public void execute(JobExecutionContext arg0) throws JobExecutionException {
		// TODO Auto-generated method stub
		System.out.println("定时任务执行时间 "+new Date());
	}
}

1.1.3调用类

public class TestJob {
	public static void main(String[] args) throws SchedulerException {
		SchedulerFactory chedule=new StdSchedulerFactory();
		Scheduler scheduler = chedule.getScheduler();
		//定义一个任务
		JobDetail detail=JobBuilder.
				newJob(HelloQuatzJob.class)
				.withIdentity("testjob1", "group1")
				.build();
		Date runTime = DateBuilder.evenSecondDateAfterNow(); 
		//定义一个触发器
		Trigger trigger=TriggerBuilder.newTrigger()
				.withIdentity("trigger1", "group1")
				.startAt(runTime)//设置触发开始时间
				.withSchedule(
					SimpleScheduleBuilder.repeatSecondlyForever(2)
					.withIntervalInSeconds(2)//时间间隔
				).build();
		scheduler.scheduleJob(detail, trigger);
		scheduler.start();
    }
}

1.1.4结果图

1.2 spring集成quartz

1.2.1集成jar包同1.1.1

1.2.2创建简单job 

public class SimpleSpringQuatz {
	public void printJob(){
		System.out.println("定时任务执行时间 "+new Date());
	}
}

1.2.3创建复杂job

public class ComplexSchejob extends QuartzJobBean{
	private ComplexJobClasExe complexBean;
	@Override
	protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
		// TODO Auto-generated method stub
		complexBean.print();
	}
	public ComplexJobClasExe getComplexBean() {
		return complexBean;
	}
	public void setComplexBean(ComplexJobClasExe complexBean) {
		this.complexBean = complexBean;
	}
}

public class ComplexJobClasExe {
	public void print(){
		System.out.println("复杂任务:"+new Date());
	}
}

1.2.4 spring中进行配置

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
http://www.springframework.org/schema/mvc 
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.2.xsd 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
	<bean id="simpleBean"  class="testJob.SimpleSpringQuatz"></bean>
	<bean id="complexBean" class="testJob.ComplexJobClasExe"></bean>
    <bean id="simpleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
        <property name="targetObject" ref="simpleBean" />  
        <property name="targetMethod" value="printJob" />  
    </bean>  
    <bean id="complexJobDetail"    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="testJob.ComplexSchejob" />  
        <property name="jobDataMap">  
            <map>  
                <entry key="complexBean" value-ref="complexBean" />  
            </map>  
        </property>  
        <property name="durability" value="true" />  
    </bean>  
    <bean id="simpleTrigger"  class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">  
        <property name="jobDetail" ref="simpleJobDetail" />  
        <property name="startDelay" value="1000" />  
        <property name="repeatInterval" value="2000" />  
    </bean>  
    <bean id="cronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="complexJobDetail" />  
        <property name="cronExpression" value="0/5 * * ? * *" />  
    </bean>  
    <bean  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="jobDetails">  
            <list>  
                <ref bean="simpleJobDetail" />  
                <ref bean="complexJobDetail" />  
            </list>  
        </property>  
        <property name="triggers">  
            <list>  
                <ref bean="simpleTrigger" />  
                <ref bean="cronTrigger" />  
            </list>  
        </property>  
    </bean>  
</beans>

1.2.5结果图



1.3 spring+quartz集群

1.3.1 建表


如上图所示从官网上下载quartz的包，找到对应的SQL并且执行对应的sql


生成quartz框架所需要的工作表。

1.3.2添加依赖


<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-context</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>  
	            <groupId>org.springframework</groupId>  
	            <artifactId>spring-context-support</artifactId>  
	            <version>${spring.version}</version>  
        	</dependency> 
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-beans</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-webmvc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-jdbc</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>
				<groupId>org.springframework</groupId>
				<artifactId>spring-aspects</artifactId>
				<version>${spring.version}</version>
			</dependency>
			<dependency>  
	            <groupId>org.quartz-scheduler</groupId>  
	            <artifactId>quartz</artifactId>  
	            <version>${quartz.version}</version>  
        	</dependency>

1.3.3 添加配置spring-quartz.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
http://www.springframework.org/schema/mvc 
http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd 
http://www.springframework.org/schema/context 
http://www.springframework.org/schema/context/spring-context-3.2.xsd 
http://www.springframework.org/schema/aop 
http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
http://www.springframework.org/schema/tx 
http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
	<bean id="test" class="yonyou.worn.quartz.TestQuartJobClass"></bean>
	<bean id="test1" class="yonyou.worn.quartz.TestQuartJobClass"></bean>

    <bean id="TestjobTask" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="durability" value="true" />
        <property name="jobClass">
            <value>yonyou.worn.quartz.QuartJobClassBean</value>
        </property> 
       
        <property name="jobDataAsMap">
            <map>
                <entry key="targetObject" value="test" />
                <entry key="targetMethod" value="printjob" />
             </map>
         </property> 
     </bean>
      <bean id="TestjobTask1" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="durability" value="true" />
        <property name="jobClass">
            <value>yonyou.worn.quartz.QuartJobClassBean</value>
        </property> 
       
        <property name="jobDataAsMap">
            <map>
                <entry key="targetObject" value="test" />
                <entry key="targetMethod" value="print" />
             </map>
         </property> 
     </bean>
    
    <bean name="TestTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="TestjobTask" />
        <property name="cronExpression" value="0/5  * * * * ?" />
    </bean> 
    <bean name="TestTrigger1" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="TestjobTask1" />
        <property name="cronExpression" value="0/5 * * * * ?" />
    </bean> 
    
	<bean id="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    	<property name="dataSource" ref="dataSource" />
        <!--可选，QuartzScheduler 启动时更新己存在的Job，这样就不用每次修改targetObject后删除qrtz_job_details表对应记录了 -->
        <property name="overwriteExistingJobs" value="true" />
        <!--必须的，QuartzScheduler 延时启动，应用启动完后 QuartzScheduler 再启动 -->
        <property name="startupDelay" value="3" />
        <!-- 设置自动启动 -->
        <property name="autoStartup" value="true" />
        <!-- 把spring上下 文以key/value的方式存放在了quartz的上下文中了 -->
        <property name="applicationContextSchedulerContextKey" value="applicationContext" />
        <!-- scheduler的名称 -->
        <property name="schedulerName" value="ClusterScheduler" />
    
        <property name="configLocation" value="classpath:resource/quartz.properties"/>
        <property name="triggers">
            <list>
                <ref bean="TestTrigger" />
                <ref bean="TestTrigger1" />
            </list>
        </property>
    </bean>        
</beans>

1.3.4 添加quartz.properties

#============================================================================
# Configure Main Scheduler Properties  
#============================================================================

org.quartz.scheduler.instanceName: TestScheduler
org.quartz.scheduler.instanceId: AUTO
org.quartz.jobStore.clusterCheckinInterval=20000
org.quartz.scheduler.skipUpdateCheck: true

#============================================================================
# Configure ThreadPool  
#============================================================================

org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 3
org.quartz.threadPool.threadPriority: 5

#============================================================================
# Configure JobStore  
#============================================================================

org.quartz.jobStore.misfireThreshold: 60000

org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX

#org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
#org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
#org.quartz.jobStore.useProperties: false
#org.quartz.jobStore.dataSource: myDS
#org.quartz.jobStore.tablePrefix: QRTZ_
org.quartz.jobStore.isClustered: true

#============================================================================
# Configure Datasources  
#============================================================================

#org.quartz.dataSource.myDS.driver: org.postgresql.Driver
#org.quartz.dataSource.myDS.URL: jdbc:postgresql://localhost/dev
#org.quartz.dataSource.myDS.user: jhouse
#org.quartz.dataSource.myDS.password: 
#org.quartz.dataSource.myDS.maxConnections: 5



#============================================================================
# Configure Plugins 
#============================================================================

##org.quartz.plugin.triggHistory.class: org.quartz.plugins.history.LoggingJobHistoryPlugin

#org.quartz.plugin.jobInitializer.class: org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin
#org.quartz.plugin.jobInitializer.fileNames: quartz_data.xml
#org.quartz.plugin.jobInitializer.failOnFileNotFound: true
#org.quartz.plugin.jobInitializer.scanInterval: 120
#org.quartz.plugin.jobInitializer.wrapInUserTransaction: false

使用集群模式的配置

org.quartz.scheduler.instanceId: AUTO

org.quartz.jobStore.clusterCheckinInterval=20000

org.quartz.jobStore.isClustered: true

1.3.5重写QuartzJobBean类

public class QuartJobClassBean extends QuartzJobBean{
	    protected final Log logger = LogFactory.getLog(getClass());
	    private String targetObject;
	    private String targetMethod;
	    private ApplicationContext ctx;
	  
	    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
	        try {
	            logger.info("execute [" + targetObject + "] at once>>>>>>");
	            Object otargetObject = ctx.getBean(targetObject);
	            Method m = null;
	            try {
	              m = otargetObject.getClass().getMethod(targetMethod, new Class[] {});
	              m.invoke(otargetObject, new Object[] {});
	            } catch (SecurityException e) {
	                logger.error(e.getMessage());
	            } catch (NoSuchMethodException e) {
	                logger.error(e.getMessage());
	            }
	        } catch (Exception e) {
	            throw new JobExecutionException(e);
	        }
	    }

	    public void setApplicationContext(ApplicationContext applicationContext){
	        this.ctx=applicationContext;
	    }
	    public void setTargetObject(String targetObject) {
	        this.targetObject = targetObject;
	    }

	    public void setTargetMethod(String targetMethod) {
	        this.targetMethod = targetMethod;
	    }
}

1.3.6编写任务类

public class TestQuartJobClass {
	public void printjob(){
		System.out.println("定时任务0:"+new Date());
	}
	public void print(){
		System.out.println("定时任务1"+new Date());
	}
}

1.3.7集群部署


模拟分布式部署

1.3.8启动测试

由以上两个图可以看出，任务调度只在一个服务器上运行了，保证了任务的不重复执行，现在假如我做一件事情就是停掉tomcaT的服务器。quartz框架将自动帮我们把任务切换到另一个服务器上执行


如上图所示tomcat停掉以后，任务自动切换到了另一个上，并且可以看出在15-50之间，在故障切换的过程中有6次定时任务没有跑，所以切换以后备用主机将会自动补跑故障以前的数据。


worn.xiao
关注
专栏目录
分布式任务调度QuartZ框架使用(通过注解使用quartz)
雾林小妖的博客
12-23 1515
springboot中使用quartz分布式任务框架及quartz中job,jobdetail,trigger,调度器概念。
Quartz架构篇 - 分布式任务调度Quartz
The Secret
01-15 2603
本文介绍分布式任务调度 Quartz
quartz的分布式调度大致分两种方式实现
06-08
一.基于JDBC-Jobstore的方式实现集群（有数据库JobStoreTX或JobStoreCMT） 二.TerracottaJobStore的配置（无数据库的集群） 本文介绍的是JDBC-Jobstore基于数据库的集群： 1.目前，群集仅适用于JDBC-Jobstore（JobStoreTX或JobStoreCMT），通过使群集的每个节点共享相同的数据库来工作。 2.负载平衡自动发生，群集的每个节点都尽可能快地触发jobs。当Triggers的触发时间发生时，获取任务的第一个节点（通过在其上放置一个锁定）是将触发它的节点。 3.当其中一个节点在执行一个或多个作业期间失败时发生故障切换。当节点出现故障时，其他节点会检测到该状况并识别数据库中在故障节点内正在进行的作业。任何标记为恢复的作业（在JobDetail上都具有“请求恢复”属性）将被剩余的节点重新执行。 没有标记为恢复的作业将在下一次相关的Triggers触发时简单地被释放以执行。 4.集群功能最适合扩展长时间运行或cpu密集型作业（通过多个节点分配工作负载）。如果需要扩展以支持数千个短期运行（例如1秒）作业，则可以考虑通过使用多个不同的调度程序（包括HA的多个群集调度程序）对作业集进行分区。 调度程序使用集群范围的锁，这种模式会在添加更多节点（超过三个节点 - 取决于数据库的功能等）时降低性能。
Quarzt
蓝色天空
03-02 121
2009-12-12 Quartz用法笔记 文章分类:Java编程 1，首先定义创建定时任务类MainTask.java Java代码 package com.lwh.action; public class MainTask { public void execute(){ System.out.printl...
quarzt
weixin_46626271的博客
05-31 131
package com.example.doublecontrol.service.impl; import com.example.doublecontrol.dao.QuartzTaskMapper; import com.example.doublecontrol.entity.QuartzTask1; import org.quartz.*; import org.springframework.beans.factory.annotation.Autowired; import org.sp
Quartz在分布式集群环境下的应用（Spring、SpringBoot）
谦虚使人发胖的博客
04-08 3611
如果仅仅只是使用定时任务，可以使用Spring的schedule实现，方便,代码量少，只需引入必要依赖及一个简单的注解即可，类似 @Scheduled(cron = "0 0 1 * * ?") public void schedule1 () { logger.info("=== 定时任务1 ===") } ...
Quarzt语法
chenpenghui1988的专栏
05-15 122
关于cron表达式（来自网络）：  Cron 表达式包括以下 7 个字段：    秒  分  小时  月内日期  月  周内日期  年（可选字段）  特殊字符    Cron 触发器利用一系列特殊字符，如下所示：    反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。  问号（?）字符和字母 L 字符只有在月内日期...
SpringBoot 整合 Quartz 实现分布式调度
十指波课堂的博客
12-23 1333
一、摘要阅读完本文大概需要 10 分钟，本文主要分享内容如下：springboot + quartz + mysql 实现持久化分布式调度集群环境任务调度测试二、Quartz 集群架构Quartz 是 Java 领域最著名的开源任务调度工具。在上篇文章中，我们详细的介绍了 Quartz 的单体应用实践，如果只在单体环境中应用，Quartz 未必是最好的选择，例如Spring Scheduled一样...
Spring整合Quartz分布式调度的示例代码
08-27
Spring整合Quartz分布式调度的示例代码 本篇文章主要介绍了Spring整合Quartz分布式调度的示例代码，主要讲解了如何使用Quartz分布式调度系统来协调每个节点执行定时任务，避免了系统资源的浪费和应用逻辑的问题。 ...
Quartz框架支持分布式任务处理
热门推荐
tanjie_123的专栏
11-21 1万+
一、问题分析 对于单机的任务调度，使用Quartz十分方便。但是在分布式情况下，对于集群中每台机器都会执行任务，从而造成了重复执行任务的问题。 二、解决思路 Quart不仅支持单机任务调度，同时也支持集群中的任务调度。原理如下： 在集群中，各个不同的机器公用同一个调度器，调度器按照一定的算法选择集群中某一台机器执行任务。 优点： 1、避免了每台机器都进行任务调度 2、避免了所有任务在
quarzt定时任务（包含动态切换数据源）
12-28
quarzt定时任务（包含动态切换数据源） quarzt定时任务（包含动态切换数据源）
Quartz使用详解
05-05
Quartz使用详解 Quartz使用详解 Quartz使用详解 Quartz使用详解 Quartz使用详解 Quartz使用详解
Quartz分布式任务调度原理
zhongzhh8的博客
12-31 9788
什么是分布式定时任务调度 定时任务调度 在很多应用场景下我们需要定时执行一些任务，比如订单系统的超时状态判断、缓存数据的定时更新等等，最简单粗暴的方式是用while(true)+sleep的组合来空转，直到到达指定时间就执行任务，但这显然非常低效。更好的方法是使用系统提供的Timer定时器或者使用Quartz框架等等。 持久化 如果只是设置一两个固定的简单的定时任务，比如只需要定时把数据从磁盘更新到内存的缓存中，那不需要考虑太多，即使节点宕机了，重启后就会继续按原有频率继续执行定时任务，所以不需要考虑定时任
quartz
qq_34172041的博客
03-03 93
quartz Quartz 是一个完全由 Java 编写的开源作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。 Scheduler：调度容器 Job：Job接口类，即被调度的任务 JobDetail ：Job的描述类，job执行时的依据此对象的信息反射实例化出Job的具体执行对象。 Trigger：触发器，存放Job执行的时间策略。用于定义任务调度时间规则。 JobStore： 存储作业和调度期间的状态 Calendar：指定排除的时间点（如排除法定节假日） 工程结构 [外链
Java Quarzt定时任务的实现
Noseparte的博客
11-30 719
Java Quarzt定时任务的实现
【Quartz】分布式定时任务
最新发布
记录了，但是完全不会。
06-29 1367
Quartz是一个功能强大且灵活的开源作业调度库，用于在Java应用程序中实现任务调度和作业管理。它提供了一种简单且可靠的方式来安排执行定时任务、重复任务或基于特定时间表的任务。
分布式定时任务quartz
yrsg666的博客
10-29 224
1、方式一，简单实现，实现QuartzJobBean 类的executeInternal方法，QuartzConfig配置具体定时信息作业详情。https://blog.csdn.net/chenmingxu438521/article/details/94485695 2、方式二、复杂但是功能强大。https://blog.csdn.net/u013330085/article/details/103873890 ...
Quartz分布式模式与Spring集成、执行定时任务、防止任务并行、在任务中获取Spring管理的Bean
ystyaoshengting的专栏
12-31 814
Spring中使用Quartz 1.配置JobDetail Spring提供了两种配置JobDetail的配置，官方示例如下： 方式一 <!-- JobDetail配置 1 --> <bean name="exampleJob" class="org.springframework.scheduling.quartz.JobDetailFactoryBean"&g...
Quartz实现分布式定时调度，并可作为独立构件集成至项目
huhailang2018的博客
05-11 1888
实现目标：（1）可动态实现调度，包括动态创建、更新、删除、立即执行、暂停、恢复等调度方式；（2）分布式部署，实现负载均衡；         （a）多节点部署，同一时间同一定时任务只会有一个节点执行；         （b）多节点部署，在其中一个节点修改了job的执行时间，则对此job执行时间的修改其他节点同样生效；           (c)  多节点部署，其中某个节点down掉，job会自动切换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值