Spring4Springmvcquartz实现多线程动态定时调度

43次阅读

共计 8827 个字符，预计需要花费 23 分钟才能阅读完成。

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

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

  1. 在项目的 pom.xml 文件中引入 quartz 的 jar 包，如下：
 <!-- quartz 定时调度 -->           
<dependency>           
  <groupId>org.quartz-scheduler</groupId>           
  <artifactId>quartz</artifactId>           
  <version>1.8.5</version>           
<dependency>
  1. 定义 quartz 的配置文件 spring-context-quartz.xml：
<?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="top.alterem.job.service.JobService" init-method="loadJob" />  
</beans>      
xml
   

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

​```xml
    classpath*:spring-context-quartz.xml
  1. 定义 job 实体对象
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;}  
      
}
  1. 编写 quartz 的 jobServvice 类：
package top.alterem.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 top.alterem.StringUtils;  
import top.alterem.common.persistence.Page;  
import top.alterem.common.service.CrudService;  
import top.alterem.job.dao.JobDao;  
import top.alterem.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 (!= 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 (!= 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;  
  
}
  1. 编写相关 job 的 Controller、dao、dao.xml 我这边就不写了，其实就是对数据的增删改查操作
  2. 启动项目验证 quartz 是否成功：

    项目启动个控制台：

  ** 任务列表：**

   ** 任务添加和修改界面：**


到此完毕！

正文完
发表至： java
2019-08-05
 0
关于java:java-web项目中BigDecimal返回值的序列化问题解决方案
JAVA volatile 关键字
关于java:类和objectso-easy啦
关于java:毕业后回母校做校招辅助工作认识不少未来巨佬