JAVA定时器quartz的使用

最新推荐文章于 2024-09-09 09:50:40 发布
最新推荐文章于 2024-09-09 09:50:40 发布
阅读量520 收藏 2
点赞数
分类专栏： java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。访问我的个人博客：http://www.zjhuiwan.cn。
本文链接：https://blog.csdn.net/sunon_/article/details/112990234
版权

.在pom.xml中添加maven依赖

<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz</artifactId>
			<version>2.2.1</version>
		</dependency>
		<dependency>
			<groupId>org.quartz-scheduler</groupId>
			<artifactId>quartz-jobs</artifactId>
			<version>2.2.1</version>
		</dependency>

 

startFilter 类 tomcat启动后，定时器开启

public class startFilter extends BaseController implements Filter{

	/**
	 * 初始化
	 */
	public void init(FilterConfig fc) throws ServletException {
		this.startWebsocketInstantMsg();
		this.startWebsocketOnline();
		this.reductionDbBackupQuartzState();
	}



	/**
	 * web容器重启时，所有定时备份状态关闭
	 */
	public void reductionDbBackupQuartzState(){
		try {
			//DbFH.executeUpdateFH("update DB_TIMINGBACKUP set STATUS = '2'");
			QuartzManager.addJob("早上发短信通知报餐", DbNoticQuartzJob.class, "0 0 9 * * ?");//0 10 8
			QuartzManager.addJob("下午统计报餐人数", DbCountQuartzJob.class, "0 10 15 * * ?");//0 10 15
		}catch(Exception e){
		}
	}

}
QuartzManager类
package com.fh.util;

import java.util.Map;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;  
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;  
  
/** 定时任务管理类 
 * @author FH 3 13 59679 0 Q
 * @date 2016-4-9
 */
public class QuartzManager {  
    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory();  //创建一个SchedulerFactory工厂实例
    private static String JOB_GROUP_NAME = "FH_JOBGROUP_NAME";  					//任务组
    private static String TRIGGER_GROUP_NAME = "FH_TRIGGERGROUP_NAME";  			//触发器组
  
    /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  
     * @param jobName 任务名
     * @param cls 任务
     * @param time 时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, Class<? extends Job> cls, String time) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  										//通过SchedulerFactory构建Scheduler对象
            JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();	//用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
        	CronTrigger trigger = (CronTrigger) TriggerBuilder
        			.newTrigger()	 																	//创建一个新的TriggerBuilder来规范一个触发器
    				.withIdentity(jobName, TRIGGER_GROUP_NAME)											//给触发器起一个名字和组名
    				.withSchedule(CronScheduleBuilder.cronSchedule(time))
    				.build();
            sched.scheduleJob(jobDetail, trigger);  
            if (!sched.isShutdown()) {  
                sched.start();  	  // 启动  
            }  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
    
    /**添加一个定时任务，使用默认的任务组名，触发器名，触发器组名  （带参数）
     * @param jobName 任务名
     * @param cls 任务
     * @param time 时间设置，参考quartz说明文档
     */
    public static void addJob(String jobName, Class<? extends Job> cls, String time, Map<String,Object> parameter) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  										//通过SchedulerFactory构建Scheduler对象
            JobDetail jobDetail= JobBuilder.newJob(cls).withIdentity(jobName,JOB_GROUP_NAME).build();	//用于描叙Job实现类及其他的一些静态信息，构建一个作业实例
            jobDetail.getJobDataMap().put("parameterList", parameter);								//传参数
        	CronTrigger trigger = (CronTrigger) TriggerBuilder
        			.newTrigger()	 																	//创建一个新的TriggerBuilder来规范一个触发器
    				.withIdentity(jobName, TRIGGER_GROUP_NAME)											//给触发器起一个名字和组名
    				.withSchedule(CronScheduleBuilder.cronSchedule(time))
    				.build();
            sched.scheduleJob(jobDetail, trigger);  
            if (!sched.isShutdown()) {  
                sched.start();  	  // 启动  
            }  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
  
    /**添加一个定时任务 
     * @param jobName	任务名 
     * @param jobGroupName	任务组名 
     * @param triggerName	触发器名 
     * @param triggerGroupName	触发器组名 
     * @param jobClass	任务 
     * @param time	时间设置，参考quartz说明文档 
     */
    public static void addJob(String jobName, String jobGroupName,  
            String triggerName, String triggerGroupName, Class<? extends Job> jobClass,  
            String time) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
            CronTrigger trigger = (CronTrigger) TriggerBuilder	 // 触发器  
    				.newTrigger()
    				.withIdentity(triggerName, triggerGroupName)
    				.withSchedule(CronScheduleBuilder.cronSchedule(time))
    				.build();
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {  
                sched.start();  	  // 启动  
            } 
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
    
    /**添加一个定时任务  （带参数）
     * @param jobName	任务名 
     * @param jobGroupName	任务组名 
     * @param triggerName	触发器名 
     * @param triggerGroupName	触发器组名 
     * @param jobClass	任务 
     * @param time	时间设置，参考quartz说明文档 
     */
    public static void addJob(String jobName, String jobGroupName,  
            String triggerName, String triggerGroupName, Class<? extends Job> jobClass,  
            String time, Map<String,Object> parameter) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            JobDetail jobDetail= JobBuilder.newJob(jobClass).withIdentity(jobName,jobGroupName).build();// 任务名，任务组，任务执行类
            jobDetail.getJobDataMap().put("parameterList", parameter);								//传参数
            CronTrigger trigger = (CronTrigger) TriggerBuilder	 // 触发器  
    				.newTrigger()
    				.withIdentity(triggerName, triggerGroupName)
    				.withSchedule(CronScheduleBuilder.cronSchedule(time))
    				.build();
            sched.scheduleJob(jobDetail, trigger);
            if (!sched.isShutdown()) {  
                sched.start();  	  // 启动  
            } 
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    } 
  
    /** 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名) 
     * @param jobName	任务名 
     * @param time	新的时间设置
     */
    public static void modifyJobTime(String jobName, String time) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  							//通过SchedulerFactory构建Scheduler对象
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME); 		//通过触发器名和组名获取TriggerKey
            CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);				//通过TriggerKey获取CronTrigger
            if (trigger == null) {  
                return;  
            }  
            String oldTime = trigger.getCronExpression();  
            if (!oldTime.equalsIgnoreCase(time)) {  
            	JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);						//通过任务名和组名获取JobKey
            	JobDetail jobDetail = sched.getJobDetail(jobKey); 
                Class<? extends Job> objJobClass = jobDetail.getJobClass();  
                removeJob(jobName);  
                addJob(jobName, objJobClass, time);  
            }  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
    
    /**修改一个任务的触发时间 
     * @param triggerName	任务名称
     * @param triggerGroupName	传过来的任务名称
     * @param time	更新后的时间规则
     */
    public static void modifyJobTime(String triggerName, String triggerGroupName, String time) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  							//通过SchedulerFactory构建Scheduler对象
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName); 	//通过触发器名和组名获取TriggerKey
            CronTrigger trigger = (CronTrigger)sched.getTrigger(triggerKey);				//通过TriggerKey获取CronTrigger
            if (trigger == null)  return;  
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(trigger.getCronExpression());
            String oldTime = trigger.getCronExpression();  
            if (!oldTime.equalsIgnoreCase(time)) {  
            	trigger = (CronTrigger)trigger.getTriggerBuilder()		//重新构建trigger
            			.withIdentity(triggerKey)
            			.withSchedule(scheduleBuilder)
            			.withSchedule(CronScheduleBuilder.cronSchedule(time))
        				.build();
            	sched.rescheduleJob(triggerKey, trigger);				//按新的trigger重新设置job执行
            }
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
    
    /**移除一个任务(使用默认的任务组名，触发器名，触发器组名) 
     * @param jobName	任务名称
     */
    public static void removeJob(String jobName) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName,TRIGGER_GROUP_NAME); 	//通过触发器名和组名获取TriggerKey
            JobKey jobKey = JobKey.jobKey(jobName, JOB_GROUP_NAME);						//通过任务名和组名获取JobKey
            sched.pauseTrigger(triggerKey);	// 停止触发器  
            sched.unscheduleJob(triggerKey);// 移除触发器  
            sched.deleteJob(jobKey);		// 删除任务  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
    
    /**移除一个任务
     * @param jobName	任务名
     * @param jobGroupName	任务组名
     * @param triggerName	触发器名
     * @param triggerGroupName	触发器组名
     */
    public static void removeJob(String jobName, String jobGroupName,String triggerName, String triggerGroupName) {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            TriggerKey triggerKey = TriggerKey.triggerKey(triggerName,triggerGroupName); 	//通过触发器名和组名获取TriggerKey
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);							//通过任务名和组名获取JobKey
            sched.pauseTrigger(triggerKey);	// 停止触发器  
            sched.unscheduleJob(triggerKey);// 移除触发器  
            sched.deleteJob(jobKey);		// 删除任务  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    } 
    
    /**
     * 启动所有定时任务 
     */
    public static void startJobs() {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            sched.start();  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
  
    /**
     * 关闭所有定时任务 
     */
    public static void shutdownJobs() {  
        try {  
            Scheduler sched = gSchedulerFactory.getScheduler();  
            if (!sched.isShutdown()) {  
                sched.shutdown();  
            }  
        } catch (Exception e) {  
            throw new RuntimeException(e);  
        }  
    }  
}  
DbNoticQuartzJob类
package com.fh.controller.app.task;

import com.alibaba.fastjson.JSONObject;
import com.fh.entity.Page;
import com.fh.service.system.systemUser.SystemUserManager;
import com.fh.service.system.systemUser.impl.SystemUserService;
import com.fh.service.task.SysHolidayManager;
import com.fh.service.task.SystemReportMealManager;
import com.fh.service.task.impl.SysHolidayService;
import com.fh.service.task.impl.SystemTaskService;
import com.fh.util.PageData;
import com.fh.util.SendSms;
import com.fh.util.SpringBootBeanUtil;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;

public class DbNoticQuartzJob implements Job {



    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {

        try {
            SystemUserManager systemUserService =SpringBootBeanUtil.getBean(SystemUserManager.class);
            SysHolidayManager sysHolidayService = SpringBootBeanUtil.getBean(SysHolidayManager.class);
            autoOver(systemUserService,sysHolidayService);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    private void autoOver( SystemUserManager systemUserService, SysHolidayManager sysHolidayService) throws Exception {
        Date now = new Date();
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        PageData pd = new PageData();
        List<PageData> holidayList = sysHolidayService.listAll(pd);
        List<String> dateList = new ArrayList<String>();
        holidayList.stream().forEach(e ->{
            dateList.add(e.getString("thetime"));
        });
        String tDay = sdf.format(addDay(now, 1));
        if(!dateList.contains(tDay)){
            pd.put("isSMSend", "0");
            List<PageData> userList = systemUserService.listAll(pd);
            String phones = "";
            for (int i=0;i<userList.size();i++){
                if(i!=userList.size()-1){
                    phones += userList.get(i).getString("mobile")+",";
                }else{
                    phones += userList.get(i).getString("mobile");
                }
            }

            System.out.println(phones);
            // 发送短信
            JSONObject jsonParam = new JSONObject();
            jsonParam.put("data", sdf.format(now));
            SendSms.sendSms(phones, "SMS_21****018", jsonParam.toString());
           // SendSms.sendSms(phones, "SMS_21****737", jsonParam.toString());
        }

    }

    // 增加或减少天数
    private Date addDay(Date date, int num) {
        Calendar startDT = Calendar.getInstance();
        startDT.setTime(date);
        startDT.add(Calendar.DAY_OF_MONTH, num);
        return startDT.getTime();
    }
}

SpringBootBeanUtil类
package com.fh.util;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringBootBeanUtil implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

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

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name) {
        return applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }
}

 

sunon_
关注
专栏目录
Java——定时任务框架quartz
wang__sepcial的博客
04-28 2127
这里写目录标题1.简介2.使用2.1 定义 Job2.2 定义 JobDetail、Trigger 1.简介 使用 @Scheduled 注解来解决简单的定时任务，大部分项目中可能都是使用 Quartz 来做定时任务。 Quartz是一个开源项目，专注于任务调度器，功能强大，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。 持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。 集群和分布式处理：当在集群
使用quartz.jar 、quartz-jobs.jar 实现定时任务 。实现 定时采集 接口数据
weixin_30502965的博客
11-01 407
前言 　　定时任务管理，在java中有很多种的方式 ，有java自带的注解方式@Scheduled 等 ，现在我要说的是一种也是使用比较广泛的一种quartz管理　　使用此类 需要的加jar包有quartz.jar 、quartz-jobs.jar （我这里用的版本是2.2.1），log4j-1.2.17.jar，slf4j-api-1.7.21.jar，slf4j-log4j12-1....
Quartz Manager 使用教程
最新发布
gitblog_00402的博客
09-09 883
Quartz Manager 使用教程 quartz-managerREST API and UI Console Manager for Quartz Scheduler. This is a Java Library & UI embeddable single page app, to control and monitor jobs scheduled with Quartz Sched...
Java中的定时任务调度：Quartz详解
聚娃科技开发者博客
07-30 1504
本文将深入探讨Quartz的基本概念、配置方法和实际应用示例，帮助你更好地利用Quartz进行定时任务调度。Quartz是一个功能强大的定时任务调度库，通过灵活的配置和编程接口，可以满足各种定时任务的需求。通过本文的示例和配置指南，你可以快速上手使用Quartz进行定时任务调度，实现高效的任务管理和调度。Quartz支持将任务的状态持久化到数据库，以便在应用重启后恢复任务状态。Quartz是一个开源的任务调度库，它允许开发者通过配置或编程方式定义、调度和管理任务。，以便Quartz能够连接到数据库。
java 定时任务quartz的使用
lai124793549的专栏
11-11 558
1.maven <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> <dependency> <groupId>org.quartz-schedule...
java 定时器 quartz_Java定时器和Quartz使用
weixin_35900668的博客
02-15 371
一、Java普通自定义定时器1 /**2 * 自定义一个定时器3 *@authorlw4 */5 public class MyTimer extendsThread{67 privateLong time ;89 publicMyTimer(Long time) {10 this.time =time;11 }1213 @Override14 publ...
Java定时器 quartz jar包
11-02
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成...
JAVA定时器Quartz及使用说明
05-23
内含：<br>quartz-1.5.2.zip<br>定时器Quartz及使用说明<br>Quartz的API
Spring中的Quartz配置-Spring-定时器-java定时器.doc
06-27
Spring 中的 Quartz 配置-Spring 定时器-java 定时器 在 Spring 框架中，Quartz 是一个非常流行的开源作业调度器，可以实现任务的定时执行。在本篇文章中，我们将讨论如何在 Spring 中配置 Quartz，以实现 Java ...
java Quartz定时器任务与Spring task定时的几种实现方法
08-31
在Java开发中，定时任务的实现有多种方式，其中Java Quartz和Spring Task是常用的两种解决方案。本文将详细介绍这两种定时任务的实现方法，并对比它们的特点。 首先，我们来看Java自带的`java.util.Timer`类。虽然...
java 定时器 quartz的使用
chao331303的专栏
09-02 866
spring 3.0.5  quartz 1.8    刚开始用的2
Java-Quartz定时器
weixin_45203607的博客
09-27 3629
Java-Quartz定时器 Quartz定时器介绍 Quartz是什么 简单来说就是一个任务调度框架，帮我们自动去执行这些程序。 大部分公司都会用到定时任务这个功能。 比如订单支付来说，超过一定时间会执行这个job，去判断你是否支付，未支付就会取消此次订单 Quartz能干什么 1: 下载交易流水 比如银行每天会自动下载流水 2: 修改密码提醒和告警 出于安全考虑，长时间没有修改密码会发出警告 3: 会员续费 会员到期了，TX提醒你进行充值 4: 短信通知 每隔一段时间向指定用户发送短信 5:垃圾清理 比
Java定时任务之Quartz
立志成为一个前端、后端、测试全方位发展的程序员
03-14 568
Quartz 文章目录Quartz1. Quartz是什么2. HelloWorld程序3. 使用JobDetail3.1 JobDetail介绍3.2 JobDetail属性4. 使用Trigger5. 使用SimpleTrigger6. 使用CronTrigger6.1 CronTrigger介绍6.2 Cron表达式示例6.3 Cron表达式案例7. 使用Scheduler7.1 Scheduler工厂模式7.2 Scheduler主要函数8. quartz.properties配置文件的使用8.1
java定时器的使用（java+Quartz实现定时任务）
qq_21305943的专栏
10-25 480
使用到的jar包是 quartz-2.2.1.jar public class Timer{ private static Timer instance; parivate Scheduler schedule; public static Timer getInstance(){//单例方式获取 } private Timer(){ try{ SchedulerFactory s...
Java实现定时器（Quartz任务调度）--简易版
AsFarmer的博客
07-26 322
Quartz实现任务调度
java quartz 定时器_JAVA 定时器 Quartz 的使用
weixin_42421331的博客
02-24 140
/* * All content copyright Terracotta, Inc., unless otherwise indicated. All rights reserved. * * Licensed under the Apache License, Version 2.0 (the "License"); you may not * use this file except in ...
java定时器quartz无故停止
m0_57066201的博客
06-19 967
最近几天，有的人在偷偷地买蚂蚁的基金，有的人却偷偷的在蚂蚁面试。 最近确实是面试的好时候。大家都奔着大厂去的，最近也分享了好多大厂的面经了，什么阿里、字节、京东、美团、百度、腾讯、滴滴、网易…已经数不清有多少了。（是我菜了） 这里分享一下蚂蚁金服5面过程与面试总结 结构化数据、非结构化数据与半结构化数据 文章的开始，聊一下结构化数据、非结构化数据与半结构化数据，因为数据特点的不同，将在技术上直接影响存储引擎的选型。 首先是结构化数据，根据定义结构化数据指的是由二维表结构来逻辑表达和实现的数据，严格.
java 定时器quartz使用
LLG
06-20 955
定时器使用场景（固定时间程序自动执行部分功能）。 使用步骤 一：配置初始化bean 二：代码实现 1、QuartzTest,.java package com.sinotrans.visualizationplatform.test; import java.text.SimpleDateFormat; import java.util.Date; public class Qu
java实现quartz定时器_java定时器quartz实现解析
weixin_29817227的博客
03-08 1543
上次我们了解过了timer的有关内容，这次来了解下另外一个定时器quartz的实现，快来看看吧。1、首先，在pom.xml中进行最重要也是基础的导包环节org.quartz-schedulerquartz2.2.1<dependency>org.quartz-scheduler<artifactId>quartz-jobs<version>...
Java定时器Timer和第三方定时器Quartz
weixin_40017062的博客
01-05 2015
概述 定时器在应用广泛，比如定时统计数据生成报表、每隔设定的时间提醒用户等。Java.util包自带的定时器Timer提供简单的定点执行功能，而Quartz是一个第三方提供的定时器框架。 对比 Timer 优点： java.util包自带的，Timer的任务是通过创建TimerTask子类进行实现，使用方便。 缺点： 定时器没有持久性机制。 定时器不能灵活的调度（只能设置开始时间和重复间隔，没有基于日期，一天中的时间等） 定时器不使用线程池（每个定时器一个线程） 定时器没有真正的管理方案，必须编
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值