springBoot中定时任务Quartz的用法

1、在项目中加入依赖

<!-- Quartz坐标 start -->
        <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>

        <!-- 添加Scheduled坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <!-- Sprng tx 坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>

        <!-- Quartz坐标 end -->

2、创建自己的job1类

package com.cn.quartz;

import com.cn.domain.User;
import com.cn.service.UserService;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

/**
 * @ClassName MyJob
 * @Description MyJob
 * @Author RX
 * @Date 2020/4/9 13:25
 * @Version 1.0
 */
@Component
public class MyJob implements Job {
//    @Autowired               为什么不能用自动注入service？注入的为什么为空？
//                              job是在job框架中完成实例化的，service是在spring中创建出来的，job不受spring的管理;
//    UserService userService;
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 获取bean的时候 通过一个实现applicationContextAwa接口的类，通过applicationContext.getBean(beanName)的方法获取;
        User userInfo = ((UserService)ApplicationContextHelper.getBean("userService")).getUserInfo("8");
        System.out.println("执行了myjob1"+userInfo+" 时间"+ LocalDateTime.now().withNano(0));
    }
}

job2

package com.cn.quartz;

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

import java.time.LocalDateTime;

/**
 * @ClassName MyJob2
 * @Description MyJob2
 * @Author RX
 * @Date 2020/4/9 13:34
 * @Version 1.0
 */
public class MyJob2 implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        System.out.println("this is myjob2 is excuting  "+ LocalDateTime.now().withNano(0));
    }
}

定时器配置类

package com.cn.quartz;

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;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**
 * @author rx
 */
@Configuration
public class QuartzConfig {

    /**
     * 将Job1放入JobDetailFactoryBean
     *
     * @return
     */
    @Bean(name = "Job1")
    public JobDetailFactoryBean Job1() {
        JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
        //关联我们定义的Job类
        jobDetailFactory.setJobClass(MyJob.class);
        return jobDetailFactory;
    }

    @Bean(name = "Job2")
    public JobDetailFactoryBean Job2() {
        JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
        jobDetailFactoryBean.setJobClass(MyJob2.class);
        return jobDetailFactoryBean;
    }

    /**
     * 设置job1的定时器  类型为简单定时器 SimpleTrigger
     *
     * @param jobDetailFactory
     * @return
     */
    @Bean(name = "cronJob1")
    public SimpleTriggerFactoryBean cronJob1(@Qualifier("Job1") JobDetailFactoryBean jobDetailFactory) {
        SimpleTriggerFactoryBean simpleTriggerFactory = new SimpleTriggerFactoryBean();
        simpleTriggerFactory.setJobDetail(jobDetailFactory.getObject());
        //设置间隔时间
        simpleTriggerFactory.setRepeatInterval(2000);
        //设置重复次数
        simpleTriggerFactory.setRepeatCount(20);
        return simpleTriggerFactory;
    }

    /**
     * 设置job2的定时器  用cron模式
     */
    @Bean(name = "cronJob2")
    public CronTriggerFactoryBean cronJob2(@Qualifier("Job2") JobDetailFactoryBean jobDetailFactoryBean) {
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        cronTriggerFactoryBean.setCronExpression("0/5 * * * * ?");
        return cronTriggerFactoryBean;
    }


    /**
     * 将SimpleTrigger，cornTrigger 分别加入SchedulerFactoryBean
     *
     * @param
     * @return
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(@Qualifier("cronJob1") SimpleTriggerFactoryBean Job1
            , @Qualifier("cronJob2") CronTriggerFactoryBean Job2) {
        SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
        schedulerFactory.setTriggers(Job1.getObject(), Job2.getObject());//一次可以加多个任务定时器
        return schedulerFactory;
    }
}

创建一个applicationContextHelper类，用于job类中引用service时使用

package com.cn.quartz;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @ClassName ApplicationContextHelper
 * @Description ApplicationContextHelper
 * @Author RX
 * @Date 2020/4/9 14:56
 * @Version 1.0
 */
@Component
public class ApplicationContextHelper implements ApplicationContextAware {
    public static ApplicationContext acx;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.acx = applicationContext;
    }
    public static Object getBean(String beanName){
        return acx.getBean(beanName);
    }
}

最后开启定时任务---在主启动类上加上注解  @EnableScheduling