任务调度框架（3）Quartz 简单使用

最新推荐文章于 2024-05-29 20:05:54 发布
最新推荐文章于 2024-05-29 20:05:54 发布
阅读量2.2k 收藏 5
点赞数 2
分类专栏： 调度框架 文章标签： Quartz JobFactory QuartzJobBean  spring JobExecutionException
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012228718/article/details/87179590
版权

文章目录

简介与概述

组件概述

  1. Job：一个任务，可以包括有状态与无状态。
  • 有状态是指 StatefulJob，不能并发的执行，需要使用注释@DisallowConcurrentExecution。
  • 而无状态的Job可以并发的执行。
  • 如每2分钟执行一个任务，某种情况下这个任务执行了3分钟，这样在上一个任务还在执行状态时，下一次触发时间已经到了。无状态的Job，只要触发一到就会立即执行两个任务并发运行，而有状态的Job不能并发执行。
  1. JobDetail：Job实例所包含的属性。JobDataMap 可以作为Job实例执行时使用的数据对象。
  2. Triggers：触发器。最常用的有 SimpleTrigger 和 CronTrigger。
  • 优先级（priority）
  • 错过触发（misfire Instructions）
  • 日历示例（calendar）
  • 监听器（TriggerListeners）
  1. Scheduler：任务执行器。可以通过 SchedulerFactory 创建，主要是StdSchedulerFactory，其使用一组属性Properties来创建和初始化 Quartz Scheduler。
  2. Job Stores：负责跟踪提供给调度程序的所有工作数据如 jobs，triggers，日历等。主要有RAMJobStore、JDBC JobStore
  3. SchedulerPlugin：Quartz提供了一个用于插入附加功能的接口插件。
  4. JobFactory：当trigger触发时，通过Scheduler上配置的JobFactory实例化与之关联的jobs。

API 概述

  1. 创建JOb
  • JobKey 一个Job任务的唯一Key
  • JobDetail 代表一个 JOb 的封装
  • storeDurably Durability 属性，如果一个job是非持久的，当没有活跃的trigger与之关联的时候，会被自动地从scheduler中删除
  • requestRecovery 如果一个job是可恢复的，并且在其执行的时候，scheduler发生硬关闭（hard shutdown)，则当scheduler重新启动的时候，该job会被重新执行。这种情况下，JobExecutionContext.isRecovering() 方法将会返回 true
JobKey jobKey = JobKey.jobKey("", "");
JobDetail jobDetail = JobBuilder.newJob(SimpleJob.class)
        .withIdentity(jobKey)
        .usingJobData("key", "value")
        .storeDurably() 
        .requestRecovery() 
        .build();

jobDetail.getJobDataMap().put("key2", "value2");
  1. 创建触发器
  • SimpleScheduleBuilder 创建 SimpleTrigger
  • CronScheduleBuilder 创建 CronTrigger
  • MISFIRE_INSTRUCTION Misfire 机制，默认是 CronTrigger.MISFIRE_INSTRUCTION_SMART_POLICY;
# 创建 SimpleTrigger
TriggerKey triggerKey = TriggerKey.triggerKey("", "");
SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder
        .simpleSchedule()
        .withIntervalInSeconds(2)
        .withRepeatCount(100)
        .withMisfireHandlingInstructionFireNow();

SimpleTrigger trigger = TriggerBuilder.newTrigger()
        .withIdentity(triggerKey)
        .startNow()
        .withSchedule(scheduleBuilder)
        .modifiedByCalendar("") // Calendar用于从trigger的调度计划中排除时间段。处理一些节假日排除
        .withPriority(Trigger.DEFAULT_PRIORITY) // 优先级
        .build();

# 创建 CronTrigger
TriggerKey triggerKey = TriggerKey.triggerKey("CronTrigger", "CronTrigger_group");
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("*/10 * * * * * ?");

// // Misfire 机制，默认是 CronTrigger.MISFIRE_INSTRUCTION_SMART_POLICY;
cronScheduleBuilder.withMisfireHandlingInstructionFireAndProceed();

CronTrigger cronTrigger = TriggerBuilder.newTrigger()
        .withIdentity(triggerKey)
        .startNow()
        .withSchedule(cronScheduleBuilder)
        .build();
  1. 创建任务调度器
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
((StdSchedulerFactory) schedulerFactory).initialize(quartzProperties());// 初始化参数

Scheduler scheduler = schedulerFactory.getScheduler();
scheduler.scheduleJob(jobDetail, cronTrigger);

常用配置概述

配置名称备注
org.quartz.scheduler.instanceName本身没有意义，而是作为客户端代码在同一程序中使用多个实例时区分调度程序的机制。可以自定义为任务字符串
org.quartz.scheduler.instanceId唯一的。如果希望为您生成Id，则可以使用值"AUTO"。
org.quartz.threadPool.class是要使用的 ThreadPool 的类名。Quartz 附带的线程池是 org.quartz.simpl.SimpleThreadPool，spring 可以使用 SimpleThreadPoolTaskExecutor。这只是一个简单的实现，需要使用 threadCount 确定体局的值
org.quartz.threadPool.threadCount线程池大小
org.quartz.threadPool.threadPriority优先级
org.quartz.jobStore.classJobStore 配置。一般基于内存的org.quartz.simpl.RAMJobStore和基于JDBC的org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass配合org.quartz.jobStore.class 的JDBCStore使用，org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.tablePrefix表前缀，jsbcstore使用 如QRTZ_
org.quartz.jobStore.isClustered集群使用设置为 true
org.quartz.jobStore.clusterCheckinInterval集群检查，如 20000
org.quartz.jobStore.dataSource数据库的 dataSource 名称，随便取名，但是在配置数据库时需要一致：如 org.quartz.dataSource.myDS.driver
org.quartz.plugin.triggHistory.class插件配置，org.quartz.plugins.history.LoggingJobHistoryPlugin

集成 Spring

Quartz 集成Spring 依赖spring context 与 context-support 模块，需要引入 Quartz 依赖：

<!--Quartz-->
<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>

Xml 配置实现

  1. 定义任务
  • Job：任务接口
public class MyJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("MyJob");
    }
}
  1. 配置任务
  • JobDetailFactoryBean实现，任务必须实现Job 接口。可以实现 spring 实现的 QuartzJobBean
  • MethodInvokingJobDetailFactoryBean 实现，可以指定任意类的任意方法
# JobDetailFactoryBean 实现，MyJob必须实现 Job 接口或者继承 QuartzJobBean 类
<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
    <property name="jobClass" value="com.learning.job.schedule.quartz.spring.xml.MyJob"/>
    <property name="jobDataAsMap">
        <map>
            <entry key="name" value="Quartz"/>
        </map>
    </property>
</bean>

# MethodInvokingJobDetailFactoryBean 实现，可以指定任意类的任意方法
<bean id="myMethodJob" class="com.learning.job.schedule.quartz.spring.xml.MyMethodJob"/>
<bean id="jobDetail2" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <property name="group" value="job_work"/>
    <property name="name" value="job_work_name"/>
    <!--false 表示等上一个任务执行完后再开启新的任务-->
    <property name="concurrent" value="false"/>
    <property name="targetObject" ref="myMethodJob"/>
    <property name="targetMethod" ref="execute"/>
</bean>
  1. 配置触发器
  • CronTriggerFactoryBean cronTrigger 调度触发器配置
  • SimpleTriggerFactoryBean simpleTrigger 简单触发器配置
  • jobDetail 属性指定Job 任务
# cronTrigger 调度触发器
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
    <property name="name" value="work_default_name"/>
    <property name="group" value="work_default"/>
    <property name="jobDetail" ref="jobDetail"/>
    <property name="cronExpression" value="0/5 * * * * ?"/>
</bean>

# simpleTrigger 简单触发器
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
    <property name="name" value="work_default_name"/>
    <property name="group" value="work_default"/>
    <property name="jobDetail" ref="jobDetail2"/>
    <property name="repeatInterval" value="1000"/>
    <property name="repeatCount" value="200"/>
</bean>
  1. 配置调度工厂 SchedulerFactoryBean
  • configLocation 指定配置文件地址
  • triggers 指定触发器
  • autoStartup 是否自动启动
  • startupDelay 延迟启动，建议是true，这样调度器会在应用启动后在启动。
<bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="autoStartup" value="false"/>
    <property name="triggers">
        <list>
            <ref bean="simpleTrigger"/>
            <ref bean="cronTrigger"/>
        </list>
    </property>
    <property name="configLocation" value="classpath*:"
    <property name="startupDelay" value="20"/>
</bean>

JavaConfig 实现

  1. 定义任务
  • QuartzJobBean Spring 实现的Job父类
@Component
public class MyBootJob extends QuartzJobBean {
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        System.out.println("~~ MyBootJob ~~");
    }
}

@Component
public class MyBootMethodJob {
    public void exe() {
        System.out.println("~~ MyBootMethodJob ~~");
    }
}
  1. 配置任务
  • @EnableScheduling 启动定时任务
  • JobDetailFactoryBean 配置任务
@Bean
public JobDetailFactoryBean jobDetailFactoryBean(MyBootJob job) {
    JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
    factoryBean.setJobClass(job.getClass());
    factoryBean.setRequestsRecovery(true);
    factoryBean.setDurability(true);
    // 额外参数
    factoryBean.setJobDataAsMap(new HashMap<>());
    return factoryBean;
}

@Bean
public MethodInvokingJobDetailFactoryBean myFirstExerciseJobBean(MyBootMethodJob job) {
    MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
    jobDetail.setConcurrent(false); // 是否并发
    jobDetail.setName("general-myFirstExerciseJob"); // 任务的名字
    jobDetail.setGroup("general"); // 任务的分组
    jobDetail.setTargetObject(job); // 被执行的对象
    jobDetail.setTargetMethod("exe"); // 被执行的方法
    return jobDetail;
}
  1. 配置触发器
@Bean
public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean) {
    SimpleTriggerFactoryBean tigger = new SimpleTriggerFactoryBean();
    tigger.setJobDetail(jobDetailFactoryBean.getObject());
    tigger.setRepeatInterval(1000L);
    tigger.setRepeatCount(5);
    return tigger;
}

@Bean
public CronTriggerFactoryBean cronTriggerFactoryBean(MethodInvokingJobDetailFactoryBean myFirstExerciseJobBean) {
    CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
    tigger.setJobDetail(myFirstExerciseJobBean.getObject());
    tigger.setCronExpression("0/10 * * * * ?");
    return tigger;
}
  1. 配置调度工厂
@Bean
public SchedulerFactoryBean schedulerFactory(SimpleTriggerFactoryBean simpleTriggerFactoryBean,
                                             CronTriggerFactoryBean cronTriggerFactoryBean) {
    SchedulerFactoryBean bean = new SchedulerFactoryBean();
    // 覆盖已存在的任务，用于集群配置
    bean.setOverwriteExistingJobs(true);
    // 延时启动定时任务，避免系统未完全启动却开始执行定时任务的情况
    bean.setStartupDelay(15);
    // 注册触发器
    bean.setTriggers(simpleTriggerFactoryBean.getObject(), cronTriggerFactoryBean.getObject());
    return bean;
}

集成Spring Boot

  1. Spring Boot 2.X以后有默认的配置项类 QuartzProperties、QuartzAutoConfiguration，简单配置了一些属性，主要是调度工厂的配置。可以使用这些配置，替换 SchedulerFactoryBean的配置。
spring:
  quartz:
    job-store-type: jdbc
    auto-startup: true
    startup-delay: 20s
    wait-for-jobs-to-complete-on-shutdown: true
  1. 源码 QuartzAutoConfiguration 中默认配置了 SchedulerFactoryBean 对象，源码如下：
@Bean
@ConditionalOnMissingBean
public SchedulerFactoryBean quartzScheduler() {
	SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
	SpringBeanJobFactory jobFactory = new SpringBeanJobFactory();
	jobFactory.setApplicationContext(this.applicationContext);
	schedulerFactoryBean.setJobFactory(jobFactory);
	if (this.properties.getSchedulerName() != null) {
		schedulerFactoryBean.setSchedulerName(this.properties.getSchedulerName());
	}
	schedulerFactoryBean.setAutoStartup(this.properties.isAutoStartup());
	schedulerFactoryBean
			.setStartupDelay((int) this.properties.getStartupDelay().getSeconds());
	schedulerFactoryBean.setWaitForJobsToCompleteOnShutdown(
			this.properties.isWaitForJobsToCompleteOnShutdown());
	schedulerFactoryBean
			.setOverwriteExistingJobs(this.properties.isOverwriteExistingJobs());
	if (!this.properties.getProperties().isEmpty()) {
		schedulerFactoryBean
				.setQuartzProperties(asProperties(this.properties.getProperties()));
	}
	if (this.jobDetails != null && this.jobDetails.length > 0) {
		schedulerFactoryBean.setJobDetails(this.jobDetails);
	}
	if (this.calendars != null && !this.calendars.isEmpty()) {
		schedulerFactoryBean.setCalendars(this.calendars);
	}
	if (this.triggers != null && this.triggers.length > 0) {
		schedulerFactoryBean.setTriggers(this.triggers);
	}
	customize(schedulerFactoryBean);
	return schedulerFactoryBean;
}

使用经验

  1. 手动设置线程池的大小。在Quartz中默认的线程池实现SimpleThreadPool，需要通过org.quartz.threadPool.threadCount 属性指定线程池初始化时的大小，设定后不能修改。

  2. 与 spring 集成时，如果使用 JdbcStore，那么Job任务需要实现Job配置需要使用JobDetailFactoryBean，不能使用MethodInvokingJobDetailFactoryBean，同时建议任务继承 QuartzJobBean。

  3. 在Job 中想通过依赖注入获取 Bean 实例，需要重写 JobFactory。并且通过 SchedulerFactoryBean 指定。其实Spring有实现，如 SpringBeanJobFactory、AutowireCapableBeanJobFactory。参考 spring boot 实现自动配置的 SchedulerFactoryBean（2.x 版本）

  4. 定时任务错过执行的原因

  • 系统重启，在重启的时间内，与偶可能任务被 misfired
  • 在 Trigger 在暂停的一段时间内（suspend），有些任务被 misfired
  • 线程池中所有线程都被占用，导致任务无法执行，造成 misfired
  • 有状态的任务在下次触发到达时，上次还没有结束
  1. misfired 处理方法：Quartz 为 Trigger 定义了处理策略，主要有两种，建议可以在应用中，让用户选择
  • CronTrigger#MISFIRE_INSTRUCTION_FIRE_ONCE_NOW：针对 misfired 的任务马上执行一次
  • CronTrigger#MISFIRE_INSTRUCTION_DO_NOTHING：忽略 misfired 的任务，等待下次触发
  1. 继承 QuartzJobBean或者Job的任务是没有状态的，支持并发的运行。集成Spring的任务默认是没有状态的，可以使用配置或者注解设置成有状态的任务
  • 配置：<property name="concurrent" value="false" /> 禁止并发
  • 注解：添加到 Job 类
    • @DisallowConcurrentExecution：注意这个注解的约束是基于 JobDetail 的而不是基于 Job 的。如同一个Job类，配置了不同的JobDetail，无效。
    • @PersistJobDataAfterExecution：表示 Quartz 将会在成功执行 execute() 方法后（没有抛出异常）更新 JobDetail 的 JobDataMap，下一次执行相同的任务（JobDetail）将会得到更新后的值，而不是原始的值。就像@DisallowConcurrentExecution 一样，这个注释基于 JobDetail 而不是 Job 类的实例
    • 如果使用了 @PersistJobDataAfterExecution 注释，那么强烈建议使用 @DisallowConcurrentExecution 注释，这是为了避免出现并发问题，当多个 Job 实例同时执行的时候，到底使用了哪个数据将变得很混乱。StatefulJob 就标注了这两个注解
  1. JobExecutionException
    任务的执行方法，默认是Job.execute(…)方法（继承 QuartzJobBean 类后是 executeInternal() 方法）。这个方法只允许抛出一种异常是JobExecutionException。需要花点时间看看 JobExecutionException 的文档，可以使用该异常它提供的各种指令来控制如何处理异常，如立即执行或者任务终止。
  • JobExecutionException.setRefireImmediately(true) 立即执行（ this job will refire immediately）
  • JobExecutionException.setUnscheduleAllTriggers(true) 立即停止所有相关这个任务的触发器，表示 Quartz 会自动取消所有与这个 job 有关的 trigger，从而避免再次运行 job

参考

  1. 源码地址 Learning_Job_Schedule
  2. w3cschool 教程
  3. 与Web 应用结合，实现任务的动态管理
Sam Sho
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot官方支持任务调度框架，轻量级用起来也挺香！
m0_67698950的博客
06-08 403
定时任务的应用场景其实蛮常见的，比如说：编程喵🐱实战项目里需要做一个定时发布文章的功能，一开始我想用 Spring Task，于是研究了一番，发现 Spring Task 用起来确实简单，但对于复杂业务却也无能为力。于是我就把注意力放到了 Quartz 上面，这是一款老而弥坚的开源任务调度框架。记得我在 14 年开发大宗期货交易平台的时候就用到了它，每天凌晨定时需要统计一波交易数据，生成日报报表，当时配合 Cron 表达式用的。可惜后来平台稳定了，新的政策出来了，直接把大宗期货交易灭了。于是我发财的机会也.
Quartz任务调度框架简介
01-30
Quartz是一个开源的作业调度框架，它用于在Java应用程序中实现复杂的定时任务。Quartz的主要功能是安排作业（Job）在特定的时间点执行，这些作业可以是任何实现了Quartz接口的任务，比如数据处理、文件传输、邮件...
使用 SpringBoot2.X 实现 Quartz 动态任务的分布式调度
MarkerHub的博客
04-25 973
小Hub领读：常见的分布式定时任务框架：elastic-job、xxl-job、quartz ，你都熟悉吗，今天先来学一下Quartz吧！作者：Sam Shohttps://blog.c...
XXL-JOB分布式任务调度框架详解（全网最详细！！！）
最新发布
可乐要加冰！！！
05-29 2590
1.1 起源与发展XXL-JOB起源于大众点评内部的分布式任务调度需求，自2016年起开始接入线上产品线，至今已迭代数十个版本，广泛应用于互联网、金融、教育、物流等多个行业。其核心设计目标是“开发迅速、学习简单、轻量级、易扩展”，并且提供开箱即用的体验。1.2 核心设计理念XXL-JOB调度中心和执行器。调度中心负责任务的调度策略、触发时机及调度请求的发起，而执行器则负责接收调度请求并执行具体的任务逻辑。
Spring框架之任务调度
A_diligent_man的博客
08-04 200
【代码】Spring框架之任务调度。
SpringTask——任务调度框架
zyxzyx666的博客
01-20 1340
​ Spring Task是Spring框架提供的任务调度工具，可以按照约定的时间自动执行某个代码逻辑。
CRON表达式 含义
mohancoco的博客
08-01 305
CRON表达式 含义 秒 分 时 日 月 星期几 年 “0 0 12 * * ?” 每天中午十二点触发 “0 15 10 ? * *” 每天早上10：15触发 “0 15 10 * * ?” 每天早上10：15触发 “0 15 10 * * ? *” 每天早上10：15触发 “0 15 10 * * ? 2005” 2005年的每天早上10：15触发 “0 * 14 * * ?” 每天从下午2点开始到2点59分每分钟一次触发 “0 0/5 14 * * ?” 每天从下午2点开始到2：55分结束每5分钟一次触
Java任务调度框架Quartz教程实例
04-08
### Java任务调度框架Quartz教程实例 #### 一、Quartz框架简介 Quartz是一个功能齐全、开源的任务调度服务框架，它可以被集成到几乎所有类型的Java应用程序中，无论是小型的独立应用还是大型的企业级系统，甚至是...
Spring整合任务调度框架Quartz
01-18
Spring 整合任务调度框架 Quartz ...Spring 整合任务调度框架 Quartz，可以使用配置文件方式或 Quartz 持久化方式来实现任务调度。开发者可以根据实际情况选择合适的方式，从而提高软件系统的自动化和可靠性。
任务调度开源框架Quartz动态添加、修改和删除定时任务
07-07
Quartz 是个开源的作业调度框架，为在 Java 应用程序中进行作业调度提供了简单却强大的机制。Quartz框架包含了调度器监听、作业和触发器监听。你可以配置作业和触发器监听为全局监听或者是特定于作业和触发器的监听...
spring分布式任务调度
08-19
基于xxl-job改造，支持1.6jdk。改分布式任务调度特性如下： 1、简单：支持通过Web页面对任务进行CRUD操作，操作简单，一分钟上手； 2、动态：支持动态修改任务状态、暂停/恢复任务，以及终止运行中任务，即时生效； 3、调度中心HA（中心式）：调度采用中心式设计，“调度中心”基于集群Quartz实现，可保证调度中心HA； 4、执行器HA（分布式）：任务分布式执行，任务"执行器"支持集群部署，可保证任务执行HA； 5、任务Failover：执行器集群部署时，任务路由策略选择"故障转移"情况下调度失败时将会平滑切换执行器进行Failover； 6、一致性：“调度中心”通过DB锁保证集群分布式调度的一致性, 一次任务调度只会触发一次执行； 7、自定义任务参数：支持在线配置调度任务入参，即时生效； 8、调度线程池：调度系统多线程触发调度运行，确保调度精确执行，不被堵塞； 9、弹性扩容缩容：一旦有新执行器机器上线或者下线，下次调度时将会重新分配任务； 10、邮件报警：任务失败时支持邮件报警，支持配置多邮件地址群发报警邮件； 11、状态监控：支持实时监控任务进度； 12、Rolling执行日志：支持在线查看调度结果，并且支持以Rolling方式实时查看执行器输出的完整的执行日志； 13、GLUE：提供Web IDE，支持在线开发任务逻辑代码，动态发布，实时编译生效，省略部署上线的过程。支持30个版本的历史版本回溯。 14、数据加密：调度中心和执行器之间的通讯进行数据加密，提升调度信息安全性； 15、任务依赖：支持配置子任务依赖，当父任务执行结束且执行成功后将会主动触发一次子任务的执行, 多个子任务用逗号分隔；
详解.NET Core使用Quartz执行调度任务进阶
10-17
Quartz.Net是一个功能丰富的开源任务调度框架，适用于多种.NET环境，包括.NET Core。本文将深入探讨如何在.NET Core 2.2及以上版本中利用Quartz进行高级任务调度。 一、Quartz.Net简介 Quartz.Net提供了强大的定时...
SpringBoot官方支持任务调度框架，轻量级用起来也挺香
m0_67505824的博客
03-21 2814
之前我们讲过一个分布式任务调度框架PowerJob，可以通过可视化的方式来进行任务调度。但是有时候我们只是需要一个轻量级的任务调度功能，而PowerJob需要搭建调度中心未免有些重，这时候SpringBoot官方支持的任务调度框架Quartz就派上用场了！本文主要介绍Quartz在SpringBoot中的使用，让你在实现任务调度上有更多的选择！ Quartz简介 Quartz是一款功能强大的开源任务调度框架，几乎可以集成到任何Java应用程序中（小到单机应用，大到分布式应用）。Quartz可用于创建.
SpringBoot官方支持的任务调度框架Quartz入门与实战
QT2016
02-16 1109
一、简介 Quartz是一款功能强大的开源任务调度框架，几乎可以集成到任何Java应用程序中（小到单机应用，大到分布式应用）。Quartz可用于创建简单或复杂的任务调度，用以执行数以万计的任务，并且支持任务持久化。任务被定义为标准化的Java组件，Java编写的任务都可以被执行。 二、核心概念 Scheduler（调度器）：Quartz中的任务调度器，通过Trigger和JobDetail可以用来调度、暂停和删除任务。 Trigger（触发器）：Quartz中的触发器，可以通过CRON表达式来指定任务执行
定时任务框架 (springTask任务调度) 快速入门
weixin_42960873的博客
06-19 257
什么是任务调度 在设定好的时间自动执行指定好的任务，springTask就可以帮助我们完成这个功能 怎么实现任务调度 在类上加上@EnableScheduling 注解, 在需要自动执行的方法上加上@Scheduled这个注解, 并用cron时间表达式设置调用时间 就可以了 @EnableScheduling 注解的作用是发现注解@Scheduled的任务并后台执行。 @Scheduled用于标注这个方法是一个定时任务的方法 cron时间表达式是一个字符串，字符串分6个域: 秒 分 时 日 月 周 cr
Spring实现任务调度的基本配置
qq_49194786的博客
10-14 374
Spring集成Quartz实现任务调度
SpringCloud-搭建XXL-JOB任务调度平台教程
踏雨歌青春，诗酒趁年华
04-21 9159
本教程提供了从XXL-JOB平台介绍到具体搭建流程的详细说明，旨在帮助开发者和系统管理员快速理解和部署XXL-JOB任务调度平台。通过Spring Cloud集成XXL-JOB任务调度平台，可以使微服务环境中的任务调度更加灵活和高效。整个过程中，调度中心和执行器的正确配置是关键。此外，通过XXL-JOB提供的控制台，用户可以轻松管理和监控任务的运行状态，实现任务的高效执行。
Spring源码：调度框架EnableScheduling&Scheduled源码解析
博客园
06-26 901
在实际项目开发中，有时会遇到定时调度的开发需要，这部分的功能在Spring框架中给出了较好的支持，即@EnableScheduling&Scheduled定时调度框架，本着不仅知其然还要知其所以然的指导思想，下面对该调度框架进行源码解析，以便更好的理解其执行过程；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值