SpringBoot任务定制

一丶QuartzConfig
package com.xwh.it.accessManage.scheduleTask;

import org.quartz.Scheduler;
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 AccessBusinessJobFactory accessBusinessJobFactory;

@Bean
public SchedulerFactoryBean schedulerFactoryBean() {
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    factory.setJobFactory(accessBusinessJobFactory);
    return factory;
}

@Bean
public Scheduler scheduler() {
    return schedulerFactoryBean().getScheduler();

}

}

二丶AccessBusinessJobFactory
package com.xwh.it.accessManage.scheduleTask;

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
import org.springframework.stereotype.Component;

@Component(“AccessBusinessJobFactory”)
public class AccessBusinessJobFactory extends SpringBeanJobFactory {

@Autowired
private AutowireCapableBeanFactory autowireCapableBeanFactory;

protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
    Object object = super.createJobInstance(bundle);
    autowireCapableBeanFactory.autowireBean(object);
    return object;
}

}

三、BusinessJobService
package com.xwh.it.accessManage.service;

import com.xwh.it.accessManage.vo.AccessCollection;
import org.quartz.JobKey;
import org.quartz.SchedulerException;

public interface BusinessJobService {

void init()throws Exception;

//添加任务
void addJob(AccessCollection job)throws Exception;

//检查一个Job是否存在
boolean isExistJob(JobKey jobKey) throws SchedulerException;

//是否存在Job
boolean isExistJob(String collectionId,String collectionName) throws SchedulerException;

//检查是否是正确的cron表达式
boolean isValidExpression(String cronExpression);

//修改Job Cron时间
boolean modifyJobTriggerTime(String collectionId,String collectionName,String frequency) throws SchedulerException;

//删除Job
boolean removeJob(String collectionId,String collectionName) throws SchedulerException;

//暂停Job
boolean pauseJob(String collectionId,String collectionName) throws SchedulerException;

//恢复Job
boolean resumeJob(String collectionId,String collectionName) throws SchedulerException;

}

四、BusinessJobServiceImpl
package com.xwh.it.accessManage.service.impl;

import com.xwh.it.accessManage.mapper.AccessCollectionMapper;
import com.xwh.it.accessManage.service.BusinessJobService;
import com.xwh.it.accessManage.vo.AccessCollection;
import org.apache.commons.collections.CollectionUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.quartz.impl.triggers.CronTriggerImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.PostConstruct;
import java.util.*;
import java.util.Set;

@Service
public class BusinessJobServiceImpl implements BusinessJobService {

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

@Autowired
private Scheduler scheduler;

@Autowired
private AccessCollectionMapper accessCollectionMapper;

/**
 * 初始化
 * */
@PostConstruct
public void init()throws Exception{
    List<AccessCollection> jobList = accessCollectionMapper.selectScheduleTask();
    for(AccessCollection job : jobList){
        addJob(job);
    }
}

/**
 * 添加定时任务
 * */
@Override
public void addJob(AccessCollection job) throws Exception {

    logger.info("添加一个job");
    JobKey jobKey = new JobKey(job.getCollectionId().toString(),job.getCollectionName());
    logger.info("校验job是否存在");
    boolean flag = isExistJob(jobKey);
    if(flag){
        logger.error("已存在该任务，CollectionId()："+job.getCollectionId().toString()+" getCollectionName:"+job.getCollectionName());
        return;
    }

    boolean checkResult = isValidExpression(job.getFrequency());
    if(!checkResult){
        logger.error("非法的cron表达式，cron："+job.getFrequency());
    }

    Class clazz = Class.forName(job.getBeanClass());

    JobDataMap jobDataMap = new JobDataMap();
    jobDataMap.put("task",job);

    JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(jobKey).usingJobData(jobDataMap).build();
    TriggerKey triggerKey = new TriggerKey(job.getCollectionId().toString(),job.getCollectionName());
    CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerKey).withSchedule(CronScheduleBuilder.cronSchedule(job.getFrequency())).build();
    CronTriggerImpl cronTrigger = (CronTriggerImpl) trigger;
    cronTrigger.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
    scheduler.scheduleJob(jobDetail,cronTrigger);
    scheduler.start();
}

/**
 * 检查一个Job是否存在
 * */
@Override
public boolean isExistJob(JobKey jobKey) throws SchedulerException {
    return  CollectionUtils.isNotEmpty(scheduler.getTriggersOfJob(jobKey));
}

/**
 * 是否存在Job
 * */
@Override
public boolean isExistJob(String collectionId, String collectionName) throws SchedulerException {
    return  isExistJob(new JobKey(collectionId, collectionName));
}

/**
 * 检查是否是正确的cron表达式
 * */
@Override
public boolean isValidExpression(String cronExpression) {
    return cronExpression != null && CronExpression.isValidExpression(cronExpression);
}

/**
 * 修改Job Cron时间
 * */
@Override
public boolean modifyJobTriggerTime(String collectionId, String collectionName, String frequency) throws SchedulerException {
    boolean flag = isValidExpression(frequency);
    if(!flag){
        logger.error("不是一个正确的cron表达式");
        return false;
    }

    Set<TriggerKey> triggerKeys = scheduler.getTriggerKeys(GroupMatcher.triggerGroupStartsWith(collectionId));
    if(CollectionUtils.isEmpty(triggerKeys)){
        logger.error("找不到触发器");
        return false;
    }

    for(TriggerKey triggerKey : triggerKeys){
        scheduler.unscheduleJob(triggerKey);
    }

    TriggerKey triggerKey = new TriggerKey(collectionId,collectionName);

    CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(new TriggerKey(collectionId,collectionName))
            .withSchedule(CronScheduleBuilder.cronSchedule(frequency)).build();

    CronTriggerImpl cronTrigger = (CronTriggerImpl) trigger;
    cronTrigger.setMisfireInstruction(CronTrigger.MISFIRE_INSTRUCTION_DO_NOTHING);
    scheduler.rescheduleJob(triggerKey,cronTrigger);
    return true;
}

/**
 * 删除Job
 * */
@Override
public boolean removeJob(String collectionId, String collectionName) throws SchedulerException {
    JobKey jobKey = new JobKey(collectionId,collectionName);
    return scheduler.deleteJob(jobKey);
}

/**
 * 暂停Job
 */
@Override
public boolean pauseJob(String collectionId, String collectionName) throws SchedulerException {
    JobKey jobKey = new JobKey(collectionId, collectionName);
    scheduler.pauseJob(jobKey);
    return true;
}

/**
 * 恢复Job
 * */
@Override
public boolean resumeJob(String collectionId, String collectionName) throws SchedulerException {
    JobKey jobKey = new JobKey(collectionId, collectionName);
    scheduler.resumeJob(jobKey);
    return true;
}

}