Spring Boot整合Quartz实现动态配置

概述

本文介绍如何把Quartz定时任务做成接口,实现以下功能的动态配置:

  • 添加任务
  • 修改任务
  • 暂停任务
  • 恢复任务
  • 删除任务
  • 任务列表
  • 任务详情

注:添加任务接口仍然需要开发者提前准备好任务类,接口的目的是实现定时任务的动态调整,按需进行开关和修改,请注意这点。

Spring Boot整合Quartz

简单说下Quartz的整合,做一下准备工作。

导入Quartz依赖

xml复制代码<!--Quartz定时任务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

配置文件中增加Quartz的支持

yml复制代码spring:
 datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: xxx
    username: xxx
    password: xxx
  quartz:
    job-store-type: jdbc # 定时任务的数据保存到jdbc即数据库中
    jdbc:
      # embedded:默认
      # always:启动的时候初始化表,我们只在第一次启动的时候用它来自动创建表,然后改回embedded即可,不然数据每次都会被清空
      # never:启动的时候不初始化表,也不知道和embedded有什么不同
      initialize-schema: embedded

第一次启动的时候请把上面的initialize-schema设置为always,这会在数据库里面自动建表,然后第二次启动时改回embedded即可。

如果不需要定时任务的持久化就可以不管。

写一个测试用的任务类

java复制代码import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

@Component
public class QuartzTestJob extends QuartzJobBean {
    @Override
    protected void executeInternal(org.quartz.JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Quartz Test Job");
    }
}

为这个任务类写一个配置类

java复制代码
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzTestJobConfig {
    @Bean
    public JobDetail quartzTestJobDetail() {
        return JobBuilder.newJob(QuartzTestJob.class)
                .withIdentity(QuartzTestJob.class.getSimpleName())
                .storeDurably()
                .usingJobData("data", "test")
                .build();
    }

    @Bean
    public Trigger quartzTestJobTrigger() {
        // 0/1 * * * * ?
        return TriggerBuilder.newTrigger()
                .forJob(QuartzTestJob.class.getSimpleName())
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(1).repeatForever())
                .build();
    }
}

结论

以上是使用Quartz写一个定时任务的步骤,很简单,问题是配置写死了,没有办法动态调整,所以我们开始写接口,把上面这个任务配置类去掉。

定时任务动态配置实现

我们还是用上面的任务类QuartzTestJob做测试,这里再说明一次,我们需要有一个任务类作为基础,本文的目的只是去掉上面的QuartzTestJobConfig

剩下的内容没有什么需要多说明的,我直接贴代码了。

业务层

java复制代码public interface QuartzService {
    /**
     * 添加定时任务
     */
    void addJob(QuartzCreateParam param) throws SchedulerException;

    /**
     * 修改定时任务
     */
    void updateJob(QuartzUpdateParam param) throws SchedulerException;

    /**
     * 暂停定时任务
     */
    void pauseJob(QuartzDetailParam param) throws SchedulerException;

    /**
     * 恢复定时任务
     */
    void resumeJob(QuartzDetailParam param) throws SchedulerException;

    /**
     * 删除定时任务
     */
    void deleteJob(QuartzDetailParam param) throws Sc
  • 2
    点赞
  • 9
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
### 回答1: Spring Boot可以很方便地整合Quartz,只需要在pom.xml中添加相关依赖,然后在配置文件中配置Quartz相关属性即可。 具体步骤如下: 1. 在pom.xml中添加Quartz依赖: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version> </dependency> ``` 2. 在配置文件中配置Quartz相关属性: ``` spring.quartz.job-store-type=jdbc spring.quartz.jdbc.initialize-schema=always spring.quartz.properties.org.quartz.scheduler.instanceName=myScheduler spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate spring.quartz.properties.org.quartz.jobStore.dataSource=myDS spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_ spring.quartz.properties.org.quartz.dataSource.myDS.driverClassName=com.mysql.jdbc.Driver spring.quartz.properties.org.quartz.dataSource.myDS.URL=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=utf-8&useSSL=false spring.quartz.properties.org.quartz.dataSource.myDS.user=root spring.quartz.properties.org.quartz.dataSource.myDS.password=root ``` 3. 创建Job类和Trigger类: ``` @Component public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("Hello, Quartz!"); } } @Configuration public class QuartzConfig { @Bean public JobDetail myJobDetail() { return JobBuilder.newJob(MyJob.class) .withIdentity("myJob") .storeDurably() .build(); } @Bean public Trigger myTrigger() { return TriggerBuilder.newTrigger() .forJob(myJobDetail()) .withIdentity("myTrigger") .withSchedule(CronScheduleBuilder.cronSchedule("/5 * * * * ?")) .build(); } } ``` 4. 在启动类中注入SchedulerFactoryBean并启动Quartz: ``` @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } @Autowired private SchedulerFactoryBean schedulerFactoryBean; @PostConstruct public void startQuartz() throws SchedulerException { schedulerFactoryBean.getScheduler().scheduleJob(quartzConfig.myJobDetail(), quartzConfig.myTrigger()); } } ``` 这样就完成了Spring Boot整合Quartz配置。在启动应用程序时,Quartz会自动创建表并启动定时任务。 ### 回答2: Spring Boot是基于Spring Framework的快速应用开发框架,而Quartz是一个任务调度框架,可以帮助我们定义和执行各种类型的后台作业。本文将为你介绍如何使用Spring Boot整合Quartz框架。 1. 添加依赖 在Spring Boot中使用Quartz需要添加以下依赖: ``` <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz-jobs</artifactId> <version>2.3.0</version> </dependency> ``` 2. 配置Job 在Quartz中,Job是需要执行的任务,我们需要定义一个类来实现这个Job。 ``` public class MyJob implements Job { @Override public void execute(JobExecutionContext context) throws JobExecutionException { // 任务逻辑 } } ``` 3. 配置Trigger 在Quartz中,Trigger用于定义任务执行的时间和频率。 ``` public class MyTrigger { public Trigger getTrigger() { return TriggerBuilder.newTrigger() .withIdentity("myTrigger", "group1") .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) .forJob("myJob", "group1") .build(); } } ``` 在上面的代码中,我们使用Cron表达式来定义Job的执行时间。 4. 配置Scheduler 在Quartz中,Scheduler是最核心的部分,它负责管理所有的Job和Trigger,并按照预定的时间执行任务。 ``` @Configuration public class SchedulerConfig { @Autowired private ApplicationContext applicationContext; @Bean public SchedulerFactoryBean schedulerFactoryBean() throws IOException { SchedulerFactoryBean factory = new SchedulerFactoryBean(); factory.setQuartzProperties(quartzProperties()); factory.setJobFactory(springBeanJobFactory()); return factory; } @Bean public Properties quartzProperties() throws IOException { PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean(); propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties")); propertiesFactoryBean.afterPropertiesSet(); return propertiesFactoryBean.getObject(); } @Bean public SpringBeanJobFactory springBeanJobFactory() { AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory(); jobFactory.setApplicationContext(applicationContext); return jobFactory; } @Bean public Scheduler scheduler() throws IOException { return schedulerFactoryBean().getScheduler(); } @Bean public JobDetail myJobDetail() { return JobBuilder.newJob(MyJob.class) .withIdentity("myJob", "group1") .storeDurably() .build(); } @Bean public Trigger myTrigger() { return new MyTrigger().getTrigger(); } @PostConstruct public void init() throws SchedulerException, IOException { scheduler().addJob(myJobDetail(), true); scheduler().scheduleJob(myTrigger()); scheduler().start(); } } ``` 在上面的代码中,我们创建了一个SchedulerFactoryBean用于创建Scheduler实例,并在配置类中创建了多个Bean,包括JobDetail、Trigger和自定义的SpringBeanJobFactory。 最后,在@PostConstruct注解下,我们将Job和Trigger添加到Scheduler实例中,并启动Scheduler开始任务调度。 5. 编写Quartz.properties文件 在resources目录下创建quartz.properties文件,用于配置Quartz的一些属性。 ``` org.quartz.scheduler.instanceName = MyScheduler org.quartz.threadPool.threadCount = 3 org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate org.quartz.jobStore.dataSource = myDS org.quartz.jobStore.tablePrefix = QRTZ_ org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/mydb org.quartz.dataSource.myDS.user = myuser org.quartz.dataSource.myDS.password = mypassword org.quartz.dataSource.myDS.maxConnections = 10 ``` 以上就是使用Spring Boot整合Quartz框架的全部步骤,通过以上步骤,我们可以轻松地创建和调度各种类型的后台任务。 ### 回答3: Spring Boot 是一个基于 Spring 框架的快速开发框架,使得构建Spring应用程序非常容易。Quartz 是一个用于作业调度的开源框架,可以通过定义任务和调度器来实现任务的自动化调度。Spring BootQuartz 框架的整合,则可以帮助开发人员更加便捷地实现任务调度。 Spring Boot整合Quartz的步骤如下: 1.在 pom.xml 中添加 Quartz 的依赖: ```xml <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.0</version> </dependency> ``` 2.创建一个 Job 类,在该类中实现具体要执行的任务逻辑,并继承 org.quartz.Job 接口: ```java public class HelloWorldJob implements Job{ public void execute(JobExecutionContext context) throws JobExecutionException { System.out.println("Hello World."); } } ``` 3.在配置文件中添加 quartz 相关的配置,例如在 application.properties 文件中添加如下配置: ``` spring.quartz.job-store-type=jdbc spring.datasource.driver-class-name=com.mysql.jdbc.Driver spring.datasource.url=jdbc:mysql://localhost:3306/test spring.datasource.username=root spring.datasource.password=123456 spring.quartz.jdbc.initialize-schema=always ``` 4.创建 SchedulerFactoryBean 类,用于创建调度器,并将 Job 注册到调度器中: ```java @Configuration public class QuartzConfig { @Autowired private DataSource dataSource; @Bean public JobDetail jobDetail() { return JobBuilder.newJob(HelloWorldJob.class) .withIdentity("helloJob") .storeDurably() .build(); } @Bean public Trigger trigger() { SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule() .withIntervalInSeconds(10) .repeatForever(); return TriggerBuilder.newTrigger() .forJob(jobDetail()) .withIdentity("helloTrigger") .withSchedule(scheduleBuilder) .build(); } @Bean public SchedulerFactoryBean schedulerFactory() { SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean(); schedulerFactoryBean.setDataSource(dataSource); schedulerFactoryBean.setJobDetails(jobDetail()); schedulerFactoryBean.setTriggers(trigger()); return schedulerFactoryBean; } } ``` 在 SchedulerFactoryBean 类中,首先创建了一个 JobDetail 类,用于描述 Job 相关的信息。然后,通过调用 TriggerBuilder 类的 newTrigger() 方法创建了一个 trigger,用于描述 Job 调度的策略和时间。最后,通过调用 SchedulerFactoryBean 的 setJobDetails() 方法和 setTriggers() 方法将 Job 和 trigger 注册到调度器中。 5.启动应用程序,任务就会开始按照调度器中定义的策略自动运行。 总的来说,Spring Boot整合Quartz非常容易,只需添加相应的依赖、编写 Job 类和 SchedulerFactoryBean 类,并在配置文件中添加相关的配置即可获得方便的任务调度功能。
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值