[置顶] Spring4+Springmvc+quartz实现多线程动态定时调度

scheduler定时调度系统是大多行业项目都需要的，传统的spring-job模式，个人感觉已经out了，因为存在很多的问题，特别是定时调度的追加、修改、删除等，需要修改xml，xml的配置生效无非是热部署灰度发布方案或者直接停止、重启服务器，完全不能做到自动启动、修复方式。

提醒：可以对应用进行集群部署，在对定时调度配置时可以使用集群方式或者单边配置应用方式，今天讲解的是使用spring4+scheduler实现定时调度，闲话少说，直接把步骤记录下来：

 

1. 在项目的pom.xml文件中引入quartz的jar包，如下：

Java代码  


             <!-- quartz定时调度 -->  

lt;dependency>  

<groupId>org.quartz-scheduler</groupId>  

<artifactId>quartz</artifactId>  

<version>1.8.5</version>  

lt;/dependency>  

 

2. 定义quartz的配置文件spring-context-quartz.xml：

Java代码  


<?xml version="1.0" encoding="UTF-8"?>  

<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  

    xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="  

        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  

        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"  

    default-lazy-init="false">  

    <!-- 调度器 -->  

    <bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">   

       <!-- 通过applicationContextSchedulerContextKey属性配置spring上下文 -->      

        <property name="applicationContextSchedulerContextKey" value="applicationContext" />  

    </bean>    

    <!--加载数据库任务-->  

    <bean id="jobService" class="com.ml.honghu.job.service.JobService" init-method="loadJob" />  

</beans>  

  

3.  在项目的web.xml文件中引入spring-context-quartz.xml配置文件

Java代码  


classpath*:spring-context-quartz.xml  

 

4. 定义job实体对象

Java代码  


public class Job{  

      

    private static final long serialVersionUID = 1L;  

      

    /** 

     * 任务执行周期cron表达式 

     */  

    public static int EXECYCLE_CRON = 2;  

    /** 

     * 任务执行周期自定义 

     */  

    public static int EXECYCLE_DEFINE = 1;  

    /** 

     * 执行周期-分钟 

     */  

    public static int EXECYCLE_MINUTE = 1;  

    /** 

     * 执行周期-小时 

     */  

    public static int EXECYCLE_HOUR = 2;  

    /** 

     * 执行周期-日 

     */  

    public static int EXECYCLE_DAY = 3;  

    /** 

     * 执行周期-月 

     */  

    public static int EXECYCLE_WEEK = 4;  

    /** 

     * 执行周期-月 

     */  

    public static int EXECYCLE_MONTH = 5;  

      

  

    private String jobType;     // 任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)  

    private String jobName;     // 任务名称  

    private String jobClass;        // 任务类  

    private String execycle;        // 执行周期分类(1非表达式 2 cron表达式)  

    private String dayOfMonth;      // 每月的哪天  

    private String dayOfWeek;       // 周几  

    private String hour;        // 小时  

    private String minute;      // 分钟  

    private String intervalHour;        // 间隔小时  

    private String intervalMinute;      // 间隔分钟  

    private String jobIntervalUnit;     // 1分钟、2小时、3日、4周、5月  

    private String cronExpression;      // 规则表达式  

    private String isEnable;        // 是否启用  

      

    public Job() {  

        super();  

    }  

  

    public Job(String id){  

        super(id);  

    }  

  

    @Length(min=1, max=1, message="任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)长度必须介于 1 和 1 之间")  

    public String getJobType() {  

        return jobType;  

    }  

  

    public void setJobType(String jobType) {  

        this.jobType = jobType;  

    }  

      

    @Length(min=1, max=255, message="任务名称长度必须介于 1 和 255 之间")  

    public String getJobName() {  

        return jobName;  

    }  

  

    public void setJobName(String jobName) {  

        this.jobName = jobName;  

    }  

      

    @Length(min=1, max=255, message="任务类长度必须介于 1 和 255 之间")  

    public String getJobClass() {  

        return jobClass;  

    }  

  

    public void setJobClass(String jobClass) {  

        this.jobClass = jobClass;  

    }  

      

    @Length(min=1, max=1, message="执行周期分类(1非表达式 2 cron表达式)长度必须介于 1 和 1 之间")  

    public String getExecycle() {  

        return execycle;  

    }  

  

    public void setExecycle(String execycle) {  

        this.execycle = execycle;  

    }  

      

    @Length(min=0, max=11, message="每月的哪天长度必须介于 0 和 11 之间")  

    public String getDayOfMonth() {  

        return dayOfMonth;  

    }  

  

    public void setDayOfMonth(String dayOfMonth) {  

        this.dayOfMonth = dayOfMonth;  

    }  

      

    @Length(min=0, max=1, message="周几长度必须介于 0 和 1 之间")  

    public String getDayOfWeek() {  

        return dayOfWeek;  

    }  

  

    public void setDayOfWeek(String dayOfWeek) {  

        this.dayOfWeek = dayOfWeek;  

    }  

      

    @Length(min=0, max=11, message="小时长度必须介于 0 和 11 之间")  

    public String getHour() {  

        return hour;  

    }  

  

    public void setHour(String hour) {  

        this.hour = hour;  

    }  

      

    @Length(min=0, max=11, message="分钟长度必须介于 0 和 11 之间")  

    public String getMinute() {  

        return minute;  

    }  

  

    public void setMinute(String minute) {  

        this.minute = minute;  

    }  

      

    @Length(min=0, max=11, message="间隔小时长度必须介于 0 和 11 之间")  

    public String getIntervalHour() {  

        return intervalHour;  

    }  

  

    public void setIntervalHour(String intervalHour) {  

        this.intervalHour = intervalHour;  

    }  

      

    @Length(min=0, max=11, message="间隔分钟长度必须介于 0 和 11 之间")  

    public String getIntervalMinute() {  

        return intervalMinute;  

    }  

  

    public void setIntervalMinute(String intervalMinute) {  

        this.intervalMinute = intervalMinute;  

    }  

      

    @Length(min=0, max=1, message="1分钟、2小时、3日、4周、5月长度必须介于 0 和 1 之间")  

    public String getJobIntervalUnit() {  

        return jobIntervalUnit;  

    }  

  

    public void setJobIntervalUnit(String jobIntervalUnit) {  

        this.jobIntervalUnit = jobIntervalUnit;  

    }  

      

    @Length(min=0, max=255, message="规则表达式长度必须介于 0 和 255 之间")  

    public String getCronExpression() {  

        return cronExpression;  

    }  

  

    public void setCronExpression(String cronExpression) {  

        this.cronExpression = cronExpression;  

    }  

      

    @Length(min=1, max=1, message="是否启用长度必须介于 1 和 1 之间")  

    public String getIsEnable() {  

        return isEnable;  

    }  

  

    public void setIsEnable(String isEnable) {  

        this.isEnable = isEnable;  

    }  

      

}  

 

5. 编写quartz的jobServvice类：

Java代码  


package com.ml.honghu.job.service;  

  

import java.text.ParseException;  

import java.util.List;  

import java.util.UUID;  

  

import org.quartz.CronTrigger;  

import org.quartz.JobDetail;  

import org.quartz.Scheduler;  

import org.quartz.SchedulerException;  

import org.slf4j.Logger;  

import org.slf4j.LoggerFactory;  

import org.springframework.beans.factory.annotation.Autowired;  

import org.springframework.stereotype.Service;  

import org.springframework.transaction.annotation.Transactional;  

  

import com.ml.honghu.StringUtils;  

import com.ml.honghu.common.persistence.Page;  

import com.ml.honghu.common.service.CrudService;  

import com.ml.honghu.job.dao.JobDao;  

import com.ml.honghu.job.entity.Job;  

  

/** 

 * 定时调度任务Service 

 *  

 * @author honghu 

 */  

@Service  

@Transactional(readOnly = true)  

public class JobService extends CrudService<JobDao, Job> {  

      

    @Autowired  

    private JobDao jobDao;  

      

    private Logger logger = LoggerFactory.getLogger(getClass());  

  

    public Job get(String id) {  

        return super.get(id);  

    }  

  

    public List<Job> findList(Job job) {  

        return super.findList(job);  

    }  

  

    public Page<Job> findPage(Page<Job> page, Job job) {  

        return super.findPage(page, job);  

    }  

  

    @Transactional(readOnly = false)  

    public void save(Job job) {  

        super.save(job);  

        // 启用则启动任务  

        if (StringUtils.equals("1", job.getIsEnable())) {  

            startTask(job, job.getId());  

        }  

    }  

      

    @Transactional(readOnly = false)  

    public void update(Job job) {  

        //结束定时调度  

        endTask(job.getId());  

          

        job.preUpdate();  

        jobDao.update(job);  

          

        // 启用则启动任务  

        if (StringUtils.equals("1", job.getIsEnable())) {  

            startTask(job, job.getId());  

        }  

    }  

  

    @Transactional(readOnly = false)  

    public void delete(Job job) {  

        //结束任务  

        endTask(job.getId());  

          

        super.delete(job);  

    }  

  

    /** 

     * 系统初始加载任务 

     */  

    public void loadJob() throws Exception {  

        List<Job> jobList = this.findList(new Job());  

        if (null != jobList && jobList.size() > 0) {  

            for (int i = 0; i < jobList.size(); i++) {  

                Job job = jobList.get(i);  

                // 任务开启状态 执行任务调度  

                if (StringUtils.equals("1", job.getIsEnable())) {  

                    try {  

                        JobDetail jobDetail = new JobDetail();  

                        // 设置任务名称  

                        if (StringUtils.isNotBlank(job.getId())) {  

                            jobDetail.setName(job.getId());  

                        } else {  

                            UUID uuid = UUID.randomUUID();  

                            jobDetail.setName(uuid.toString());  

                            job.setId(uuid.toString());  

                        }  

                        jobDetail.setGroup(Scheduler.DEFAULT_GROUP);  

                        // 设置任务执行类  

                        jobDetail.setJobClass(getClassByTask(job.getJobClass()));  

                        // 添加任务参数  

                        CronTrigger cronTrigger = new CronTrigger("cron_" + i, Scheduler.DEFAULT_GROUP,  

                                jobDetail.getName(), Scheduler.DEFAULT_GROUP);  

  

                        cronTrigger.setCronExpression(getCronExpressionFromDB(job.getId()));  

                        // 调度任务  

                        scheduler.scheduleJob(jobDetail, cronTrigger);  

                    } catch (SchedulerException e) {  

                        logger.error("JobService SchedulerException", e);  

                    } catch (ClassNotFoundException e) {  

                        logger.error("JobService ClassNotFoundException", e);  

                    } catch (Exception e) {  

                        logger.error("JobService Exception", e);  

                    }  

                }  

            }  

        }  

    }  

  

    /** 

     *  

     * @param taskClassName 

     *            任务执行类名 

     * @return 

     * @throws ClassNotFoundException 

     */  

    @SuppressWarnings("rawtypes")  

    private Class getClassByTask(String taskClassName) throws ClassNotFoundException {  

        return Class.forName(taskClassName);  

    }  

  

    public String getCronExpressionFromDB(String id) throws Exception {  

        // 设置任务规则  

        Job job = this.get(id);  

        if (null != job) {  

            if (Job.EXECYCLE_CRON == Integer.parseInt(job.getExecycle())) {  

                return job.getCronExpression();  

            } else {  

                Integer execycle = Integer.parseInt(job.getJobIntervalUnit());  

                String excep = "";  

                if (execycle.equals(Job.EXECYCLE_MONTH)) {  

                    excep = "0  " + job.getMinute() + " " + job.getHour() + " " + job.getDayOfMonth() + " * ?";  

                } else if (execycle.equals(Job.EXECYCLE_WEEK)) {  

                    excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " ? " + " * " + job.getDayOfWeek();  

                } else if (execycle.equals(Job.EXECYCLE_DAY)) {  

                    excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " * * ?";  

                } else if (execycle.equals(Job.EXECYCLE_HOUR)) {  

                    excep = "0 0 */" + job.getIntervalHour() + " * * ?";  

                } else if (execycle.equals(Job.EXECYCLE_MINUTE)) {  

                    excep = "0  */" + job.getIntervalMinute() + " * * * ?";  

                }  

                return excep;  

            }  

        }  

        return "";  

    }  

  

    private void startTask(Job job, String id) {  

        try {  

            String cronExpress = getCronExpressionFromDB(id);  

            if (StringUtils.isNotEmpty(cronExpress) && cronExpress.indexOf("null") == -1) {  

                JobDetail jobDetail = new JobDetail();  

                jobDetail.setName(id);  

                jobDetail.setGroup(Scheduler.DEFAULT_GROUP);  

                jobDetail.setJobClass(getClassByTask(job.getJobClass()));  

                CronTrigger cronTrigger = new CronTrigger("cron_" + id, Scheduler.DEFAULT_GROUP, jobDetail.getName(),  

                        Scheduler.DEFAULT_GROUP);  

                cronTrigger.setCronExpression(cronExpress);  

                scheduler.scheduleJob(jobDetail, cronTrigger);  

            }  

        } catch (ParseException e) {  

            logger.error("JobService ParseException", e);  

        } catch (Exception e) {  

            logger.error("JobService Exception", e);  

        }  

    }  

      

    private void endTask(String id) {  

        try {  

            scheduler.deleteJob(id, Scheduler.DEFAULT_GROUP);  

        } catch (SchedulerException e) {  

            logger.error("JobService endTask", e);  

        }  

    }  

  

    @Autowired  

    private Scheduler scheduler;  

  

}  

 

6. 编写相关job的Controller、dao、dao.xml我这边就不写了，其实就是对数据的增删改查操作

 

7. 启动项目验证quartz是否成功：

    项目启动个控制台：



      任务列表：



       任务添加和修改界面：



 愿意了解框架技术或者源码的朋友直接求求交流分享技术：2042849237

分布式的一些解决方案，有愿意了解的朋友可以找我们团队探讨

更多详细源码参考来源：http://minglisoft.cn/technology