Spring4+Springmvc+quartz实现多线程动态定时调度

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

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

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

在项目的pom.xml文件中引入quartz的jar包,如下:


org.quartz-scheduler
quartz
1.8.5

定义quartz的配置文件spring-context-quartz.xml:
<?xml version="1.0" encoding="UTF-8"?>

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


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

`xml

classpath*:spring-context-quartz.xml 

定义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;  
}  
  

}
编写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 {

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

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

启动项目验证quartz是否成功:

项目启动个控制台:

点击查看原始大小图片
任务列表:
点击查看原始大小图片
任务添加和修改界面:
点击查看原始大小图片
到此完毕!
原文地址https://www.cnblogs.com/alterem/p/11301235.html

相关文章
|
3月前
|
Java Spring
spring多线程实现+合理设置最大线程数和核心线程数
本文介绍了手动设置线程池时的最大线程数和核心线程数配置方法,建议根据CPU核数及程序类型(CPU密集型或IO密集型)来合理设定。对于IO密集型,核心线程数设为CPU核数的两倍;CPU密集型则设为CPU核数加一。此外,还讨论了`maxPoolSize`、`keepAliveTime`、`allowCoreThreadTimeout`和`queueCapacity`等参数的设置策略,以确保线程池高效稳定运行。
298 10
spring多线程实现+合理设置最大线程数和核心线程数
|
2月前
|
前端开发 Java 应用服务中间件
【Spring】Spring MVC的项目准备和连接建立
【Spring】Spring MVC的项目准备和连接建立
59 2
|
3月前
|
缓存 前端开发 Java
【Java面试题汇总】Spring,SpringBoot,SpringMVC,Mybatis,JavaWeb篇(2023版)
Soring Boot的起步依赖、启动流程、自动装配、常用的注解、Spring MVC的执行流程、对MVC的理解、RestFull风格、为什么service层要写接口、MyBatis的缓存机制、$和#有什么区别、resultType和resultMap区别、cookie和session的区别是什么?session的工作原理
【Java面试题汇总】Spring,SpringBoot,SpringMVC,Mybatis,JavaWeb篇(2023版)
|
2月前
|
XML 前端开发 Java
Spring,SpringBoot和SpringMVC的关系以及区别 —— 超准确,可当面试题!!!也可供零基础学习
本文阐述了Spring、Spring Boot和Spring MVC的关系与区别,指出Spring是一个轻量级、一站式、模块化的应用程序开发框架,Spring MVC是Spring的一个子框架,专注于Web应用和网络接口开发,而Spring Boot则是对Spring的封装,用于简化Spring应用的开发。
142 0
Spring,SpringBoot和SpringMVC的关系以及区别 —— 超准确,可当面试题!!!也可供零基础学习
|
4月前
|
Java 数据库连接 Spring
后端框架入门超详细 三部曲 Spring 、SpringMVC、Mybatis、SSM框架整合案例 【爆肝整理五万字】
文章是关于Spring、SpringMVC、Mybatis三个后端框架的超详细入门教程,包括基础知识讲解、代码案例及SSM框架整合的实战应用,旨在帮助读者全面理解并掌握这些框架的使用。
后端框架入门超详细 三部曲 Spring 、SpringMVC、Mybatis、SSM框架整合案例 【爆肝整理五万字】
|
5月前
|
Java Spring
spring boot 中默认最大线程连接数,线程池数配置查看
spring boot 中默认最大线程连接数,线程池数配置查看
371 4
|
5月前
|
Java Spring 容器
Spring boot 自定义ThreadPoolTaskExecutor 线程池并进行异步操作
Spring boot 自定义ThreadPoolTaskExecutor 线程池并进行异步操作
243 3
|
4月前
|
安全 Java C#
Spring创建的单例对象,存在线程安全问题吗?
Spring框架提供了多种Bean作用域,包括单例(Singleton)、原型(Prototype)、请求(Request)、会话(Session)、全局会话(GlobalSession)等。单例是默认作用域,保证每个Spring容器中只有一个Bean实例;原型作用域则每次请求都会创建一个新的Bean实例;请求和会话作用域分别与HTTP请求和会话绑定,在Web应用中有效。 单例Bean在多线程环境中可能面临线程安全问题,Spring容器虽然确保Bean的创建过程是线程安全的,但Bean的使用安全性需开发者自行保证。保持Bean无状态是最简单的线程安全策略;
|
4月前
|
前端开发 Java Spring
Java 新手入门:Spring Boot 轻松整合 Spring 和 Spring MVC!
Java 新手入门:Spring Boot 轻松整合 Spring 和 Spring MVC!
67 0
|
5月前
|
安全 Java 数据库连接
Spring Boot 优雅关机时异步线程安全优化
Spring Boot 优雅关机时异步线程安全优化
125 1