Java实现自定义任务调度

第一步获取该数据库中可以执行的任务，初始化加载任务

@Component
public class InitMethond implements InitializingBean{
    
    @Autowired
    private SchedulerManager schedulerManager;
    
    @Autowired
    private TaskService taskService;
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("===========定时任务开始啦==========");
        List<WarningTaskSetting> taskList = taskService.getAllListTaskByStatus();//查询数据库中的任务根据你自己业务逻辑去写
        for (WarningTaskSetting task : taskList) {
            try {
                schedulerManager.initTask(task);//初始化加载任务
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }
}

//初始化任务

package com.unicom.tancms.config;

import com.unicom.tancms.pojo.WarningTaskSetting;
import org.apache.commons.lang.StringUtils;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import java.util.LinkedList;
import java.util.List;
import java.util.Set;

/**
 * created by IntelliJ IDEA
 * 任务管理器 调度
 */
@Component
public class SchedulerManager {

        private Logger logger = LoggerFactory.getLogger(getClass());
        @Autowired
        @Qualifier("schedulerFactoryBean")
        private Scheduler scheduler;

        @Autowired
        private List<JobListener> jobListeners;
        @Autowired
        private List<TriggerListener> triggerListeners;

        public void setScheduler(Scheduler scheduler) {
            this.scheduler = scheduler;
        }

        public void setJobListeners(List<JobListener> jobListeners) {
            this.jobListeners = jobListeners;
        }

        public void setTriggerListeners(List<TriggerListener> triggerListeners) {
            this.triggerListeners = triggerListeners;
        }

        @PostConstruct
        public void postConstruct() throws Exception {
            if (this.jobListeners != null && this.jobListeners.size() > 0) {
                if (logger.isInfoEnabled()) {
                    logger.info("Initing quartz scheduler[" + this.scheduler.getSchedulerName() + "] , add Joblistener size ：" + this.jobListeners.size());
                }
                for (JobListener jobListener : this.jobListeners) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Add JobListener : " + jobListener.getName());
                    }
                    //全局注册,所有Job都会起作用
                    this.scheduler.getListenerManager().addJobListener(jobListener);
                }

                if (this.triggerListeners != null && this.triggerListeners.size() > 0) {
                    if (logger.isInfoEnabled()) {
                        logger.info("Initing quartz scheduler[" + this.scheduler.getSchedulerName() + "] , add Triggerlistener size ：" + this.triggerListeners.size());
                    }
                    for (TriggerListener triggerListener : this.triggerListeners) {
                        if (logger.isInfoEnabled()) {
                            logger.info("Add Triggerlistener : " + triggerListener.getName());
                        }
                        this.scheduler.getListenerManager().addTriggerListener(triggerListener);
                    }
                }

            }
        }
        
        //创建定时任务
        public boolean initTask(WarningTaskSetting taskScheduled) throws Exception {
            String jobGroup =String.valueOf(taskScheduled.getTaskId());
            String jobName = String.valueOf(taskScheduled.getTaskId());

            //java获取时间间隔
            long interval=taskScheduled.getTaskInterval();
            
            //触发器表达式;
            String express="";
            
            //时间间隔<60分钟
            if(interval!=0&&interval<60) {
                express="0 0/"+interval+" * * * ?";
            }
            
            //时间间隔>=60分钟按照小时的定时表达式
            if(interval!=0&&interval>=60) {
                //获取有几个小时
                int hour=(int) (interval/60);
                //每天凌晨执行一次任务
                if(hour!=0&&hour<=24) {
                    express="0 0 0/"+hour+" * * ?";
                }
            }
            
            if (StringUtils.isEmpty(jobGroup)) {
                jobGroup = "undefined_job_group";
            }
            
            if (StringUtils.isEmpty(jobName)) {
                jobName = "undefined_job_name_" + String.valueOf(System.currentTimeMillis());
            }
            //为空字符串或者为null情况
            if(StringUtils.isBlank(express)) {
                express=" 0 * */1 * * ?";
            }

            JobDataMap jobDataMap = new JobDataMap();
            taskScheduled.setJobClass(TaskAdapter.class.getSimpleName());
            jobDataMap.put(Constans.QUARTZ_TEST, taskScheduled);

            JobBuilder jobBuilder = null;
            //设置任务调度适配器
            jobBuilder = JobBuilder.newJob(TaskAdapter.class);

            if (jobBuilder != null) {
                JobDetail jobDetail = jobBuilder.withIdentity(jobName, jobGroup).withDescription(taskScheduled.getTaskDescription()).storeDurably(true).usingJobData(jobDataMap).build();
                Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule(express))
                        .withIdentity(jobName, jobGroup).withDescription(taskScheduled.getTaskDescription()).forJob(jobDetail)
                        .usingJobData(jobDataMap).build();
                    JobDetail detail = scheduler.getJobDetail(new JobKey(jobName, jobGroup));
                    if (detail == null) {
                        //添加
                        scheduler.scheduleJob(jobDetail, trigger);
                    } else {
                        //更新
                        scheduler.addJob(jobDetail, true);
                        scheduler.rescheduleJob(new TriggerKey(jobName, jobGroup), trigger);
                    }
                    return true;
                
            }
            return false;
        }
        

       查看当前运行的任务

 

        public List<WarningTaskSetting> getAllJobDetail () {
            List<WarningTaskSetting> result = new LinkedList<WarningTaskSetting>();
            try {
                GroupMatcher<JobKey> matcher = GroupMatcher.jobGroupContains("");
                Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
                    for (JobKey jobKey : jobKeys) {
                        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                        List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                        for (Trigger trigger : triggers) {
                            JobDataMap jobDataMap = trigger.getJobDataMap();
                            WarningTaskSetting taskScheduled = (WarningTaskSetting) jobDataMap.get(Constans.QUARTZ_TEST);

                            //  任务状态 0禁用 1启用 2删除
                            Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                            taskScheduled.setStatus(Integer.parseInt(triggerState.name()));

                            // 最后一次执行时间
                            taskScheduled.setPreviousFireTime(trigger.getPreviousFireTime());
                            // 下次执行时间
                            taskScheduled.setNextFireTime(trigger.getNextFireTime());

                            String jobClass = jobDetail.getJobClass().getSimpleName();
                            taskScheduled.setJobClass(jobClass);
                            result.add(taskScheduled);
                        }
                    }
                } catch (Exception e) {
                    logger.error("Try to load All JobDetail cause error : ", e);
                }
                return result;
            }

        public JobDetail getJobDetailByTriggerName(Trigger trigger) {
            try {
                return this.scheduler.getJobDetail(trigger.getJobKey());
                } catch (Exception e) {
                logger.error(e.getMessage(), e);
            }
            return null;
        }

       
        /**
         * 暂停所有触发器
         * return
         */
        public void pauseAllTrigger() throws Exception {
            try {
                scheduler.standby();
            } catch (SchedulerException e) {
                logger.error("SchedulerManagerException", e);
                throw new SchedulerException(e);
            }
        }

        /**
         * 启动所有触发器
         * return
         */
        public void startAllTrigger() throws Exception {
            try {
                if (scheduler.isInStandbyMode()) {
                    scheduler.start();
                }
            } catch (SchedulerException e) {
                logger.error("SchedulerManagerException", e);
                throw new SchedulerException(e);
            }
        }

        /**
         * 获取触发器key
         * <p>
         * param jobName
         * param jobGroup
         * return
         */
        private static TriggerKey getTriggerKey(String jobName, String jobGroup) throws Exception {
            return TriggerKey.triggerKey(jobName, jobGroup);
        }

        /**
         * 获取表达式触发器
         * <p>
         * param scheduler the scheduler
         * param jobName   the job name
         * param jobGroup  the job group
         * return cron trigger
         */
        private CronTrigger getCronTrigger(Scheduler scheduler, String jobName, String jobGroup) throws Exception {
            try {
                //TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroup);
                TriggerKey triggerKey = getTriggerKey(jobName, jobGroup);
                return (CronTrigger) scheduler.getTrigger(triggerKey);
            } catch (SchedulerException e) {
                logger.error("\"获取定时任务CronTrigger出现异常\"", e);
                throw new Exception(e);
            }
        }

        /**
         * 获取jobKey
         * <p>
         * param jobName  the job name
         * param jobGroup the job group
         * return the job key
         */
        private static JobKey getJobKey(String jobName, String jobGroup) {
            return JobKey.jobKey(jobName, jobGroup);
        }

    }
 

//通过反射获取任务，执行对应的任务

package com.unicom.tancms.config;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.logging.Logger;

import org.quartz.InterruptableJob;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.UnableToInterruptJobException;
import org.slf4j.LoggerFactory;

import com.unicom.SpringContextUtil;
import com.unicom.tancms.pojo.WarningTaskSetting;
import com.unicom.tancms.service.WarningTaskSettingService;

//import com.unicom.SpringContextUtil;
//import com.unicom.tancms.service.WarningTaskSettingService;

/**
 * TaskAdapter 相当于Job,但是这个job的作用是通过反射去适配存在数据库中的各种任务...
 * InterruptableJob 接口 继承了 job接口
 * @author leihz
 * @date 2017-7-5 15:53
 */
public class TaskAdapter implements InterruptableJob{
  
    
    private  static Logger logger = LoggerFactory.getLogger(TaskAdapter.class);
 
    //定时业务逻辑
    @Override
    public void execute(JobExecutionContext context){
        try {
            SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
            //你的业务逻辑---->执行你的任务去完成的事情

            XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX 
        }catch(Exception e) {
            logger.error("调用任务失败",e);
        }
       
    }
}
 

 

创建或者更新任务

    public boolean createOrUpdateTask(WarningTaskSetting taskScheduled) throws Exception {
        String jobGroup = String.valueOf(taskScheduled.getTaskId());
        String jobName = String.valueOf(taskScheduled.getTaskId());

        //java获取时间间隔
        long interval=taskScheduled.getTaskInterval();

        //触发器表达式;
        String express="";

        //时间间隔<60分钟
        if(interval!=0&&interval<60) {
            express="0 0/"+interval+" * * * ?";
        }

        //时间间隔>=60分钟按照小时的定时表达式
        if(interval!=0&&interval>=60) {
            //获取有几个小时
            int hour=(int) (interval/60);
            //每天凌晨执行一次任务
            if(hour!=0&&hour<=24) {
                express="0 0 0/"+hour+" * * ?";
            }
        }

        if (StringUtils.isEmpty(jobGroup)) {
            jobGroup = "undefined_job_group";
        }

        if (StringUtils.isEmpty(jobName)) {
            jobName = "undefined_job_name_" + String.valueOf(System.currentTimeMillis());
        }

        //为空字符串或者为null情况
        if(StringUtils.isBlank(express)) {
            express=" 0 * */1 * * ?";
        }

        JobDataMap jobDataMap = new JobDataMap();
        taskScheduled.setJobClass(TaskAdapter.class.getSimpleName());
        jobDataMap.put(Constans.QUARTZ_TEST, taskScheduled);

        JobBuilder jobBuilder = null;
        //设置任务调度适配器
        jobBuilder = JobBuilder.newJob(TaskAdapter.class);

        if (jobBuilder != null) {
            JobDetail jobDetail = jobBuilder.withIdentity(jobName, jobGroup).withDescription(taskScheduled.getTaskDescription()).storeDurably(true).usingJobData(jobDataMap).build();
            Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule(express))
                    .withIdentity(jobName, jobGroup).withDescription(taskScheduled.getTaskDescription()).forJob(jobDetail)
                    .usingJobData(jobDataMap).build();
                JobDetail detail = scheduler.getJobDetail(new JobKey(jobName, jobGroup));
                if (detail == null) {
                    //添加
                    scheduler.scheduleJob(jobDetail, trigger);
                } else {
                    //更新
                    scheduler.addJob(jobDetail, true);
                    scheduler.rescheduleJob(new TriggerKey(jobName, jobGroup), trigger);
                }
                return true;

        }
        return false;
    }

 

  启动任务（放到你的业务逻辑通常界面有按钮点击调用该方法）

    public void startJob(String taskName,String taskId) throws Exception{

        JobKey jobKey = getJobKey(taskName,taskId);
         TriggerKey triggerKey = getTriggerKey(taskName,taskId);
         scheduler.resumeTrigger(triggerKey);
         scheduler.resumeJob(jobKey);
    }

 

    暂停任务

    public void closeTaskJob(String taskName,String taskId) throws Exception{
         JobKey jobKey = getJobKey(taskName,taskId);

         TriggerKey triggerKey = getTriggerKey(taskName,taskId);
         scheduler.pauseTrigger(triggerKey);// 停止触发器
         scheduler.pauseJob(jobKey);
    }
    private static JobKey getJobKey(String jobName, String jobGroup) {
        return JobKey.jobKey(jobName, jobGroup);
    }

    //获取触发器
    private static TriggerKey getTriggerKey(String jobName, String jobGroup){
        return TriggerKey.triggerKey(jobName, jobGroup);
    }

    删除任务

    public void delJob(String jobName, String jobGroup) throws Exception{
        try {
            JobKey jobKey = getJobKey(jobName,jobGroup);
            TriggerKey triggerKey = getTriggerKey(jobName,jobGroup);
            scheduler.pauseTrigger(triggerKey);// 停止触发器
            scheduler.unscheduleJob(triggerKey);// 移除触发器
            scheduler.deleteJob(jobKey);// 删除任务
        } catch (Exception e) {
            throw new Exception(e);
        }
    }