Springboot整合Quartz 达到定时任务的效果

把自己博客的内容搬运过来

Quartz

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。

job

做什么事

trigger

什么时间做

scheduler

在什么时间做什么事

1. 创建xxx类实现job接口（org.quartz.job) execute方法（任务被触发时执行的方法）

2. 创建类

   • 创建job对象 JobDetail job = JobBuilder.newJob(xxx.class).build();
   • 创建Trigger对象
     Trigger trigger = TriggerBuilder.newTrigger().withSchedule(schedBuilder).build();
     • 简单的trigger触发时间：通过Quartz提供一个方法来完成简单的重复调用
       ​ SimpleSchedulerBuilder.repeatxxxxxx()
     • cron cromSchedule
   • 创建Scheduler对象
     Scheduler s = StdSchedulerFactory.getSDefaultScheduler();
     s.schedulerJob(job,trigger);
   • 启动 scheduler.start();

springboot整合

pom依赖

<!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz -->
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.3.2</version>
	<exclusions>
	  <exclusion>
    	 <artifactId>slf4j-api</artifactId>
         <groupId>org.slf4j</groupId>
	  </exclusion>
    </exclusions>
</dependency>
    
<!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>

<!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

创建Job类

实现job接口 如QuartzDemo

QuartzConfig配置类（@Configuration）

1. 创建Job对象

   @Bean
   public JobDetailFactoryBean jobDetailFactoryBean(){
       JobDetailFactoryBean factory = new JobDetailFactoryBean();
       factory.setJobClass(QuartzDemo.class);
       return factory;
   }
   

2. 创建Trigger对象

   简单Trigger

   @Bean
   public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean j){
       SimpleTriggerFactoryBean factory = new SimpleTriggerFactoryBean();
       //关联JobDetail对象
       factory.setJobDetail(j.getObject());
       //repeatInterval 表示执行的毫秒数
       factory.setRepeatInterval(repeatInterval);
       //设置重复次数
       factory.setRepeatCount(5);
       return factory;
   }
   

   Core

   @Bean
   public CoreTriggerFactoryBean coreTriggerFactoryBean(JobDetailFactoryBean j){
       CoreTriggerFactoryBean factory = new CoreTriggerFactoryBean();
       factory.setJobDetail(j.getObject());
       factory.setCornExpression("");
       return factory;
   }
   

3. 创建Scheduler对象

   @Bean
   public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean  s){
       SchedulerFactoryBean factory = new SchedulerFactoryBean();
       //关联trigger
       factory.setTriggers(s.getObject());
       return factory;
   }
   

启动类

@EnableScheduling

Job类对象注入

Job直接引入业务类 不会经过Spring的处理 而是一个简单的反射（AdaptableJobFactory）

1. 继承AdaptableJobFactory类 重写方法createJobInstance

   @Compoment("myAdaptableJobFactory")
   public class MyAdaptableJobFactory extends AdaptableJobFactory{
       //AutowireCapableBeanFactory 可以将一个对象添加到springIOC容器中，并完成注入
   	@Autowired
       private AutowireCapableBeanFactory autowireCapableBeanFactory;
     
     /**
      * 将实例化的任务对象手动添加到springIOC容器中并且完成对象注入
      */
     public Object createJobInstance(TriggerFiredBundle bundle) throws Exception{
            Object obj = super.createJobInstance(bundle);
         	 autowireCapableBeanFactory.autowireBean(obj);
            return obj;
     }
   }
   

2. 重新设计jobFactory,创建Scheduler对象

   @Bean
   public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean s,
                                                    MyAdaptableJobFactory myAdaptableJobFactory){
       SchedulerFactoryBean factory = new SchedulerFactoryBean();
       //关联trigger
       factory.setTriggers(s.getObject());
       factory.setJobFactory(myAdaptableJobFactory);
       return factory;
   }