spring&quartz的项目应用总结

最新推荐文章于 2022-08-17 21:23:03 发布
最新推荐文章于 2022-08-17 21:23:03 发布
阅读量1.4k 收藏
点赞数
分类专栏： spring 文章标签： quartz spring null class bean string
 

一.名词简介：
        Quartz是一个完全由java编写的开源作业调度框架。Spring 为创建Quartz的Scheduler、Trigger和JobDetail提供了便利的FactoryBean类，以便能够在 Spring 容器中享受注入的好处。此外Spring还提供了一些便利工具类直接将Spring中的Bean包装成合法的任务。Spring进一步降低了使用 Quartz的难度，能以更具Spring风格的方式使用Quartz。概括来说它提供了两方面的支持：
    1)为Quartz的重要组件类提供更具Bean风格的扩展类；
    2)提供创建Scheduler的BeanFactory类，方便在Spring环境下创建对应的组件对象，并结合Spring容器生命周期进行启动和停止的动作。

二。项目实践

情景一： 集群部署，持久化，动态创建schedule配置
 1.spring-schedule.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans default-autowire="byName">
 <bean id="GMTZone" class="java.util.TimeZone" factory-method="getTimeZone">
        <constructor-arg value="GMT"/>
 </bean>

 <!--业务job生成工厂，该工厂注入了scheduleManager --> 
 <bean id="pharmaskyJobFactory " class="com.infowarelab.pharmasky.service.schedule.PharmaskyJobFactory "/>

 <!--schedule管理器，用于动态添加，修改，删除schedule  --> 
 <bean id="scheduleManager" class="com.infowarelab.pharmasky.service.schedule.ScheduleManager">
        <property name="scheduler" ref="scheduleFactoryBean"/>
 </bean>
 
 <!--持久化，集群schedule工厂配置信息,实际可以在classpath下附加quartz.properties定义这些属性值 -->
 <bean id="scheduleFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="quartzProperties">
         <props>
                <prop key="org.quartz.scheduler.instanceName">PharmaskyClusteredScheduler</prop>
                <prop key="org.quartz.scheduler.instanceId">AUTO</prop>
                <prop key="org.quartz.threadPool.class">org.quartz.simpl.SimpleThreadPool</prop>
                <prop key="org.quartz.threadPool.threadCount">25</prop>
                <prop key="org.quartz.threadPool.threadPriority">5</prop>
                <prop key="org.quartz.jobStore.misfireThreshold">60000</prop>
                <prop key="org.quartz.jobStore.class">org.quartz.impl.jdbcjobstore.JobStoreTX</prop>
                <prop key="org.quartz.jobStore.driverDelegateClass">org.quartz.impl.jdbcjobstore.StdJDBCDelegate</prop>
                <prop key="org.quartz.jobStore.tablePrefix">QRTZ_</prop>
                <prop key="org.quartz.jobStore.isClustered">true</prop>
                <prop key="org.quartz.jobStore.clusterCheckinInterval">20000</prop>
         </props>
        </property>
        <property name="triggers">
                 <list>
                         <ref local="orderConversionCronTrigger"/>
                 </list>
         </property>
 </bean>
 
  <!--固定jobDetail, org.quartz.JobDetail类型的JobDetail必须实现指定接口方法来执行job-->
 <bean id="autoOrderStatusConversionJob" class="org.quartz.JobDetail ">
        <property name="jobClass">
                  <value>com.infowarelab.pharmasky.service.schedule.job.HisAutoOrderConversionJob</value>
        </property>
        <property name="name" value="PMS-SYS-JOB-HIS-ORDER-CONVERSION"/>
        <property name="group" value="PMS-GROUP"/>
        <property name="requestsRecovery" value="true"/>
 </bean>
 
 <!--job触发器，绑定上面的jobDetail --> 
 <bean id="orderConversionCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
         <property name="beanName" value="PMS-SYS-JOB-HIS-ORDER-CONVERSION-Trigger"/>
         <property name="jobDetail" ref="autoOrderStatusConversionJob" />
         <property name="cronExpression" value="0 0/20 * * * ?" />
         <property name="timeZone" ref="GMTZone"/>
  </bean>
</beans>
2.ScheduleManager.java动态管理schedule工具类


package  com.infowarelab.pharmasky.service.schedule;

 import  java.text.ParseException;
 import  java.util.ArrayList;
 import  java.util.Date;
 import  java.util.List;

 import  org.apache.commons.lang.StringUtils;
 import  org.quartz.CronTrigger;
 import  org.quartz.JobDetail;
 import  org.quartz.Scheduler;
 import  org.quartz.SchedulerException;
 import  org.quartz.Trigger;

 import  com.infowarelab.common.log.Log;
 import  com.infowarelab.common.log.LogFactory;
 import  com.infowarelab.pharmasky.util.Config;


 public   class  ScheduleManager  {

     private   static   final  Log log  =  LogFactory.getLog(ScheduleManager. class );

     private  Scheduler scheduler;

     public   void  start()  throws  SchedulerException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
         if  (scheduler.isShutdown()  ||  scheduler.isInStandbyMode())  {
            scheduler.start();
        }
    }

     public   void  pause()  throws  SchedulerException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
         if  (scheduler.isStarted())  {
            scheduler.standby();
        }
    }

     public   void  stop()  throws  SchedulerException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
         if  (scheduler.isStarted()  ||  scheduler.isInStandbyMode())  {
            scheduler.shutdown();
        }
    }

     public  List listJobDetails()  throws  SchedulerException  {
        List rstList  =   new  ArrayList < JobDetail > ();
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
        String[] groupNames  =  scheduler.getJobGroupNames();
        log.info( " [INFO] the groups in current scheduler is :  "
                 +  groupNames.length);
         for  ( int  i  =   0 ; i  <  groupNames.length; i ++ )  {
            String[] jobNames  =  scheduler.getJobNames(groupNames[i]);
             for  ( int  j  =   0 ; j  <  jobNames.length; j ++ )  {
                JobDetail jobDetail  =  scheduler.getJobDetail(jobNames[j],
                        groupNames[i]);
                 if  (jobDetail  !=   null )  {
                    rstList.add(jobDetail);
                }
            }
        }
         return  rstList;
    }

     public  JobDetail getJobDetail(String jobName, String jobGroupName)
             throws  SchedulerException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
        JobDetail job  =  scheduler.getJobDetail(jobName, jobGroupName);

         if  (job  ==   null )  {
            log.info( " [INFO]none object relative the jobName :  "   +  jobName
                     +   "  and jobGroupName :  "   +  jobGroupName);
        }
         return  job;
    }

     public  List < JobDetail >  getJobDetailByGroup(String jobGroupName)
             throws  SchedulerException  {
        List < JobDetail >  list  =   new  ArrayList < JobDetail > ();
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
        String[] jobNames  =  scheduler.getJobNames(jobGroupName);

        log.debug( " [DEBUG] jobNames with / ""  + jobGroupName
                 +   " / "  as groupName :  "  + jobNames);

         for  ( int  i  =   0 ; i  <  jobNames.length; i ++ )  {
            JobDetail jobDetail  =  getJobDetail(jobNames[i], jobGroupName);
             if  (jobDetail  !=   null )  {
                list.add(jobDetail);
            }   else   {
                log
                        .debug( " [DEBUG] JobDetail with {/ ""
                                  +  jobNames[i]
                                 +   " / "  , / ""
                                 +  jobGroupName
                                 +   " / " }  as the jobName and jobGroupName can not be found  ! " );
            }
        }
         return  list;
    }

     public   boolean  addJobDetail(JobDetail jobDetail, String cronExpress)
             throws  SchedulerException, ParseException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
         if  (jobDetail  !=   null   &&  cronExpress  !=   null )  {

            Trigger trigger  =   new  CronTrigger(jobDetail.getName(), jobDetail.getGroup(),
                    jobDetail.getName(), jobDetail.getGroup(), cronExpress);

            Date jobDate  =  scheduler.scheduleJob(jobDetail, trigger);
            log
                    .info( " [INFO]jobDetail :  "
                             +  jobDetail.getFullName()
                             +   "  has been added into the scheduler , and the firstFiredTime is :  "
                             +  jobDate);
             return  (jobDate  ==   null )  ?   false  :  true ;
        }   else   {
            log
                    .info( " [INFO]add jobDetail failure, the parameters on jobDetail or trigger has null value ! " );
        }
         return   false ;
    }

     public  Trigger[] getJobTrigger(String jobName, String jobGroupName)
             throws  SchedulerException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
         return  scheduler.getTriggersOfJob(jobName, jobGroupName);
    }

     public  List < Trigger >  listTrigger()  throws  SchedulerException  {
        List < Trigger >  triggerList  =   new  ArrayList < Trigger > ();
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }
        String[] triggerGroupNames  =  scheduler.getTriggerGroupNames();
        log
                .info( " [INFO] the trigger groups amounts which is registed within the system is :  "
                         +  triggerGroupNames.length);
         for  (String triggerGroupName : triggerGroupNames)  {
             if  (triggerGroupName  !=   null )  {
                String[] triggerNames  =  scheduler
                        .getTriggerNames(triggerGroupName);
                 for  (String triggerName : triggerNames)  {
                    Trigger trigger  =  scheduler.getTrigger(triggerName,
                            triggerGroupName);
                     if  (trigger  !=   null
                             &&  scheduler.getTriggerState(triggerName,
                                    triggerGroupName)  ==  Trigger.STATE_NORMAL)  {
                        triggerList.add(trigger);
                    }   else   {
                        log.info( " [INFO] the trigger :  "
                                 +  ((trigger  ==   null )  ?  trigger.getFullName()
                                        :  "  null " )  +   " , not exists  "
                                 +   " or has the not normal status " );
                    }
                }
            }
        }
         return  triggerList;
    }

     public   boolean  reScheduleJob(String jobName, String jobGroupName,
            String computedStr)  throws  SchedulerException, ParseException  {
         if  (scheduler  ==   null )  {
            scheduler  =  getScheduler();
        }

        Trigger newTrigger  =   new  CronTrigger(jobName, jobGroupName, jobName,
                jobGroupName, computedStr);

        newTrigger.setJobName(jobName);
        newTrigger.setJobGroup(jobGroupName);


        Date triggerDate  =  scheduler.rescheduleJob(jobName, jobGroupName, newTrigger);
        log.info( " [INFO] the job  "   +  jobName
                 +   "  has been update to fired on :  "   +  triggerDate);

         return  (triggerDate  ==   null )  ?   false  :  true ;
    }

     public  String genScheduleTimeStr( byte  type, Short  scheduleTimeParams)  {
        String pattern  =   null ;  //  variable for cron express
         switch  (type)  {
         case   1 :
             //  auto order creation job , the parameter turn is : weekInterval ,
             //  weekday, hour, minute
             //  "0 minute hour ? * weekDay/weekInterval"
            pattern  =  Config
                    .getString( " schedule.cron.express.his.order.creation " );
            log.info( " [INFO] parttern for his order creation cron express :  "
                     +  pattern);
             for  ( int  i  =   0 ; i  <  scheduleTimeParams.length; i ++ )  {
                 switch  (i)  {
                 case   0 :  //  minute
                    pattern  =  StringUtils.replace(pattern,  " minute " ,
                            scheduleTimeParams[ 0 ].toString());
                     break ;
                 case   1 :  //  hour
                    pattern  =  StringUtils.replace(pattern,  " hour " ,
                            scheduleTimeParams[ 1 ].toString());
                     break ;
                 case   2 :  //  weekDay
                    pattern  =  StringUtils.replace(pattern,  " weekDay " ,
                            getWeekIdentify(scheduleTimeParams[ 2 ]));
                     break ;
                 case   3 :  //  weekInterval
                    pattern  =  StringUtils.replace(pattern,  " weekInterval " ,
                            scheduleTimeParams[ 3 ].toString());
                     break ;
                 default :
                     break ;
                }
            }
             break ;

         case   2 :
             //  his stock sync job , the parameter turn is : dayInterval, hour,
             //  minute
             //  "0 minute hour */dayInterval * ?"
            pattern  =  Config.getString( " schedule.cron.express.his.stock.sync " );
            log.info( " [INFO] parttern for his order creation cron express :  "
                     +  pattern);
             for  ( int  i  =   0 ; i  <  scheduleTimeParams.length; i ++ )  {
                 switch  (i)  {
                 case   0 :  //  minute
                    pattern  =  StringUtils.replace(pattern,  " minute " ,
                            scheduleTimeParams[ 0 ].toString());
                     break ;
                 case   1 :  //  hour
                    pattern  =  StringUtils.replace(pattern,  " hour " ,
                            scheduleTimeParams[ 1 ].toString());
                     break ;
                 case   2 :  //  dayInterval
                    pattern  =  StringUtils.replace(pattern,  " dayInterval " ,
                            scheduleTimeParams[ 2 ].toString());
                     break ;
                 default :
                     break ;
                }
            }
             break ;

         default :
             break ;
        }

        log.info( " [INFO] schedule job cron express is :  "   +  pattern);
         return  (pattern  ==   null )  ?   null  : pattern.trim();
    }

     /**  **********************************************************************  */
     /**  helper method or getters and setters *  */
     /**  **********************************************************************  */

     /**
     * get the week day's identify like "SUN","MON" and so on. In this method
     * the data "1" equals "SUN", so the "7" equals "SAT";
     * 
     *  @param  short
     *            the numeric data for week day
     *  @return  String the week day identify with correct numeric data
      */
     private  String getWeekIdentify( short  weekDay)  {
        String value  =   null ;
         switch  (weekDay)  {
         case   1 :
            value  =   " SUN " ;
             break ;
         case   2 :
            value  =   " MON " ;
             break ;
         case   3 :
            value  =   " TUE " ;
             break ;
         case   4 :
            value  =   " WED " ;
             break ;
         case   5 :
            value  =   " THU " ;
             break ;
         case   6 :
            value  =   " FRI " ;
             break ;
         case   7 :
            value  =   " SAT " ;
             break ;
         default :
             break ;
        }
         return  value;
    }

     public  Scheduler getScheduler()  {
         return  scheduler;
    }

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

 

情景二：单机部署，固定触发规则多个schedule，不用持久化
1.spring-schedule.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans default-autowire="byName">
 <!-- Job Bean -->
 <bean name="autoOrderAuditService" class="com.infowarelab.sam.service.job.AutoOrderAuditService"></bean>
 <bean name="sendAuditedOrderService" class="com.infowarelab.sam.service.job.SendAuditedOrderService"></bean>
 
 <!-- Job由于以上job bean具有相同的触发规则，所以统一集中在这个管理器执行-->
 <bean id="timerJobManagerJob"  class="com.infowarelab.sam.service.job.SamJobManager"  autowire="no">
       <property name="tasks">
             <list>
                    <ref bean="autoOrderAuditService"/>
                    <ref bean="sendAuditedOrderService"/>
              </list>
        </property>
         <property name="samBaseInfoService" ref="samBaseInfoService"></property>
 </bean>

 <bean id="timerJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean " autowire="no">
        <property name="targetObject" ref="timerJobManagerJob" />
        <property name="targetMethod" value="jobExpires" />
 </bean>

 <bean id="timerCronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean" autowire="no">
        <property name="jobDetail" ref="timerJobDetail" />
        <property name="cronExpression">
               <value>0 0/15 * * * ?</value>
        </property>
 </bean>

 <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean" autowire="no">
        <property name="triggers">
              <list>
                <ref bean="timerCronTrigger" />
              </list>
        </property>
 </bean>
</beans>

 

 参考资料：
cronExpression表达式:
http://hi.baidu.com/the_space_of_programmer/blog/item/725759f78d383e27720eec80.html  (cronExpression
quartz介绍：
http://hi.baidu.com/alliance_alex/blog/item/5c998d64241173f2f73654b0.html
集群及quartz配置说明:
http://hi.baidu.com/jiangyou001/blog/item/5196d990862d5789a977a4af.html
http://gocom.primeton.com/modules/newbb/forumtopic19180_9963_40.htm

溺水的鱼
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【quartz】quartz学习使用心得（3）之spring与Quartz的整合
crainnogao的博客
03-30 211
spring与Quartz的整合需要导入Quartz jar包，在maven中导入，方法我就不列出来了，就是在pom引入依赖，不知道的话可以查查别的资料。整合后xml的配置文件的两种方式：MethodInvokingJobDetailFactoryBean  调用特定bean的某个特定方法例如：&lt;!-- ***********使用MethodInvokingJobDetailFactory*...
Spring集成Quartz---具体场景应用
Q蛋黄酱的专栏
09-27 1011
Java并发编程阶段，突然接触到了定时调度任务这一概念，恰巧在实习期间有过运用，因此特写此博客以记录，欢迎指正和讨论。 　　　　　　　　　　　　　　　　　　　　　　　　　——前言本文将分以下四点进行讨论。篇幅过长的话，可能分其他章节。Quartz基本概念一、quartz核心概念 先来看一张图： 对于上图中各个部分的概念解释如下： scheduler：任务调度器 trig
Quartz框架介绍及在spring中的简单应用
weixin_41910244的博客
06-14 325
大家好，今天给大家分享一下：Quartz框架的介绍。 虽然上个项目中并没有明确要求使用Quartz框架，但是涉及一个SpringRMI中web\service的分离,其中要求在一台service宕机之后，web就不连接它，直接忽略它。而RMI是原生的Spring框架，所以当时没有找到负载均衡这方面的功能，于是就想到了使用定时任务来发送生存报告到缓存中，然后去缓存中查看是否存在对应的生存报告再决定...
spring quartz 12张表的功能作用
热门推荐
kongjunlongaa的博客
06-16 1万+
spring quartz 12张表的效能作用 JobStore 是基于 JDBC 的，它需要一个数据用于 Scheduler 信息的持久化。Quartz  需要创建 12 张数据库表。表的名字和描述在表 6.1 中列出。 表 6.1. Quartz 需要下列表用于所有的 JDBC 的持久性 JobStore 表名 描述 QRTZ_CALENDARS 以
Spring quartz使用详解
wgzhl2008的专栏
06-20 1042
Spring quartz在作定时任务时使用起来很方便，较java的timer使用起来更加高效，管理起来快捷，下面是详细配置 <beans default-autowire="byName" xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-in
spring quartz使用详解
a936676463的专栏
08-14 979
2012-01-09 14:49 Spring中Quartz的配置 定时器 Spring中Quartz的配置 各种企业应用几乎都会碰到任务调度的需求，就拿论坛来说：每隔半个小时生成精华文章的RSS文件，每天凌晨统计论坛用户的积分排名，每隔30分钟执行锁定用户解锁任务。对于一个典型的MIS系统来说，在每月1号凌晨统计上个月各部门的业务数据生成月报表，每半个小时查询用户是否已经有快到期的
spring的quartz功能演示
acoolper的专栏
03-16 579
大家可能忽略了spring提供的一个非常强大的功能那就是quartz 这个可以定时执行某一个方法.比如说我们需要每隔几分钟或者几个小时执行一次刷新操作或统计操作 这个用quartz就非常方便 具体的spring配置如下:                                  class="org.springframework.scheduling.quartz.M
spring:quartz的总结
flm_llx的专栏
01-26 104
Quartz 是一个强大的企业级 Schedule 工具，也是目前最好的开源 Schedule 工具。Spring中也集成了quartz的应用，下面就讲一下如何在spring中使用quartz。 spring的配置： xml 代码 list> property> bean> ...
springboot整合quartz之数据库持久化的十一张表
Hana335566的博客
07-04 394
数据库sql
Python程序控制流程-三大流程
WhiteAdam的博客
10-03 103
1、顺序结构 代码是从上到下、从左到右运行的 2、选择结构 1.单分支选择结构 if 条件: # 条件成立时要执行的代码 2.双分支选择结构 if condition: # 条件成立时要执行的代码 else: # 条件不成立时要执行的代码 3. 多分支选择结构 if 条件1: # 条件1成立时要执行的代码 elif 条件2: # 条件2成立时要执行的代码 ... else: # 前面条件都不满足时要执行的代码 3.循环 while
深入解读Quartz的原理
05-17
深入解读Quartz的原理，定时任务框架是web开发过程中使用很多的框架之一
[springboot]集成org.quartz-scheduler进行任务调度(定时任务)
s_156的博客
11-30 3187
前言 springboot内置有org.springframework.scheduling.annotation.Scheduled可以让我们进行简单快速的任务调度（例如定时执行的任务），当我们一些和任务调度有关的业务开始复杂的时候，极其需要非常灵活的任务调度策略；在这种情况，博主使用了quartz，写下此文以记； 依赖（gradle） compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.2.1' quartz的配置文件
热部署定时任务管理实现
hantiwenti的博客
10-26 371
热部署定时任务管理实现（上传jar+动态加载jar中接口类文件+hessian远程调用执行业务）1.新增定时任务主要是配置定时任务的执行周期，涉及到热部署的就是关于接口jar上传，要调用的远程接口类名称，接口中要被调用的方法名称、远程调用的hessianURL，这样子就配置好了一个定时任务，信息存放到数据库，这样就成功添加了一个定时任务用到了loadJar这个方法，这里用到了动态加载，刚上传的j...
java 定时器 原理_实现quartz定时器及quartz定时器原理介绍
weixin_29712031的博客
02-12 321
一、核心概念Quartz的原理不是很复杂，只要搞明白几个概念，然后知道如何去启动和关闭一个调度程序即可。1、Job表示一个工作，要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context)2、JobDetailJobDetail表示一个具体的可执行的调度程序，Job是这个可执行程调度程序所要执行的内容，另外JobDetail还包含了这个任...
Spring Quartz
最新发布
qq_37933128的博客
08-17 664
Quartz是由Java编写的开源作业调度框架，Quartz可以定时或周期性的执行一些任务。
java 操作quartz.Scheduler
点点滴滴
11-29 390
以前在web项目中使用过spring+quartz进行定时操作，本次没有使用spring，直接java代码使用quartz进行定时任务的操作，做了一点总结进行分享： try { Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler(); if (scheduler != null && scheduler.is...
定时任务框架Quartz原理和整合springboot
weixin_44308214的博客
11-16 925
文章目录定时任务框架Quartz介绍二、Quartz Demo搭建三、Quartz核心详解四、Quartz流程和原理五、Quartz持久化任务和锁机制六、Springboot整合Quartz实现动态定时任务 定时任务框架Quartz介绍 #一、 什么是Quartz （1）首先我们需要定义实现一个定时功能的接口，我们可以称之为Task（或Job），如定时发送邮件的task（Job），重启机器的task（Job），优惠券到期发送短信提醒的task（Job），实现接口如下： [外链图片转存失败,源站可能有防盗链机
spring4.1.5 配置quartz2.2.1
登高必自卑，涉远必自迩
11-04 949
一：需要的jar包如下： 二：spring 配置文件如下： autoRun 0 36 16 ? * *
Spring集成Quartz，动态配置定时任务调度
本文是基于sundoctor在iteye上的一篇文章，结合自己的理解和一些参考文档，对Spring Quartz集成进行了总结和说明。 在开始之前，需要了解一些Spring Quartz集成中用到的类。这些类包括： - org.springframework....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值