SpringBoot 配置 定时器（ Quartz 框架、Scheduled ）

---

---

一、Quartz 定时任务框架

1. 所需依赖
     Web - Spring Web
2. 启动类注解
     @EnableScheduling

1-1】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>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

1-2】项目代码

  1/4  业务代码

package com.debj.quartz_lx.service;

import org.springframework.stereotype.Service;

@Service
public class InfoService {

    public void showInfo(){
        System.out.println("--- 定时任务器，将会定时执行此方法 ---");
    }
}

  2/4  定时任务类

package com.debj.quartz_lx.timer;

import com.debj.quartz_lx.service.InfoService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class JobImpl implements Job {

    @Resource
    private InfoService infoService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        infoService.showInfo();
    }
}

  3/4  编写自定义适应 Job 工厂

package com.debj.quartz_lx.util;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component(value = "myAdaptableJobFactory")
public class MyAdaptableJobFactory extends AdaptableJobFactory {

    @Resource
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    @Override
    protected Object createJobInstance(
            TriggerFiredBundle bundle) throws Exception {
        Object obj = super.createJobInstance(bundle);
        // 将 obj 对象添加 Spring IOC 容器中，并完成注入
        this.autowireCapableBeanFactory.autowireBean(obj);
        return obj;
    }
}

  4/4  Quartz 配置类

package com.debj.quartz_lx.config;

import com.debj.quartz_lx.timer.JobImpl;
import com.debj.quartz_lx.util.MyAdaptableJobFactory;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfig {

    // 创建 Job 对象
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean factory = new JobDetailFactoryBean();
        factory.setJobClass(JobImpl.class);
        return factory;
    }

    // 创建 Cron Trigger 对象
    @Bean
    public CronTriggerFactoryBean cronTriggerFactoryBean(
            JobDetailFactoryBean jobDetailFactoryBean){
        CronTriggerFactoryBean factory = new CronTriggerFactoryBean();
        factory.setJobDetail(jobDetailFactoryBean.getObject());
        factory.setCronExpression("0/2 * * * * ?");		// 触发时间设置
        return factory;
    }

    // 创建 Scheduler 对象
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(
            CronTriggerFactoryBean cronTriggerFactoryBean,
            MyAdaptableJobFactory myAdaptableJobFactory){
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setTriggers(cronTriggerFactoryBean.getObject());    // 关联 trigger
        factory.setJobFactory(myAdaptableJobFactory);               // 关联 自定义工厂
        return factory;
    }

}

二、Quartz 补充

2-1】单纯执行定时任务的 Main 方法

package com.debj.quartz_lx.util;

import com.debj.quartz_lx.timer.JobImpl;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 运行经方法，需要将【JobImpl】中业务代码注释
 * 例：
 *      // infoService.showInfo();
 *      System.out.println("aaa");
 */
public class QuartzMain {
    public static void main(String[] args) throws Exception {
        // 创建 Job 对象：你要做什么事？
        JobDetail job = JobBuilder.newJob(JobImpl.class).build();

        // 创建 Trigger 对象：在什么时间做？
        // Trigger trigger = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever()).build();
        Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?")).build();

        // 创建 Scheduler 对象：在什么时间做什么事？
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.scheduleJob(job, trigger);

        //启动
        scheduler.start();
    }
}

2-2】QuartzConfig 另一种配置

// 创建 Trigger 对象，简单的 Trigger
@Bean
public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
    SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
    // 关联 JobDetail 对象
    factory.setJobDetail(jobDetailFactoryBean.getObject());
    // 该参数表示一个执行的毫秒数
    factory.setRepeatInterval(2000);
    // 重复数次
    factory.setRepeatCount(5);
    return factory;
}
 // 创建 Scheduler 对象
@Bean
public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    // 关联 trigger
    factory.setTriggers(simpleTriggerFactoryBean.getObject());
    return factory;
}

三、Scheduled（ 定时任务器 ）小练习

1. 所需依赖
     Web - Spring Web
2. 启动类注解
     @EnableScheduling
   与之前 依赖、注解 一致

package com.debj.quartz_lx.scheduled;

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

import java.util.Date;

@Component
public class ScheduledDemo {

    /**
     * 此方法【每五秒】执行一次
     * 
     * corn：秒 分 小时 月份中的日期 月份 星期中的日期 年份
     * @Scheduled(cron = "5 * * * * ?")：每分钟的第五秒执行
     */
    @Scheduled(cron = "0/5 * * * * ?")
    public void scheduledMethod(){
        System.out.println("定时器被触发时间：" + new Date());
    }

}