SpringBoot2 task scheduler 定时任务调度器四种方式

使用@EnableScheduling方式

@Component
@Configurable
@EnableScheduling
public class Task1 {
    private static Log logger = LogFactory.getLog(Task1.class);
    @Scheduled(cron = "0/2 * * * * * ")
    public void execute() {
        logger.info("Task1>>" + new Date());
    }
}

xml配置方式

application启动加入读取xml文件

@SpringBootApplication
@ImportResource(value = { "classpath:applicationContext*.xml" })
public class Springboot2TaskApplication {

    public static void main(String[] args) {
        SpringApplication.run(Springboot2TaskApplication.class, args);
    }
}

@Service
public class Task2 {
    private static Log logger = LogFactory.getLog(Task2.class);
    public void method2() {
        logger.info("Task2----method2>>>>" + new Date());
    }
}

bean创建工厂方式

使用到的jar包

    org.springframework
    spring-context-support


    org.springframework
    spring-tx


    org.quartz-scheduler
    quartz
    2.3.0

新建SchedledConfiguration.java文件

@Configuration
public class SchedledConfiguration {

    /**
     * attention:
     * Details：配置定时任务
     */
    @Bean(name = "jobDetail")
    public MethodInvokingJobDetailFactoryBean detailFactoryBean(Task3 task) {// TestTask为需要执行的任务
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        /*
         *  是否并发执行
         *  例如每5s执行一次任务，但是当前任务还没有执行完，就已经过了5s了，
         *  如果此处为true，则下一个任务会执行，如果此处为false，则下一个任务会等待上一个任务执行完后，再开始执行
         */
        jobDetail.setConcurrent(false);

        // 设置任务的名字
        jobDetail.setName("jobDetailName");

        // 设置任务的分组，这些属性都可以存储在数据库中，在多任务的时候使用
        jobDetail.setGroup("jobDetailGroup");

        /*
         * 为需要执行的实体类对应的对象
         */
        jobDetail.setTargetObject(task);

        /*
         * 通过这几个配置，告诉JobDetailFactoryBean我们需要执行定时执行ScheduleTask类中的task方法
         */
        jobDetail.setTargetMethod("task");
        return jobDetail;
    }

    /**
     * Details：配置定时任务的触发器，也就是什么时候触发执行定时任务
     */
    @Bean(name = "jobTrigger")
    public CronTriggerFactoryBean cronJobTrigger(JobDetail jobDetail) {
        CronTriggerFactoryBean tigger = new CronTriggerFactoryBean();
        tigger.setJobDetail(jobDetail);
        // 初始时的cron表达式，可以改成从数据库中获取
        tigger.setCronExpression("0/2 * * * * ?");
        // trigger的name
        tigger.setName("tiggerName");
        return tigger;

    }

    /**
     * Details：定义quartz调度工厂
     */
    @Bean(name = "scheduler")
    public SchedulerFactoryBean schedulerFactory(Trigger trigger) {
        SchedulerFactoryBean bean = new SchedulerFactoryBean();
        // 用于quartz集群,QuartzScheduler 启动时更新己存在的Job
        bean.setOverwriteExistingJobs(true);
        // 延时启动，应用启动1秒后
        bean.setStartupDelay(1);
        // 注册触发器
        bean.setTriggers(trigger);
        return bean;
    }
}

新建Task任务

@Service
public class Task3 {

    @Resource(name = "jobTrigger")
    private CronTrigger cronTrigger;

    @Resource(name = "scheduler")
    private Scheduler scheduler;

    private static Log logger = LogFactory.getLog(Task3.class);

    public void task() {
        logger.info("Task3---------" + new Date());
    }

    /**
     * 设置cron并重启定时器
     * @param cron cron值
     */
    public void setCron(String cron) {
        try {
            // 表达式调度构建器
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);
            // 按新的cronExpression表达式重新构建trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(cronTrigger.getKey());
            trigger = trigger.getTriggerBuilder().withIdentity(cronTrigger.getKey())
                    .withSchedule(scheduleBuilder).build();
            // 按新的trigger重新设置job执行
            scheduler.rescheduleJob(cronTrigger.getKey(), trigger);
        } catch (SchedulerException e) {
            logger.info("cron表达式错误");
        }
    }
}

其中setCron方法可以进行重新设定任务调度时间

ThreadPoolTaskScheduler Runnable方式

public class Task4 implements Runnable {

    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    private static Log logger = LogFactory.getLog(Task4.class);

    @Override
    public void run() {
        logger.info("Task4================" + new Date());
    }

    /**
     * 设置cron并启动
     * @param cronExp cron值
     */
    public void reStart(String cronExp) {
        if (null != this.threadPoolTaskScheduler) {
            ScheduledExecutorService scheduledExecutorService = this.threadPoolTaskScheduler.getScheduledExecutor();
            if (!scheduledExecutorService.isShutdown()) {
                scheduledExecutorService.shutdownNow();
            }

            this.threadPoolTaskScheduler.destroy();
        }

        if (null != cronExp && cronExp.trim().length() > 0) {
            this.threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
            this.threadPoolTaskScheduler.setThreadNamePrefix("task4");
            this.threadPoolTaskScheduler.initialize();
            this.threadPoolTaskScheduler.schedule(this, new CronTrigger(cronExp));
        }
    }
}

其中reStart可以进行任务启动和重新设置任务调度时间,调用方式如下所示

/**
     * 初始化task4
     * 这里的代码不应该写在rest层上， 应该写在service层上
     */
    @PostConstruct
    private void initTask4() {
        //初始化task4任务调度器cron，可以从数据库中查询到cron值
        setTask4Cron("0/3 * * * * ?");
    }

    /**
     * 改变task4的cron
     * @param cron cron值
     * @return 成功标志
     */
    @RequestMapping(value = { "/setTask4Cron" }, method = RequestMethod.GET)
    @ResponseBody
    public String setTask4Cron(String cron) {
        if (null == task4) {
            task4 = new Task4();
        }

        task4.reStart(cron);
        return "success";
    }

initTask4方法加了@PostConstruct'注解,可以在项目启动时自动根据cron来启动任务,setTask4Cron方法可以重新调置任务时间

四个任务的效果如下: