`
Anita558
  • 浏览: 12706 次
社区版块
存档分类
最新评论

Spring4+Springmvc+quartz实现多线程动态

 
阅读更多

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

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

 

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

Java代码  收藏代码
  1.              <!-- quartz定时调度 -->  
  2. lt;dependency>  
  3. <groupId>org.quartz-scheduler</groupId>  
  4. <artifactId>quartz</artifactId>  
  5. <version>1.8.5</version>  
  6. lt;/dependency>  

 

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

Java代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="  
  4.         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd  
  5.         http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd"  
  6.     default-lazy-init="false">  
  7.     <!-- 调度器 -->  
  8.     <bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">   
  9.        <!-- 通过applicationContextSchedulerContextKey属性配置spring上下文 -->      
  10.         <property name="applicationContextSchedulerContextKey" value="applicationContext" />  
  11.     </bean>    
  12.     <!--加载数据库任务-->  
  13.     <bean id="jobService" class="com.ml.honghu.job.service.JobService" init-method="loadJob" />  
  14. </beans>  

  

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

Java代码  收藏代码
  1. classpath*:spring-context-quartz.xml  

 

4. 定义job实体对象

Java代码  收藏代码
  1. public class Job{  
  2.       
  3.     private static final long serialVersionUID = 1L;  
  4.       
  5.     /** 
  6.      * 任务执行周期cron表达式 
  7.      */  
  8.     public static int EXECYCLE_CRON = 2;  
  9.     /** 
  10.      * 任务执行周期自定义 
  11.      */  
  12.     public static int EXECYCLE_DEFINE = 1;  
  13.     /** 
  14.      * 执行周期-分钟 
  15.      */  
  16.     public static int EXECYCLE_MINUTE = 1;  
  17.     /** 
  18.      * 执行周期-小时 
  19.      */  
  20.     public static int EXECYCLE_HOUR = 2;  
  21.     /** 
  22.      * 执行周期-日 
  23.      */  
  24.     public static int EXECYCLE_DAY = 3;  
  25.     /** 
  26.      * 执行周期-月 
  27.      */  
  28.     public static int EXECYCLE_WEEK = 4;  
  29.     /** 
  30.      * 执行周期-月 
  31.      */  
  32.     public static int EXECYCLE_MONTH = 5;  
  33.       
  34.   
  35.     private String jobType;     // 任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)  
  36.     private String jobName;     // 任务名称  
  37.     private String jobClass;        // 任务类  
  38.     private String execycle;        // 执行周期分类(1非表达式 2 cron表达式)  
  39.     private String dayOfMonth;      // 每月的哪天  
  40.     private String dayOfWeek;       // 周几  
  41.     private String hour;        // 小时  
  42.     private String minute;      // 分钟  
  43.     private String intervalHour;        // 间隔小时  
  44.     private String intervalMinute;      // 间隔分钟  
  45.     private String jobIntervalUnit;     // 1分钟、2小时、3日、4周、5月  
  46.     private String cronExpression;      // 规则表达式  
  47.     private String isEnable;        // 是否启用  
  48.       
  49.     public Job() {  
  50.         super();  
  51.     }  
  52.   
  53.     public Job(String id){  
  54.         super(id);  
  55.     }  
  56.   
  57.     @Length(min=1, max=1, message="任务类型(1首页静态化、2栏目页静态化、3内容页静态化、4采集、5分发)长度必须介于 1 和 1 之间")  
  58.     public String getJobType() {  
  59.         return jobType;  
  60.     }  
  61.   
  62.     public void setJobType(String jobType) {  
  63.         this.jobType = jobType;  
  64.     }  
  65.       
  66.     @Length(min=1, max=255, message="任务名称长度必须介于 1 和 255 之间")  
  67.     public String getJobName() {  
  68.         return jobName;  
  69.     }  
  70.   
  71.     public void setJobName(String jobName) {  
  72.         this.jobName = jobName;  
  73.     }  
  74.       
  75.     @Length(min=1, max=255, message="任务类长度必须介于 1 和 255 之间")  
  76.     public String getJobClass() {  
  77.         return jobClass;  
  78.     }  
  79.   
  80.     public void setJobClass(String jobClass) {  
  81.         this.jobClass = jobClass;  
  82.     }  
  83.       
  84.     @Length(min=1, max=1, message="执行周期分类(1非表达式 2 cron表达式)长度必须介于 1 和 1 之间")  
  85.     public String getExecycle() {  
  86.         return execycle;  
  87.     }  
  88.   
  89.     public void setExecycle(String execycle) {  
  90.         this.execycle = execycle;  
  91.     }  
  92.       
  93.     @Length(min=0, max=11, message="每月的哪天长度必须介于 0 和 11 之间")  
  94.     public String getDayOfMonth() {  
  95.         return dayOfMonth;  
  96.     }  
  97.   
  98.     public void setDayOfMonth(String dayOfMonth) {  
  99.         this.dayOfMonth = dayOfMonth;  
  100.     }  
  101.       
  102.     @Length(min=0, max=1, message="周几长度必须介于 0 和 1 之间")  
  103.     public String getDayOfWeek() {  
  104.         return dayOfWeek;  
  105.     }  
  106.   
  107.     public void setDayOfWeek(String dayOfWeek) {  
  108.         this.dayOfWeek = dayOfWeek;  
  109.     }  
  110.       
  111.     @Length(min=0, max=11, message="小时长度必须介于 0 和 11 之间")  
  112.     public String getHour() {  
  113.         return hour;  
  114.     }  
  115.   
  116.     public void setHour(String hour) {  
  117.         this.hour = hour;  
  118.     }  
  119.       
  120.     @Length(min=0, max=11, message="分钟长度必须介于 0 和 11 之间")  
  121.     public String getMinute() {  
  122.         return minute;  
  123.     }  
  124.   
  125.     public void setMinute(String minute) {  
  126.         this.minute = minute;  
  127.     }  
  128.       
  129.     @Length(min=0, max=11, message="间隔小时长度必须介于 0 和 11 之间")  
  130.     public String getIntervalHour() {  
  131.         return intervalHour;  
  132.     }  
  133.   
  134.     public void setIntervalHour(String intervalHour) {  
  135.         this.intervalHour = intervalHour;  
  136.     }  
  137.       
  138.     @Length(min=0, max=11, message="间隔分钟长度必须介于 0 和 11 之间")  
  139.     public String getIntervalMinute() {  
  140.         return intervalMinute;  
  141.     }  
  142.   
  143.     public void setIntervalMinute(String intervalMinute) {  
  144.         this.intervalMinute = intervalMinute;  
  145.     }  
  146.       
  147.     @Length(min=0, max=1, message="1分钟、2小时、3日、4周、5月长度必须介于 0 和 1 之间")  
  148.     public String getJobIntervalUnit() {  
  149.         return jobIntervalUnit;  
  150.     }  
  151.   
  152.     public void setJobIntervalUnit(String jobIntervalUnit) {  
  153.         this.jobIntervalUnit = jobIntervalUnit;  
  154.     }  
  155.       
  156.     @Length(min=0, max=255, message="规则表达式长度必须介于 0 和 255 之间")  
  157.     public String getCronExpression() {  
  158.         return cronExpression;  
  159.     }  
  160.   
  161.     public void setCronExpression(String cronExpression) {  
  162.         this.cronExpression = cronExpression;  
  163.     }  
  164.       
  165.     @Length(min=1, max=1, message="是否启用长度必须介于 1 和 1 之间")  
  166.     public String getIsEnable() {  
  167.         return isEnable;  
  168.     }  
  169.   
  170.     public void setIsEnable(String isEnable) {  
  171.         this.isEnable = isEnable;  
  172.     }  
  173.       
  174. }  

 

5. 编写quartz的jobServvice类：（企业架构源码可以加求球：三五三六二四七二五九）

Java代码  收藏代码
  1. package com.ml.honghu.job.service;  
  2.   
  3. import java.text.ParseException;  
  4. import java.util.List;  
  5. import java.util.UUID;  
  6.   
  7. import org.quartz.CronTrigger;  
  8. import org.quartz.JobDetail;  
  9. import org.quartz.Scheduler;  
  10. import org.quartz.SchedulerException;  
  11. import org.slf4j.Logger;  
  12. import org.slf4j.LoggerFactory;  
  13. import org.springframework.beans.factory.annotation.Autowired;  
  14. import org.springframework.stereotype.Service;  
  15. import org.springframework.transaction.annotation.Transactional;  
  16.   
  17. import com.ml.honghu.StringUtils;  
  18. import com.ml.honghu.common.persistence.Page;  
  19. import com.ml.honghu.common.service.CrudService;  
  20. import com.ml.honghu.job.dao.JobDao;  
  21. import com.ml.honghu.job.entity.Job;  
  22.   
  23. /** 
  24.  * 定时调度任务Service 
  25.  *  
  26.  * @author honghu 
  27.  */  
  28. @Service  
  29. @Transactional(readOnly = true)  
  30. public class JobService extends CrudService<JobDao, Job> {  
  31.       
  32.     @Autowired  
  33.     private JobDao jobDao;  
  34.       
  35.     private Logger logger = LoggerFactory.getLogger(getClass());  
  36.   
  37.     public Job get(String id) {  
  38.         return super.get(id);  
  39.     }  
  40.   
  41.     public List<Job> findList(Job job) {  
  42.         return super.findList(job);  
  43.     }  
  44.   
  45.     public Page<Job> findPage(Page<Job> page, Job job) {  
  46.         return super.findPage(page, job);  
  47.     }  
  48.   
  49.     @Transactional(readOnly = false)  
  50.     public void save(Job job) {  
  51.         super.save(job);  
  52.         // 启用则启动任务  
  53.         if (StringUtils.equals("1", job.getIsEnable())) {  
  54.             startTask(job, job.getId());  
  55.         }  
  56.     }  
  57.       
  58.     @Transactional(readOnly = false)  
  59.     public void update(Job job) {  
  60.         //结束定时调度  
  61.         endTask(job.getId());  
  62.           
  63.         job.preUpdate();  
  64.         jobDao.update(job);  
  65.           
  66.         // 启用则启动任务  
  67.         if (StringUtils.equals("1", job.getIsEnable())) {  
  68.             startTask(job, job.getId());  
  69.         }  
  70.     }  
  71.   
  72.     @Transactional(readOnly = false)  
  73.     public void delete(Job job) {  
  74.         //结束任务  
  75.         endTask(job.getId());  
  76.           
  77.         super.delete(job);  
  78.     }  
  79.   
  80.     /** 
  81.      * 系统初始加载任务 
  82.      */  
  83.     public void loadJob() throws Exception {  
  84.         List<Job> jobList = this.findList(new Job());  
  85.         if (null != jobList && jobList.size() > 0) {  
  86.             for (int i = 0; i < jobList.size(); i++) {  
  87.                 Job job = jobList.get(i);  
  88.                 // 任务开启状态 执行任务调度  
  89.                 if (StringUtils.equals("1", job.getIsEnable())) {  
  90.                     try {  
  91.                         JobDetail jobDetail = new JobDetail();  
  92.                         // 设置任务名称  
  93.                         if (StringUtils.isNotBlank(job.getId())) {  
  94.                             jobDetail.setName(job.getId());  
  95.                         } else {  
  96.                             UUID uuid = UUID.randomUUID();  
  97.                             jobDetail.setName(uuid.toString());  
  98.                             job.setId(uuid.toString());  
  99.                         }  
  100.                         jobDetail.setGroup(Scheduler.DEFAULT_GROUP);  
  101.                         // 设置任务执行类  
  102.                         jobDetail.setJobClass(getClassByTask(job.getJobClass()));  
  103.                         // 添加任务参数  
  104.                         CronTrigger cronTrigger = new CronTrigger("cron_" + i, Scheduler.DEFAULT_GROUP,  
  105.                                 jobDetail.getName(), Scheduler.DEFAULT_GROUP);  
  106.   
  107.                         cronTrigger.setCronExpression(getCronExpressionFromDB(job.getId()));  
  108.                         // 调度任务  
  109.                         scheduler.scheduleJob(jobDetail, cronTrigger);  
  110.                     } catch (SchedulerException e) {  
  111.                         logger.error("JobService SchedulerException", e);  
  112.                     } catch (ClassNotFoundException e) {  
  113.                         logger.error("JobService ClassNotFoundException", e);  
  114.                     } catch (Exception e) {  
  115.                         logger.error("JobService Exception", e);  
  116.                     }  
  117.                 }  
  118.             }  
  119.         }  
  120.     }  
  121.   
  122.     /** 
  123.      *  
  124.      * @param taskClassName 
  125.      *            任务执行类名 
  126.      * @return 
  127.      * @throws ClassNotFoundException 
  128.      */  
  129.     @SuppressWarnings("rawtypes")  
  130.     private Class getClassByTask(String taskClassName) throws ClassNotFoundException {  
  131.         return Class.forName(taskClassName);  
  132.     }  
  133.   
  134.     public String getCronExpressionFromDB(String id) throws Exception {  
  135.         // 设置任务规则  
  136.         Job job = this.get(id);  
  137.         if (null != job) {  
  138.             if (Job.EXECYCLE_CRON == Integer.parseInt(job.getExecycle())) {  
  139.                 return job.getCronExpression();  
  140.             } else {  
  141.                 Integer execycle = Integer.parseInt(job.getJobIntervalUnit());  
  142.                 String excep = "";  
  143.                 if (execycle.equals(Job.EXECYCLE_MONTH)) {  
  144.                     excep = "0  " + job.getMinute() + " " + job.getHour() + " " + job.getDayOfMonth() + " * ?";  
  145.                 } else if (execycle.equals(Job.EXECYCLE_WEEK)) {  
  146.                     excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " ? " + " * " + job.getDayOfWeek();  
  147.                 } else if (execycle.equals(Job.EXECYCLE_DAY)) {  
  148.                     excep = "0  " + job.getMinute() + " " + job.getHour() + " " + " * * ?";  
  149.                 } else if (execycle.equals(Job.EXECYCLE_HOUR)) {  
  150.                     excep = "0 0 */" + job.getIntervalHour() + " * * ?";  
  151.                 } else if (execycle.equals(Job.EXECYCLE_MINUTE)) {  
  152.                     excep = "0  */" + job.getIntervalMinute() + " * * * ?";  
  153.                 }  
  154.                 return excep;  
  155.             }  
  156.         }  
  157.         return "";  
  158.     }  
  159.   
  160.     private void startTask(Job job, String id) {  
  161.         try {  
  162.             String cronExpress = getCronExpressionFromDB(id);  
  163.             if (StringUtils.isNotEmpty(cronExpress) && cronExpress.indexOf("null") == -1) {  
  164.                 JobDetail jobDetail = new JobDetail();  
  165.                 jobDetail.setName(id);  
  166.                 jobDetail.setGroup(Scheduler.DEFAULT_GROUP);  
  167.                 jobDetail.setJobClass(getClassByTask(job.getJobClass()));  
  168.                 CronTrigger cronTrigger = new CronTrigger("cron_" + id, Scheduler.DEFAULT_GROUP, jobDetail.getName(),  
  169.                         Scheduler.DEFAULT_GROUP);  
  170.                 cronTrigger.setCronExpression(cronExpress);  
  171.                 scheduler.scheduleJob(jobDetail, cronTrigger);  
  172.             }  
  173.         } catch (ParseException e) {  
  174.             logger.error("JobService ParseException", e);  
  175.         } catch (Exception e) {  
  176.             logger.error("JobService Exception", e);  
  177.         }  
  178.     }  
  179.       
  180.     private void endTask(String id) {  
  181.         try {  
  182.             scheduler.deleteJob(id, Scheduler.DEFAULT_GROUP);  
  183.         } catch (SchedulerException e) {  
  184.             logger.error("JobService endTask", e);  
  185.         }  
  186.     }  
  187.   
  188.     @Autowired  
  189.     private Scheduler scheduler;  
  190.   
  191. }  
分享到：
| 云架构代码结构构建
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Lucene4.8+IKAnalyzer+SpringMVC4+Jsoup+Quartz示例

    本示例项目"Lucene4.8+IKAnalyzer+SpringMVC4+Jsoup+Quartz"为我们提供了一个强大的智能搜索引擎搭建框架，它整合了多项关键技术，旨在帮助开发者高效地实现网页抓取、内容分析和定时任务等功能。 首先，Lucene是...

    SSM框架（spring+springMVC +mybatis） +任务调度管理

    在实际项目中，任务调度管理往往涉及到多线程和并发控制，确保任务的有序执行和资源的合理分配。开发者还需要关注异常处理，确保即使在任务执行过程中出现错误，系统也能保持稳定运行。 至于压缩包中的"Scientific...

    ssm-springMVC-整合Quartz（解决了无法注入service问题）-项目示例

    SSM（Spring、SpringMVC、MyBatis）框架是Java Web开发中常见的技术栈，而Quartz是一款强大的任务调度库，常用于实现定时任务。本文将深入探讨如何在SSM项目中整合Quartz，并解决服务无法注入的问题。 首先，我们要...

    SpringMvc自动任务调度之task实现项目源码

    但是Quartz有线程和线程管理以及集群等高级特性，所以大家可以自行选择了。不过一般情况下，觉得SpringTask足够了。 Spring Task提供两种方式进行配置，注解和配置文件。使用注解虽然简单，不用配置xml，但是相对于...

    java多线程实现下载图片并压缩

    本文旨在详细探讨Java多线程在实现下载图片并进行压缩的具体实现方法，并提供了SpringMVC定时任务、FTP环境搭建的参考，旨在为有此类需求的开发者提供实用的参考。 首先，需要创建一个SpringMVC定时任务，这允许...

    Java源码 SpringMVC Mybatis Shiro Bootstrap Rest Webservice

    4. 文件上传、多线程下载服务化、发送邮件、短信服务化、部门信息服务化、产品信息服务化、信息发布服务化、我的订阅服务化、我的任务服务化、公共链接、我的收藏服务化等 系统模块： 1. 用户管理： 用户信息...

    给予SpringMVC的java爬虫Demo.zip

    3. **异步处理**：为了提高爬虫效率，可以使用多线程或异步编程。Java 8引入了CompletableFuture，Spring 5提供了WebFlux框架，支持非阻塞和反应式编程。 **三、整合SpringMVC与Java爬虫** 1. **创建爬虫服务**：...

    基于ssm高校宿舍管理系统.zip

    Java的多线程、面向对象特性使得处理并发请求和复杂业务逻辑变得更加简单。系统可能使用了Spring Boot来简化Java应用的配置和启动过程。 5. **微信小程序**：作为前端界面，微信小程序提供了轻量级、跨平台的用户...

    Java面试宝典PLUS.pdf

    包括JavaSE基础（多态、异常处理、常用API、数据类型、IO操作、集合、多线程和并发库、内部类）、JavaSE高级（反射、动态代理、设计模式&回收机制、加载器、JVM基础、GC基础）、JavaWeb基础（JDBC技术、HTTP协议、...

    Java面试可能问的问题.docx

    在多线程环境中，通常使用双重检查锁定（Double-Check Locking）来实现线程安全的单例。 - **策略模式**：定义一系列算法，封装起来并使它们可以互相替换，使算法的变化独立于使用算法的客户。 - **观察者模式**：...

    游戏助手微信小程序.zip

    开发者需要掌握面向对象编程、异常处理、多线程、集合框架等核心概念。 5. **数据库设计与操作**： - 在游戏助手小程序中，可能会涉及到用户信息、游戏数据、排行榜等功能，需要设计合理的数据库模型并使用SQL进行...

    2021年最新Java后端学习路线，适用于所有想要踏入Java行业的初学者（csdn）————程序.pdf

    多线程编程是并发处理的核心，学习线程的创建、同步机制、线程池等知识将让你更好地处理高并发场景。 在项目管理工具方面，Maven是Java开发中的标准工具，用于管理依赖和构建项目。掌握Maven的基本操作和配置，可以...

    应聘Java工程师-3年工作经验-张xx-南昌大学-1----0_嵌入式_java简历_程序员简历模板_计算机相关专业.doc

    他负责了业务模块的设计、权限管理、待办任务管理，用SpringMail发送提醒邮件，Quartz框架实现定时任务，POI技术处理数据导出，Redis用于菜单智能展示，而统计分析则可能借助amCharts等工具实现动态图表。...

    java工程师简历_java简历.doc

    他熟练掌握了Spring、SpringMVC和MyBatis等常用的Java后端框架，这些框架常用于构建企业级应用，Spring提供依赖注入和AOP（面向切面编程）等功能，SpringMVC则负责处理HTTP请求和响应，MyBatis则是轻量级的持久层...

    梁某某-3年Java-本科_嵌入式_java简历_程序员简历模板_计算机相关专业.doc

    1. 多线程基础知识：了解Java多线程编程的基础概念和技术。 2. 集合基础知识：掌握Java集合框架的基础知识和应用。 二、后台开发知识点： 1. Spring框架基础知识：熟悉Spring框架的基础概念和应用，包括依赖注入、...

    基于springboot在线订餐系统微信小程序源码数据库文档.zip

    开发者需熟悉Java语法、异常处理、多线程、集合框架等基础知识。 4. **SSM框架**： SSM（Spring、SpringMVC、MyBatis）是Java web开发中的经典组合。Spring提供了依赖注入和AOP等功能，SpringMVC处理HTTP请求和...

    java高级工程师面试总结

    这意味着在多线程环境中使用`Hashtable`时无需额外的同步措施，但这也使得其性能较低。 - `HashMap`允许键值为`null`，而`Hashtable`不允许。 - `HashMap`提供了`putIfAbsent`等实用方法，这在`Hashtable`中是没有...

    北大青鸟java课程的学习大纲.docx

    9. **SpringMVC**：Spring框架的Web模块，用于构建MVC应用。 10. **MyBatis**：轻量级持久层框架，结合XML或注解实现SQL映射。 11. **SpringSecurity或Shiro**：安全框架，提供身份验证、授权等功能。 12. **...

Magicbox
Global site tag (gtag.js) - Google Analytics