Java quartz创建定时任务

莱茵战线

已于 2023-03-10 15:38:03 修改

阅读量299

点赞数

分类专栏：项目经验记录文章标签： java 数据库大数据

于 2022-11-27 15:08:50 首次发布

本文链接：https://blog.youkuaiyun.com/m0_47104939/article/details/128064548

版权

项目经验记录专栏收录该内容

60 篇文章

订阅专栏

该博客介绍了如何在SpringBoot应用中整合Quartz框架来创建和配置定时任务。首先，展示了如何添加相关依赖，然后编写Job处理类，并通过`@Autowired`注解尝试注入服务。由于异步线程环境下无法直接注入，因此使用静态`ApplicationContextHolder`获取Bean。接着，通过`main`方法测试了任务调度，包括设置任务数据、创建JobDetail、CronTrigger，并启动调度器。最后，给出了SpringBoot中配置Quartz的步骤，包括定义JobDetail、Trigger以及相关的配置类。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

//main方法测试
//导入依赖
<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz-jobs -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.2.1</version>
</dependency>

编写处理类

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

/**
 * 实现  Job 接口，重写 execute 方法
 */
public class QuartzDemo extends QuartzJobBean{
    
    //注意：这里无法通过注入获取bean对象
    @Autowired
    private XXXService xxxservice;

    /**
     * 具体执行任务调度的逻辑
     * @param jobExecutionContext
     * @throws JobExecutionException
     */
    @Override
    public void executeInternal(JobExecutionContextjobExecutionContext) throws JobExecutionException {    

        //通过ApplicationContextHolder获取要注入的Bean对象
        XXXService xxxservice= 
          ApplicationContextHolder.getBean(IMmsOperationService.class);

        //获取JOBData
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        String redisKey = jobDataMap.getString("redisKey");

       
//   定时任务的业务逻辑
        System.out.println("11111");
    }


import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

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

    /**
     * 通过类获取
     * @param clazz
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> clazz) {
        return applicationContext.getBean(clazz);
    }

    /**
     * 通过bean名称
     * @param name
     * @param <T>
     * @return
     */
    public static <T> T getBean(String name) {
        if (applicationContext == null) {
            throw new Exception("异步线程获取bean失败！");
        }
        return (T) applicationContext.getBean(name);

    }
}

main测试

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

import java.util.Date;

/**
 * quartz-job 的测试类
 */
public class Test {
    public static void main(String[] args) throws SchedulerException {
        // 1、创建 scheduled 工厂
        StdSchedulerFactory stdSchedulerFactory = new StdSchedulerFactory();
        // 2、从工厂中获得调度器的实例
        Scheduler scheduler = stdSchedulerFactory.getScheduler();

        //使用JobMap传递数据到JOB
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("redisKey", redisKey);

        // 3、创建 JobDetail，引用 “job” 具体的执行类
        JobDetail job = JobBuilder.newJob(QuartzDemo.class)
                .withDescription("xiangjiao  test") // job描述
                .withIdentity("xiangjiao", "bunana") // name 和 group
                .setJobData(jobDataMap) //传递jobData
                .build();

        // 任务执行时间，触发器等
        long startTimes = System.currentTimeMillis()+3*1000L;
        Date startDate = new Date(startTimes);

        // 4、创建 CronTrigger
        CronTrigger cronTrigger = TriggerBuilder.newTrigger()
                .withDescription("this is a cronTrigger")
                .withIdentity("xiangjiao2", "test2")
                .startAt(startDate)
                // 使用 SimpleScheduleBuilder 或者  CronScheduleBuilder
                //.withSchedule(SimpleScheduleBuilder.simpleSchedule())
                //.withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) // 每5秒执行一次(正常)
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) // 每5秒执行一次(异常)
                .build();

        // 5、注册任务和定时器
        scheduler.scheduleJob(job,cronTrigger);

        // 6、启动 定时调度器
        scheduler.start();

        // 7、关闭调度器
        // scheduler.shutdown();
    }
}

springboot整合quartz

1. 依赖

   <!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-quartz -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>2.7.0</version>
        </dependency>

2. 处理类

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

import java.text.SimpleDateFormat;
import java.util.Date;


@Service
public class XXXserviceImpl extends QuartzJobBean {

    /**
     * 任务的具体执行类
     * @param context
     * @throws JobExecutionException
     */
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("MyQuartzJob  executeInternal ----" + sdf.format(new Date()));
    }
}

3. 配置类

import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 自定义quartz配置类
 */
@Configuration
public class MyQuartzConfig {

    @Bean
    public JobDetail getJob1(){
        return JobBuilder
                .newJob(XXXServiceImpl.class) // 关联具体的执行类
                .withDescription("this is quartz job test 1") // 描述
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger testJobTrigger1(){
        // 使用设定
//        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
//                .withIntervalInSeconds(5)
//                .repeatForever();

        // 使用 cron 表达式
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
        return TriggerBuilder.newTrigger()
                .forJob(getJob1())
                .withIdentity("testJobTrigger1")
                //.withSchedule(scheduleBuilder)
                .withSchedule(cronScheduleBuilder)
                .build();
    }
}