springboot+Quartz(任务调度)

1、引入pom

 <!-- quartz -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.3</version>
            </dependency>
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz-jobs</artifactId>
                <version>2.2.3<</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>

2、

@Component
public class MyJobFactory extends AdaptableJobFactory {

    /**
     * AutowireCapableBeanFactory接口是BeanFactory的子类
     * 可以连接和填充那些生命周期不被Spring管理的已存在的bean实例
     * 具体请参考：http://blog.csdn.net/iycynna_123/article/details/52993542
     */
    @Autowired
    private AutowireCapableBeanFactory capableBeanFactory;

    /**
     * 创建Job实例
     *
     * @param bundle
     * @return
     * @throws Exception
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        // 实例化对象
        Object jobInstance = super.createJobInstance(bundle);
        // 进行注入（Spring管理该Bean）
        capableBeanFactory.autowireBean(jobInstance);
        //返回对象
        return jobInstance;
    }
}

package com.wdk.logistics;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzConfig {

    @Autowired
    private MyJobFactory myJobFactory;

    /**
     * 创建调度器工厂
     */
    @Bean(name = "SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        factoryBean.setJobFactory(myJobFactory);
        return factoryBean;
    }

    @Bean(name = "scheduler")
    public Scheduler exeScheduler() throws SchedulerException {
        // 1. 创建scheduler，调度器  核心组件
        Scheduler scheduler = schedulerFactoryBean().getScheduler();
        Trigger trigger = TriggerBuilder.newTrigger()
            // 定义name/group
            .withIdentity("trigger1", "group1")
            .startNow()//一旦加入scheduler，立即生效，即开始时间
            .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(2)
                .repeatForever())//一直执行下去
            //.endAt(new GregorianCalendar(2023,9,19,9,59,10).getTime())//设置最终停止时间
            .build();

        // 3. 创建JobDetail，JobBuilder（任务）
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class)
            // 任务的名字和组
            .withIdentity("job04", "group04")
            // 任务中的数据和值
            .usingJobData("lierlin", "hello word ~~~")
            .build();

        // 4. 注册 JobDetail 和 Trigger
        scheduler.scheduleJob(jobDetail, trigger);//将任务和触发器注册到调度器
        scheduler.start();

        return scheduler;
    }

}

package com.wdk.logistics;

import java.util.List;

import javax.annotation.Resource;

import com.wdk.logistics.repo.EventBatchOffRepository;
import com.wdk.logistics.repo.InventoryInfoRepository;
import com.wdk.logistics.repo.model.EventBatchOffModel;
import com.wdk.logistics.repo.model.InventoryInfoModel;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @author lierlin
 */
@DisallowConcurrentExecution
public class MyJob implements Job {

    @Resource
    private EventBatchOffRepository eventBatchOffRepository;

    @Resource
    private InventoryInfoRepository  inventoryInfoRepository;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        //创建工作详情
        JobDetail jobDetail = jobExecutionContext.getJobDetail();
        //获取工作的名称
        //任务名
        String name = jobDetail.getKey().getName();
        //任务group
        String group = jobDetail.getKey().getGroup();
        //任务中的数据
        String job = jobDetail.getJobDataMap().getString("lierlin");
        //这里是我们最终要定时的任务
        //System.out.println("job执行，job名：" + name + " group:" + group + new Date() + job);
        //1、【查询出数据库中status = 1 的数据 进行仿真算法】

        try {
            List<EventBatchOffModel> batchOffModels = eventBatchOffRepository.queryByStatus();

            InventoryInfoModel lll = inventoryInfoRepository.queryById(11L);

            System.out.println("--------------------------------- " + "查询数据库" +batchOffModels);
        } catch (Exception e) {
            e.printStackTrace();
        }

        //2、【修改所有数据在数据库中的状态 status = 2 仿真中】
//        eventBatchOffModels.forEach(x -> {
//            eventBatchOffRepository.updateStatus(x.getId(), 2);
//        });
        //3、【开启线程启动调取 算法 &返回结果】

        //4、【批次下架结果 插入 批次下架结果表】

        //5、【更新数据库中status = 3 仿真完成】
//        eventBatchOffModels.forEach(x -> {
//            eventBatchOffRepository.updateStatus(x.getId(), 3);
//        });
    }
}