SpringBoot2.0集成Quartz实现动态定时任务

多任务情况下，quartz更容易管理，可以实现动态配置执行时间表达式：表达式示例：微服务启动时必须加上@EnableScheduling下面是单纯schedule 用法，简单@Scheduled(cron="0/5 * * * * ?")public void job(){System.out.println("每五秒执行一次");...

大树168

4399人浏览 · 2018-12-14 19:46:54

大树168 · 2018-12-14 19:46:54 发布

多任务情况下，quartz更容易管理，可以实现动态配置
执行时间表达式：

表达式示例：

微服务启动时必须加上@EnableScheduling

下面是单纯schedule 用法，简单

@Scheduled(cron="0/5 * * * * ?")
    public void job(){
        System.out.println("每五秒执行一次");
    }

集成Quartz

pom依赖因为已经有这个日志文件，所以排除掉

		<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>

下面直接上代码，其实都比较好理解

/**
 * 
 */
package com.matrix.cloud.service.impl;

import java.util.Map;

import org.quartz.CronExpression;
import org.quartz.CronScheduleBuilder;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;



/**
 * @author lmc
 * 2018年12月14日
 * ApplicationContextAware  两个地方都实现了此接口，初始化工作
 * 任务的删除和修改停止等方法都有， 然后封装一下对外提供接口就行 在controller写接口
 */
@Component
@Scope("singleton")
public class QuartzManager implements ApplicationContextAware {

    private Logger logger = LoggerFactory.getLogger(QuartzManager.class);

	private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

    private static final String JOB_DEFAULT_GROUP_NAME = "JOB_DEFAULT_GROUP_NAME";

    private static final String TRIGGER_DEFAULT_GROUP_NAME = "TRIGGER_DEFAULT_GROUP_NAME";


    private ApplicationContext applicationContext;

    private Scheduler scheduler;

    @Autowired
    private AutowiringSpringBeanJobFactory autowiringSpringBeanJobFactory;
    
    public void start() {
        //启动所有任务
        try {
            this.scheduler = schedulerFactory.getScheduler();
            scheduler.setJobFactory(autowiringSpringBeanJobFactory);
            //启动所有任务,这里获取AbstractTask的所有子类,继承的关系，取得所有子任务
            Map<String, AbstractTask> tasks =  applicationContext.getBeansOfType(AbstractTask.class);
            tasks.forEach((k, v) -> {
                String cronExpression = v.getCronExpression();
                if (cronExpression != null) {
                    addJob(k, v.getClass().getName(), cronExpression);
                }
            });
            logger.info("start jobs finished.");
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            throw new RuntimeException("init Scheduler failed");
        }
    }
    
    /*
     *  增加定时任务
	 */
    public boolean addJob(String jobName, String jobClass, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            logger.error("Illegal cron expression format({})", cronExp);
            return result;
        }
        try {
            JobDetail jobDetail = JobBuilder.newJob().withIdentity(new JobKey(jobName, JOB_DEFAULT_GROUP_NAME))
                    .ofType((Class<Job>) Class.forName(jobClass))
                    .build();
            Trigger trigger = TriggerBuilder.newTrigger()
                    .forJob(jobDetail)
                    .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
                    .withIdentity(new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME))
                    .build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
            logger.error("QuartzManager add job failed");
        }
        return result;
    }
    
    /*
     *  更新定时任务
	 */
    public boolean updateJob(String jobName, String cronExp) {
        boolean result = false;
        if (!CronExpression.isValidExpression(cronExp)) {
            logger.error("Illegal cron expression format({})", cronExp);
            return result;
        }
        JobKey jobKey = new JobKey(jobName, JOB_DEFAULT_GROUP_NAME);
        TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME);
        try {
            if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
                JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                Trigger newTrigger = TriggerBuilder.newTrigger()
                        .forJob(jobDetail)
                        .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
                        .withIdentity(new TriggerKey(jobName, TRIGGER_DEFAULT_GROUP_NAME))
                        .build();
                scheduler.rescheduleJob(triggerKey, newTrigger);
                result = true;
            } else {
                logger.error("update job name:{},group name:{} or trigger name:{},group name:{} not exists..",
                        jobKey.getName(), jobKey.getGroup(), triggerKey.getName(), triggerKey.getGroup());
            }
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            logger.error("update job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
        }
        return result;
    }

    /* 
     * 删除定时任务
	 */
    public boolean deleteJob(String jobName) {
        boolean result = false;
        JobKey jobKey = new JobKey(jobName, JOB_DEFAULT_GROUP_NAME);
        try {
            if (scheduler.checkExists(jobKey)) {
                result = scheduler.deleteJob(jobKey);
            } else {
                logger.error("delete job name:{},group name:{} not exists.", jobKey.getName(), jobKey.getGroup());
            }
        } catch (SchedulerException e) {
            logger.error(e.getMessage(), e);
            logger.error("delete job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
        }
        return result;
    }

	/* 
	 * 接口实现 初始化
	 */
	@Override
	public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
		 this.applicationContext = applicationContext;
	}
	
}

交给spring IOC管理的方法

/**
 * 
 */
package com.matrix.cloud.service.impl;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

/**
 * @author lmc
 * 2018年12月14日
 * Job默认由Quartz管理，如果需要使用Spring容器管理bean，也就是依赖注入，
 * 需要指定JobFactory，也就是指定将Job由Spring容器管理。
 */
@Component
public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        final Object jobInstance = super.createJobInstance(bundle);
        beanFactory.autowireBean(jobInstance);
        return jobInstance;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.beanFactory = applicationContext.getAutowireCapableBeanFactory();
    }

}

服务启动后，加载所有定时任务的接口

/**
 * 
 */
package com.matrix.cloud.service.impl;

import javax.annotation.PostConstruct;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * @author lmc
 * 2018年12月14日
 * 
 * 此方法是为了启动服务的时候，自动运行定时任务start()，其中 还可以利用@PostConstruct启动，还有CommandLineRunner 接口实现也可以
 */
@Component
public class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent>{

	@Autowired
    private QuartzManager quartzManager;

    /**
     * 初始启动quartz
     */
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        try {
        	quartzManager.start();
            System.out.println("任务已经启动...");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 初始注入scheduler
     * @return
     * @throws SchedulerException
     */
    @Bean
    public Scheduler scheduler() throws SchedulerException{
        SchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
        return schedulerFactoryBean.getScheduler(); 
    }

}

必须要实现的接口，也就是任务的入口，为了后续好加载，我这里写在抽象类，任务启动直接获取所有子类任务


package com.matrix.cloud.service.impl;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author lmc
 * 2018年12月14日
 * 定义抽象任务类AbstractTask，实现Job接口，子类Job实例需实现executeInternal方法。
 * 
 * 子类继承此方法，定时任务启动时可以拿到所有子类的方法，不需要去配置文件拿或者是数据库加定时任务
 */
public abstract class AbstractTask implements  Job{

	/* 
	 */
	 private Logger logger = LoggerFactory.getLogger(AbstractTask.class);

	    protected abstract void executeInternal(JobExecutionContext context);

	    protected String cronExpression;

	    @Override
	    public void execute(JobExecutionContext context) {
	        try {
	            executeInternal(context);
	        } catch (Exception e) {
	            logger.error(e.getMessage(), e);
	            logger.error("job execute failed!");
	        }
	    }

		/* 
		 * 定时任务表达式
		 */
	    public String getCronExpression() {
	        return cronExpression;
	    }

}

下面就是测试的TestDemo

/**
 * 
 */
package com.matrix.cloud.service.impl;

import javax.annotation.PostConstruct;

import org.quartz.JobExecutionContext;
import org.springframework.stereotype.Component;

/**
 * @author lmc
 * 2018年12月14日
 * 第二个定时任务, 继承AbstractTask实现 , 在任务启动的时候会去拿到所有子任务
 * 交给springIOC管理的话， 必须要注入进来,实例对象其实也就是定时任务名
 */
@Component("TestDemo2")
public class TestDemo2 extends AbstractTask {

	/* 
	 *  默认需要quartzManager.start();开启，然后默认是2秒执行一次
	 */
	    @PostConstruct
	    public void init() {
	        this.cronExpression = "0/2 * * * * ? ";
	    }

	@Override
	protected void executeInternal(JobExecutionContext context) {
		System.out.println("第二个任务的开始");
	}

}

下面是测试的类

@RunWith(SpringRunner.class)
@SpringBootTest
public class ElectronicFenceControllerTest {
    private Logger logger = LoggerFactory.getLogger(ElectronicFenceControllerTest.class);
	@Autowired
	RedisTemplate<String, String> redisTemplate;
	@Autowired
    private QuartzManager quartzManager;
    @Autowired
    private TestTask testTask;
	
	   @Test
	    public void tasksTest() throws Exception {
		    quartzManager.start();
	        TimeUnit.SECONDS.sleep(10);
	        logger.info("start update job");
	      //修改任务
	        quartzManager.updateJob("testTask", "0/3 * * * * ? ");
	        logger.info("end update job");
	        TimeUnit.SECONDS.sleep(10);
	        logger.info("start delete job");
	 }
}

主要还是写代码去理解运行原理，然后去实现各种不同场景的业务，

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...