SpringBoot整合Quartz定时框架

概述

  • Quartz:是一个开放源代码任务调度框架。Quartz功能强大,可以让你的程序在指定时间执行,也可以按照某一个频度执行,支持数据库、监听器、插件、集群等特性。
  • 使用场景:定时消息推送、定时抢购、定时发送邮件、定时统计等。

体系架构

  • Job
    是一个接口,只定义一个方法execute(JobEexcutionContext context),在实现接口的execute方法中编写所需要定时执行的Job任务,JobEexcutionContext 类提供了调度应用的一些信息。Job运行时的信息保存在JobDataMap实例中。
  • JobDetail
    JobDetail定义的是任务数据,而真正的执行逻辑是在Job中。sheduler每次执行,都会根据JobDetail创建一个新的Job实例
  • Trigger
    是一个类,描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当且仅当需要调度一次或者以固定时间间隔周期执行调度,SimpleTrigger是最适合简单任务的选择;而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案:如工作日周一到周五的15:00~16:00执行调度等。

Cron表达式

  • 表达式的格式:秒 分 时 日 月 周 年(可选)。
字段名允许的值允许的特殊字符
0-59, – * /
0-59, – * /
0-23, – * /
1-31, – * / L W C
1-12 or JAN-DEC, – * /
1-7 or SUN-SAT, – * ? / L C # MON FRI
年(可选字段)empty, 1970-2099, – * /
允许的特殊字符:
  1. * 字符代表:代表所有可能的值。因此,“*”在Month中表示每个月,在Day-of-Month中表示每天,在Hours表示每小时
  2. “,”字符:指定数个值。例如:在Minutes子表达式中,“5,20”表示在5分钟和20分钟触发。
  3. “-”字符:指定一个值的范围
  4. “/”字符:指定一个值的增加幅度。n/m表示从n开始,每次增加m。例如:在Minutes子表达式中,“0/15”表示从0分钟开始,每15分钟执行一次。“3/20"表示从第三分钟开始,每20分钟执行一次。和"3,23,43”(表示第3,23,43分钟触发)的含义一样。
  5. “L”字符:用在日表示一个月中的最后一天,用在周表示该月最后一个星期X
  6. “W”字符:指定离给定日期最近的工作日(周一到周五)
  7. “#”字符:表示该月第几个周X。6#3表示该月第3个周五
  8. ? 字符:用在Day-of-Month和Day-of-Week中,指“没有具体的值”。当两个子表达式其中一个被指定了值以后,为了避免冲突,需要将另外一个的值设为“?”。例如:想在每月20日触发调度,不管20号是星期几,只能用如下写法:0 0 0 20 * ?,其中最后以为只能用“?”,而不能用“*”。
  9. C:该字符只在日期和星期字段中使用,代表“Calendar”的意思。它的意思是计划所关联的日期,如果日期没有被关联,则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。

Cron表达式对特殊字符的大小写不敏感,对代表星期的缩写英文大小写也不敏感。

Cron表达式范例例:
1. 每隔5秒执行一次:*/5 * * * * ?
2. 每隔1分钟执行一次:0 */1 * * * ?
3. 每天23点执行一次:0 0 23 * * ?
4. 每天凌晨1点执行一次:0 0 1 * * ?
5. 每月1号凌晨1点执行一次:0 0 1 1 * ?
6. 每月最后一天23点执行一次:0 0 23 L * ?
7. 每周星期天凌晨1点执行一次:0 0 1 ? * L
8. 在26分、29分、33分执行一次:0 26,29,33 * * * ?
9. 每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?
  • Scheduler 代表一个Quartz的独立运行容器, Trigger和JobDetail可以注册到Scheduler中, 两者在 Scheduler中拥有各自的组及名称, 组及名称是Scheduler查找定位容器中某一对象的依据, Trigger的组及名称必须唯一, JobDetail的组和名称也必须唯一(但可以和Trigger的组和名称相 同,因为它们是不同类型的)。Scheduler定义了了多个接口方法, 允许外部通过组及名称访问和 控制容器中Trigger和JobDetail。
  • JobBulider 用于定义/构建已经定义了了Job实例的JobDetail实例。
  • TriggerBuilder 用于定义/构建Trigger实例例。

代码示例

  • 添加依赖
		<!-- Quartz坐标 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 添加Scheduled坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <!-- Sprng tx 坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
  • 定时任务框架/自定义任务类、实现Job
public class MyQuartz implements Job {
    @Override
    public void execute(JobExecutionContext jobExeutionContext) throws JobExecutionException {
        LocalDateTime time = LocalDateTime.now();
        System.out.println("执行任务。。。。。。" + time);
    }
}
  • 编写Quartz的启动类。关联自定义任务类、编写执行规则
@Configuration
public class QuartzConfig {

    /**
     * 创建 Job 对象
     *
     * @return 任务细节工厂
     */
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        // 关联自定义的 Job 类
        factory.setJobClass(MyQuartz.class);
        return factory;
    }

    /**
     * 创建Scheduler对象
     * 这里我们根据自己的需求可以选择使用 SimpleTriggerFactoryBean对象或者 CronTriggerFactoryBean对象作为参数
     * @return 程序调度工厂
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        // 关联 Trigger
        schedulerFactoryBean.setTriggers(cronTriggerFactoryBean.getObject());
        return schedulerFactoryBean;
    }

    /**
     * 创建 Trigger 对象
     * 和cronTriggerFactoryBean()方法类似、基于简单的时间调度规则
     * @param jobDetailFactoryBean
     * @return 基于调度间隔时间
     */
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean) {
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
        // 关联JobDetail对象
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        // 定义执行规则 (该参数表示一个执行的毫秒数)
        factoryBean.setRepeatInterval(2000);
        // 重复次数 默认无限重复
        factoryBean.setRepeatCount(-1);
        return factoryBean;
    }

    /**
     * 创建 Trigger 对象
     * 和simpleTriggerFactoryBean()方法类似、基于Cron表达式、可以满足复杂的时间调度规则
     * @param jobDetailFactoryBean
     * @return 基于时间刻度(可以设置具体时间)
     */
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean) {
        CronTriggerFactoryBean cron = new CronTriggerFactoryBean();
        // 关联JobDetail对象
        cron.setJobDetail(jobDetailFactoryBean.getObject());
        // 指定Cron表达式
        cron.setCronExpression("*/1 * * * * ?");
        return cron;
    }
}
  • 修改启动类:加上@EnableScheduling注解
@SpringBootApplication
@EnableScheduling
public class ApplicationRun {
    public static void main(String[] args) {
        SpringApplication.run(ApplicationRun.class, args);
    }
}
### 回答1: Spring Boot整合Quartz框架可以实现定时任务的管理和调度。Quartz是一个开源的作业调度框架,可以用来实现各种定时任务,如定时发送邮件、定时备份数据等。在Spring Boot中,可以通过配置文件或注解的方式来实现Quartz整合。具体步骤如下: 1. 引入Quartz和Spring Boot的依赖包。 2. 配置Quartz的数据源和调度器。 3. 创建Job类,实现execute方法,编写定时任务的逻辑。 4. 创建Trigger类,设置定时任务的触发器,如执行时间、重复次数等。 5. 在配置类中注入Job和Trigger,配置SchedulerFactoryBean。 6. 在Controller中注入SchedulerFactoryBean,通过调用Scheduler的方法来启动和停止定时任务。 以上就是Spring Boot整合Quartz框架的基本步骤,具体实现可以参考相关的教程和示例代码。 ### 回答2: Spring Boot是一个快速构建基于Spring框架的应用程序的工具,它提供了快速开发、配置简单、易于管理的方法。Quartz是一个稳定、可靠和高效的开源作业调度框架Quartz提供了许多功能,包括复杂定时任务、任务调度、任务管理、集群支持、持久化等等。然而,Quartz的配置较为繁琐,需要考虑很多细节。为了避免这些麻烦,可以使用Spring Boot进行Quartz整合。 首先,在Spring Boot项目的pom.xml文件中添加Quartz的依赖: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 然后,在Spring Boot应用程序中配置Quartz,需要创建一个QuartzConfiguration类。这个类中包含了Quartz的基本配置信息,比如调度器工厂、作业存储、触发器、作业等等。以下是一个示例: ``` @Configuration public class QuartzConfiguration { @Bean public SchedulerFactoryBean schedulerFactoryBean() { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setJobFactory(jobFactory()); schedulerFactoryBean.setQuartzProperties(quartzProperties()); return schedulerFactoryBean; } @Bean public JobDetailFactoryBean jobDetailFactoryBean() { JobDetailFactoryBean factory = new JobDetailFactoryBean(); factory.setJobClass(MyJob.class); factory.setDescription("Invoke Sample Job service..."); factory.setDurability(true); return factory; } @Bean public SimpleTriggerFactoryBean simpleTriggerFactoryBean() { SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean(); factoryBean.setJobDetail(jobDetailFactoryBean().getObject()); factoryBean.setRepeatInterval(3000); factoryBean.setRepeatCount(SimpleTrigger.REPEAT_INDEFINITELY); return factoryBean; } @Bean public JobFactory jobFactory() { return new AutowiringSpringBeanJobFactory(); } @Bean public Properties quartzProperties() { PropertiesFactoryBean props = new PropertiesFactoryBean(); props.setLocation(new ClassPathResource("/quartz.properties")); props.afterPropertiesSet(); return props.getObject(); } } ``` 在这个配置类中,首先创建了调度器工厂,然后设置了作业存储、触发器和作业等等。这里要注意,作业需要实现QuartzJob接口,同时,也需要添加一个AutwiringSpringBeanJobFactory,以便在作业中注入Spring Bean。 最后,在Spring Boot应用程序中定义一个Quartz作业类,实现QuartzJob接口。在这个作业类中,编写需要执行的任务。 ``` public class MyJob implements Job { @Autowired private SampleJobService sampleJobService; @Override public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException { sampleJobService.executeSampleJob(); } } ``` 以上就是使用Spring Boot整合Quartz框架的基本步骤。通过这种方式,我们可以快速构建出一个强大、稳定和高效的作业调度系统,使得整个应用程序变得更加可靠和高效。 ### 回答3: Spring Boot 是一款非常流行的微服务框架,它可以帮助我们快速构建可扩展的应用程序。其中,Quartz 是一款流行的定时任务调度框架,它可以帮助我们在应用程序中实现定时任务调度的功能。本文将介绍 Spring Boot 整合 Quartz 框架的方法。 首先,我们需要在 Maven 中引入 Quartz 框架的依赖。在 pom.xml 文件中添加以下代码: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> ``` 然后,我们需要创建一个 Quartz 配置类,用于配置 Quartz 的属性。在该类中,我们需要创建一个 SchedulerFactoryBean 对象,用于创建 Quartz 的 Scheduler 对象。在 SchedulerFactoryBean 对象中,我们需要设置 DataSource 对象、JobFactory 对象、Bean 名称等属性。以下是一个示例: ``` @Configuration public class QuartzConfig { @Autowired private DataSource dataSource; @Autowired private ApplicationContext applicationContext; @Bean public JobFactory jobFactory() { AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory(); jobFactory.setApplicationContext(applicationContext); return jobFactory; } @Bean public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) { SchedulerFactoryBean factory = new SchedulerFactoryBean(); factory.setDataSource(dataSource); factory.setJobFactory(jobFactory); factory.setApplicationContextSchedulerContextKey("applicationContext"); factory.setSchedulerName("QuartzScheduler"); factory.setApplicationContext(applicationContext); factory.setStartupDelay(10); return factory; } } ``` 以上代码中,我们创建了一个 JobFactory 对象,用于自动装配 Spring Bean。然后,我们创建了一个 SchedulerFactoryBean 对象,用于创建 Quartz 的 Scheduler 对象。SchedulerFactoryBean 对象中设置了 DataSource 对象、JobFactory 对象、Bean 名称等属性。 接下来,我们需要创建一个定时任务,该任务继承于 QuartzJob 接口,实现 execute() 方法。例如: ``` @Component public class SampleJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("SampleJob is running..."); } } ``` 最后,我们需要将该任务添加到 Quartz 的 Scheduler 对象中,以实现定时执行。我们可以在应用程序启动后,使用 @PostConstruct 注解调用以下代码: ``` @Autowired private SchedulerFactoryBean schedulerFactoryBean; @PostConstruct public void init() throws Exception { Scheduler scheduler = schedulerFactoryBean.getScheduler(); JobDetail jobDetail = JobBuilder.newJob(SampleJob.class) .withIdentity("sampleJob", "sampleGroup") .build(); CronTrigger cronTrigger = TriggerBuilder.newTrigger() .withIdentity("sampleTrigger", "sampleGroup") .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) .build(); scheduler.scheduleJob(jobDetail, cronTrigger); scheduler.start(); } ``` 以上代码中,我们从 SchedulerFactoryBean 对象中获取了 Quartz 的 Scheduler 对象,并创建了一个 JobDetail 对象和一个 CronTrigger 对象,用于描述定时任务。然后,我们将这两个对象添加到 Scheduler 对象中,并启动了 Scheduler 对象。 至此,完成了 Spring Boot 整合 Quartz 框架的过程。我们可以在应用程序中添加多个定时任务,实现各种定时任务调度的功能。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值