springboot quartz 使用

springboot 继承quartz（这里使用内存存储任务，如果想使用数据库存储需要额外配置DataSource这里暂不赘述）

1. 引入依赖pom

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>

2. 配置quartz 和spring依赖依赖注入等
   SpringJobFactory 是为了在job中能依赖注入spring 的bean

@Component
public class SpringJobFactory extends AdaptableJobFactory {
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 调用父类的方法
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入
        capableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

@Configuration
public class QuartzConfig {
    //注入JobFactory
    @Autowired
    SpringJobFactory springJobFactory;

    /**
     * SchedulerFactoryBean这个类的真正作用提供了对org.quartz.Scheduler的创建与配置，并且会管理它的生命周期与Spring同步。
     * org.quartz.Scheduler: 调度器。所有的调度都是由它控制。
     *  数据源默认内存，且为非集群模式
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //设置自行启动
        factory.setAutoStartup(true);
        factory.setJobFactory(springJobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }

//注入scheduler到spring
    @Bean(name = "scheduler")
    public Scheduler scheduler() throws IOException {
        return schedulerFactoryBean().getScheduler();
    }

    @Bean
    public Properties quartzProperties() throws IOException {
        Properties properties = new Properties();
//        ID设置为自动获取 每一个必须不同 （所有调度器实例中是唯一的）
        properties.setProperty("org.quartz.scheduler.instanceId","AUTO");
//        ThreadPool实现的类名
        properties.setProperty("org.quartz.threadPool.class","org.quartz.simpl.SimpleThreadPool");
        return properties;
    }

3. 完成配置后，就可以使用了
   例如：先创建一个spring service

@Service
public class SrpingService {

    public void test(){
       System.out.println("spring service");
    }
}

创建job 并注入该service

public class MyJob extends QuartzJobBean {
    @Autowired
    private SrpingService service;

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //如果超时下发超时提醒，并取消招车单，招车单编号
       service.test();
    }
}

创建一个job监听器,可以处理一些任务前后

@Component
public class JobListener implements JobListener {
    @Autowired
    JobScheduler scheduler;

    //获取该JobListener的名称
    @Override
    public String getName() {
        // TODO Auto-generated method stub
        String name = getClass().getSimpleName();
        log.info(name);
        return name;
    }
    //：Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
    @Override
    public void jobExecutionVetoed(JobExecutionContext arg0) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail即将被执行，但又被TriggerListerner否决");
    }
    //Scheduler在JobDetail将要被执行时调用这个方法。
    @Override
    public void jobToBeExecuted(JobExecutionContext arg0) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail将要被执行");
    }
    //Scheduler在JobDetail被执行之后调用这个方法
    @Override
    public void jobWasExecuted(JobExecutionContext arg0, JobExecutionException arg1) {
        // TODO Auto-generated method stub
        log.info("Scheduler在JobDetail被执行之后,删除该job");
        JobKey jobKey  = arg0.getJobDetail().getKey();
        //移除该job
         scheduler.deleteJob(jobKey);
    }
}

写一个JobScheduler封装Scheduler为方便使用(并且初始化启动)

@Service
public class JobScheduler {

    @Autowired
    private  Scheduler scheduler;

    //初始化启动
    @PostConstruct
    public void initialize() {
        try {
            scheduler.start();
        } catch (SchedulerException e) {
        }
    }

    public  void addJob(JobDetail jobDetail, Trigger trigger){
        //加入这个调度
        try {
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public  void runSchedule(){
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    public  void deleteJob(JobKey jobKey){
        try {
            scheduler.deleteJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    /**
     * 添加指定的job监听器
     * @param jobListener
     */
    public  void addJobListiner(JobListener jobListener,String jobName,String jobGroupName){
        try {
            scheduler.getListenerManager().addJobListener(jobListener, KeyMatcher.keyEquals(JobKey.jobKey(jobName,jobGroupName)));
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

}

处理完，就可以使用了

@Service
public class MyUserQuartzService {
        @Autowired
    private JobScheduler jobScheduler;
        @Autowired
    private JobListener jobListener;

    public void testQuartz(){
     jobScheduler.addJobListiner(jobListener,"jobName","groupName");
     JobDetail  jobDetail= JobBuilder.newJob(MyJob.class).withIdentity("jobName","groupName").storeDurably().build();
     Trigger trigger = TriggerBuilder.newTrigger()
     //一分钟后执行
                .startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.MINUTE))
                .withIdentity("triggerName","groupName")
//                .withSchedule(simpleScheduleBuilder) 可以写自己的cron方式
                .build();
                //因为前面已经启动scheduler，所以这里直接放入即可
     jobScheduler.addJob(jobDetail, trigger);
    }

上面的MyUserQuartzService 就可以在我们想调用的地方使用就可以了，也可以通过controller调用，加入正删改查任务的接口