笔记大全

SpringBoot整合Quartz及异步调用的方法是什么

更新时间：2023-11-29

第一段：SpringBoot整合Quartz的方法

在SpringBoot项目中，可以使用Quartz来完成定时任务的处理。

首先，需要在pom.xml文件中添加如下依赖：

    
        org.springframework.boot
        spring-boot-starter-quartz

然后，在配置文件中添加如下内容，配置任务调度器：

quartz:
  job-store-type: memory  
  properties:
    org:
      quartz:
        scheduler:
          instanceName: scheduler  
          instanceId: AUTO  
        threadPool:
          threadCount: 10  
          threadPriority: 5  
        jobStore:
          class: org.quartz.simpl.RAMJobStore

注：这里使用的是内存存储，具体可以根据实际情况选择使用数据库存储。

接着，在项目中定义定时任务，例如：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("执行定时任务");
    }

}

最后，在启动类中配置定时任务，并启动调度器：

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) throws SchedulerException {
        SpringApplication.run(Application.class, args);
    }

    // 定义定时任务
    @Bean
    public JobDetail jobDetail() {
        return JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob")
                .storeDurably()
                .build();
    }

    // 定义触发器
    @Bean
    public Trigger trigger() {
        return TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withIdentity("myJobTrigger")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
                .build();
    }

    // 配置调度器
    @Bean
    public Scheduler scheduler() throws SchedulerException {
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.scheduleJob(jobDetail(), trigger());
        scheduler.start();
        return scheduler;
    }

}

第二段：异步调用的方法

在SpringBoot中，可以使用@Async注解来实现异步调用。具体方法如下：

首先，在pom.xml文件中添加如下依赖：

    
        org.springframework.boot
        spring-boot-starter-web

然后，在启动类上添加@EnableAsync注解，并在方法上添加@Async注解：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableAsync;

@SpringBootApplication
@EnableAsync
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }

    @Async
    public void doSomething() {
        // 异步执行的方法
    }

}

这样，在doSomething方法被调用时，会启动一个新的线程来执行其中的逻辑代码，从而实现异步调用。

第三段：Quartz整合异步调用的方法

如果需要在Quartz中调用异步方法，可以使用QuartzJobBean替代Job接口，并在其中调用异步方法，具体方法如下：

先定义一个异步方法：

import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Component
public class MyService {

    @Async
    public void doSomething() {
        // 异步执行的方法
    }

}

然后编写一个任务类：

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

@Component
public class MyJob extends QuartzJobBean {

    private MyService myService;

    public MyJob(MyService myService) {
        this.myService = myService;
    }

    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        myService.doSomething();
    }

}

最后，在启动类中配置任务调度器，将任务类注入到调度器中：

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

@SpringBootApplication
public class Application {

    public static void main(String[] args) throws SchedulerException {
        SpringApplication.run(Application.class, args);
    }

    // 定义任务
    @Bean
    public JobDetail jobDetail() {
        return JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob")
                .storeDurably()
                .build();
    }

    // 定义触发器
    @Bean
    public Trigger trigger() {
        return TriggerBuilder.newTrigger()
                .forJob(jobDetail())
                .withIdentity("myJobTrigger")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(5).repeatForever())
                .build();
    }

    // 配置调度器
    @Bean
    public Scheduler scheduler(JobDetail jobDetail, Trigger trigger) throws SchedulerException {
        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.scheduleJob(jobDetail, trigger);
        scheduler.start();
        return scheduler;
    }

}

第四段：总结

SpringBoot整合Quartz及异步调用可以实现非常方便快捷的定时任务处理和异步处理功能。在Quartz中调用异步方法，只需要使用QuartzJobBean替代Job接口，并在其中调用异步方法即可。需要注意的是，异步方法需要使用@EnableAsync注解开启异步调用功能。

c语言编程笔录