Quartz集成spring开发大全

最新推荐文章于 2024-06-03 10:27:17 发布
最新推荐文章于 2024-06-03 10:27:17 发布
阅读量769 收藏
点赞数
分类专栏： Quartz

一.固定xml调用quartz

准备工作：

1.导入quartz-1.x.x.x.jar到lib，可能还需要lib/sh4j-api-1.x.x.jar，log4g，sh4j.api,1,x,x,jar，sh4j.nop,1,x,x,jar

2.在src目录下创建quartz.properties（压缩quartz-1.x.x.x.jar 下的org/quarz下可得）

[html]  view plain copy
  1. # 配置主调度器属性  
  2. org.quartz.scheduler.instanceName = DefaultQuartzScheduler  
  3. org.quartz.scheduler.rmi.export = false  
  4. org.quartz.scheduler.rmi.proxy = false  
  5. org.quartz.scheduler.wrapJobExecutionInUserTransaction = false  
  6. # 配置线程池  
  7. # Quartz线程池的实现类  
  8. org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool  
  9. # 线程池的线程数量  
  10. org.quartz.threadPool.threadCount = 10  
  11. # 线程池里线程的优先级  
  12. org.quartz.threadPool.threadPriority = 5  
  13. org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true  
  14. # 配置作业存储  
  15. org.quartz.jobStore.misfireThreshold = 60000  
  16.   
  17. org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore  
  18.   
  19. #org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX  
  20. #org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.HSQLDBDelegate  
  21. #org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate  
  22. #org.quartz.jobStore.useProperties = true  
  23. #org.quartz.jobStore.tablePrefix = QRTZ_    
  24. #org.quartz.jobStore.isClustered = false    
  25. #org.quartz.jobStore.maxMisfiresToHandleAtATime=1   

 

3.编写触发时要执行的类

[java]  view plain copy
  1. package com.quartz;  
  2.   
  3. import org.quartz.JobExecutionContext;  
  4. import org.quartz.JobExecutionException;  
  5. import org.quartz.Trigger;  
  6. import org.springframework.scheduling.quartz.QuartzJobBean;  
  7.   
  8. public class TestQuartzJob extends QuartzJobBean{  
  9.   
  10.     @Override  
  11.     protected void executeInternal(JobExecutionContext jobexecutioncontext) throws JobExecutionException {  
  12.         // TODO Auto-generated method stub  
  13.         Trigger trigger = jobexecutioncontext.getTrigger();  
  14.         String triggerName = trigger.getName();       
  15.         System.out.println("MyQuartzJobBean"+triggerName);  
  16.     }  
  17.   
  18. }  


4.配置sping管理的配置文件quartzContext.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:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"
xmlns:jee="http://www.springframework.org/schema/jee"
xsi:schemaLocation="
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/jee
    http://www.springframework.org/schema/jee/spring-jee-2.5.xsd">
<!-- 自定义工作类 -->
<bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass">
<value>com.quartz.TestQuartzJob</value>
</property>
<property name="jobDataAsMap">
<map>
<!--
<entry key="upVersionDevService"> <ref bean="upVersionDevService"
/> </entry>
-->
</map>
</property>
</bean>
<!-- 注入的service的工作类 -->
<bean id="methodInvokingJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">         
<!-- 指定定时任务调度类 -->  
<property name="targetObject">
<ref bean="userService" />
</property>          
<!-- 指定定时任务调度方法 -->
<property name="targetMethod">
<value>save</value>  
</property>
</bean>

<!-- 每隔10秒自动调用 配置模板 使用复杂的cronTrigger-->
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"> 
<property name="jobDetail" ref="jobDetail" /> 
<property name="cronExpression" value="0/10 * * ? * * *" /> 
</bean> 
<bean  id="schedulerTrigger" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"> 
<property name="triggers"> 
<list> 
<ref bean="cronTrigger"/>      
</list> 
</property> 
</bean>
        <!-- 延迟1秒后，每隔10秒自动调用 配置模板 使用简单的SimpleTriggerBean-->
<bean id="st01SimpleTrigger"   class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
            <property name="jobDetail" ref="checkSt01Job"></property>  
            <property name="startDelay" value="1000"></property>  
           <property name="repeatInterval" value="10000"></property>  
    </bean>  
         
</beans>

[javascript]  view plain copy
  1.   

[javascript]  view plain copy
  1. cronTrigger表达式含义：  
  2. <property name="cronExpression" value="0/10 * * ? * * *" />  
  3.  <!--  0 0 0 1 * ?     
  4.   #       1.秒(0-59)  
  5.   #       2.分钟(0-59)   
  6.   #       3.小时(0-23)    
  7.   #       4.月份中的日期(1-31)    
  8.   #       5.月份(1-12或SUN-DEC)    
  9.   #       6.星期中的日期(1-7或SUN-SAT)    
  10.   #       7.年份(1970-2099)  
  11.     表达式意义  
  12.     "0 0 12 * * ?" 每天中午12点触发  
  13.     "0 15 10 ? * *" 每天上午10:15触发  
  14.     "0 15 10 * * ?" 每天上午10:15触发  
  15.     "0 15 10 * * ? *" 每天上午10:15触发  
  16.     "0 15 10 * * ? 2005" 2005年的每天上午10:15触发  
  17.     "0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发  
  18.     "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发  
  19.     "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发  
  20.     "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发  
  21.     "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发  
  22.     "0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发  
  23.     "0 15 10 15 * ?" 每月15日上午10:15触发  
  24.     "0 15 10 L * ?" 每月最后一日的上午10:15触发  
  25.     "0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发  
  26.     "0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发  
  27.     "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发  
  28.     每天早上6点  
  29.     0 6 * * *  
  30.     每两个小时  
  31.     0 */2 * * *  
  32.     晚上11点到早上8点之间每两个小时，早上八点  
  33.     0 23-7/2，8 * * *  
  34.     每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点  
  35.     0 11 4 * 1-3  
  36.     1月1日早上4点  
  37.     0 4 1 1 *  


[html]  view plain copy
  1.   

二程序动态调用quartz(动态设置job和定时器)

1.导入quartz-1.x.x.x.jar到lib，可能还需要lib/sh4j-api-1.x.x.jar，log4g，sh4j.api,1,x,x,jar，sh4j.nop,1,x,x,jar

2.在src目录下创建quartz.properties（压缩quartz-1.x.x.x.jar 下的org/quarz下可得）

3.配置sping管理的配置文件quartzContext.xml

[html]  view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <beans xmlns="http://www.springframework.org/schema/beans"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"  
  4.     xmlns:tx="http://www.springframework.org/schema/tx" xmlns:context="http://www.springframework.org/schema/context"  
  5.     xmlns:jee="http://www.springframework.org/schema/jee"  
  6.     xsi:schemaLocation="  
  7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd  
  8.     http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd  
  10.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
  11.     http://www.springframework.org/schema/jee  
  12.     <a target="_blank" href="http://www.springframework.org/schema/jee/spring-jee-2.5.xsd'>">http://www.springframework.org/schema/jee/spring-jee-2.5.xsd"></a>  
[html]  view plain copy
  1. <u><span style="color:#0000ff"><!--要注入的包名--></span></u>  
[html]  view plain copy
  1. <context:component-scan base-package="com"/>  
  2.          <u><span style="color:#0000ff"><!--要注入的时间触发器--></span></u>  
[html]  view plain copy
  1. <bean name="quartzScheduler"  
  2.     class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
  3.     <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />  
  4.     <property name="configLocation" value="classpath:quartz.properties" />  
  5. </bean>  


 

4.spring中导入QuartzServiceImpl和IQuartzService2个类  作用是动态时间执行

[java]  view plain copy
  1. package com.quartz;  
  2.   
  3. import java.util.Date;  
  4.   
  5. import org.quartz.CronExpression;  
  6.   
  7. public interface IQuartzService {  
  8.     /** 
  9.      * 根据 Quartz Cron Expression 调试任务 
  10.      * @param cronExpression  Quartz Cron 表达式，如 "0/10 * * ? * * *"等 
  11.      */  
  12.     void schedule(String cronExpression);  
  13.       
  14.     /** 
  15.      * 根据 Quartz Cron Expression 调试任务 
  16.      * @param name  Quartz CronTrigger名称 
  17.      * @param cronExpression Quartz Cron 表达式，如 "0/10 * * ? * * *"等 
  18.      */  
  19.     void schedule(String name,String cronExpression);  
  20.       
  21.     /** 
  22.      * 根据 Quartz Cron Expression 调试任务 
  23.      * @param cronExpression Quartz CronExpression 
  24.      */  
  25.     void schedule(CronExpression cronExpression);  
  26.       
  27.     /** 
  28.      * 根据 Quartz Cron Expression 调试任务 
  29.      * @param name Quartz CronTrigger名称 
  30.      * @param cronExpression Quartz CronExpression 
  31.      */  
  32.     void schedule(String name,CronExpression cronExpression);  
  33.       
  34.     /** 
  35.      * 在startTime时执行调试一次 
  36.      * @param startTime 调度开始时间 
  37.      */  
  38.     void schedule(Date startTime);    
  39.       
  40.     /** 
  41.      * 在startTime时执行调试一次 
  42.      * @param name Quartz SimpleTrigger 名称 
  43.      * @param startTime 调度开始时间 
  44.      */  
  45.     void schedule(String name,Date startTime);  
  46.       
  47.     /** 
  48.      * 在startTime时执行调试，endTime结束执行调度 
  49.      * @param startTime 调度开始时间 
  50.      * @param endTime 调度结束时间 
  51.      */  
  52.     void schedule(Date startTime,Date endTime);   
  53.       
  54.     /** 
  55.      * 在startTime时执行调试，endTime结束执行调度 
  56.      * @param name Quartz SimpleTrigger 名称 
  57.      * @param startTime 调度开始时间 
  58.      * @param endTime 调度结束时间 
  59.      */  
  60.     void schedule(String name,Date startTime,Date endTime);  
  61.       
  62.     /** 
  63.      * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次 
  64.      * @param startTime 调度开始时间 
  65.      * @param endTime 调度结束时间 
  66.      * @param repeatCount 重复执行次数 
  67.      */  
  68.     void schedule(Date startTime,Date endTime,int repeatCount);   
  69.       
  70.     /** 
  71.      * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次 
  72.      * @param name Quartz SimpleTrigger 名称 
  73.      * @param startTime 调度开始时间 
  74.      * @param endTime 调度结束时间 
  75.      * @param repeatCount 重复执行次数 
  76.      */  
  77.     void schedule(String name,Date startTime,Date endTime,int repeatCount);  
  78.       
  79.     /** 
  80.      * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次 
  81.      * @param startTime 调度开始时间 
  82.      * @param endTime 调度结束时间 
  83.      * @param repeatCount 重复执行次数 
  84.      * @param repeatInterval 执行时间隔间 
  85.      */  
  86.     void schedule(Date startTime,Date endTime,int repeatCount,long repeatInterval) ;  
  87.       
  88.     /** 
  89.      * 在startTime时执行调试，endTime结束执行调度，重复执行repeatCount次，每隔repeatInterval秒执行一次 
  90.      * @param name Quartz SimpleTrigger 名称 
  91.      * @param startTime 调度开始时间 
  92.      * @param endTime 调度结束时间 
  93.      * @param repeatCount 重复执行次数 
  94.      * @param repeatInterval 执行时间隔间 
  95.      */  
  96.     void schedule(String name,Date startTime,Date endTime,int repeatCount,long repeatInterval);  
  97.       
  98.     /** 
  99.      * 移除定时任务 
  100.      * @param name Quartz SimpleTrigger 名称 
  101.      */  
  102.     void removeSchedule(String name);  
  103. }  


 

[java]  view plain copy
  1. package com.quartz;  
  2.   
  3. import java.text.ParseException;  
  4. import java.util.Date;  
  5. import java.util.UUID;  
  6.   
  7. import org.quartz.CronExpression;  
  8. import org.quartz.CronTrigger;  
  9. import org.quartz.JobDetail;  
  10. import org.quartz.Scheduler;  
  11. import org.quartz.SchedulerException;  
  12. import org.quartz.SimpleTrigger;  
  13. import org.springframework.beans.factory.annotation.Autowired;  
  14. import org.springframework.beans.factory.annotation.Qualifier;  
  15. import org.springframework.stereotype.Service;  
  16.   
  17. @Service("schedulerService")  
  18. public class QuartzServiceImpl implements IQuartzService {  
  19.   
  20.     private Scheduler scheduler;  
  21.     private JobDetail jobDetail;  
  22.   
  23.     @Autowired  
  24.     public void setJobDetail(@Qualifier("jobDetail") JobDetail jobDetail) {  
  25.         this.jobDetail = jobDetail;  
  26.     }  
  27.   
  28.     @Autowired  
  29.     public void setScheduler(@Qualifier("quartzScheduler") Scheduler scheduler) {  
  30.         this.scheduler = scheduler;  
  31.     }  
  32.   
  33.     @Override  
  34.     public void schedule(String cronExpression) {  
  35.         schedule(null, cronExpression);  
  36.     }  
  37.   
  38.     @Override  
  39.     public void schedule(String name, String cronExpression) {  
  40.         try {  
  41.             schedule(name, new CronExpression(cronExpression));  
  42.         } catch (ParseException e) {  
  43.             throw new RuntimeException(e);  
  44.         }  
  45.     }  
  46.   
  47.     @Override  
  48.     public void schedule(CronExpression cronExpression) {  
  49.         schedule(null, cronExpression);  
  50.     }  
  51.   
  52.     @Override  
  53.     public void schedule(String name, CronExpression cronExpression) {  
  54.         if (name == null || name.trim().equals("")) {  
  55.             name = UUID.randomUUID().toString();  
  56.         }  
  57.   
  58.         try {  
  59.             scheduler.addJob(jobDetail, true);  
  60.   
  61.             CronTrigger cronTrigger = new CronTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),  
  62.                     Scheduler.DEFAULT_GROUP);  
  63.             cronTrigger.setCronExpression(cronExpression);  
  64.             scheduler.scheduleJob(cronTrigger);  
  65.             scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, cronTrigger);  
  66.         } catch (SchedulerException e) {  
  67.             throw new RuntimeException(e);  
  68.         }  
  69.     }  
  70.   
  71.     @Override  
  72.     public void schedule(Date startTime) {  
  73.         schedule(startTime, null);  
  74.     }  
  75.   
  76.     @Override  
  77.     public void schedule(String name, Date startTime) {  
  78.         schedule(name, startTime, null);  
  79.     }  
  80.   
  81.     @Override  
  82.     public void schedule(Date startTime, Date endTime) {  
  83.         schedule(startTime, endTime, 0);  
  84.     }  
  85.   
  86.     @Override  
  87.     public void schedule(String name, Date startTime, Date endTime) {  
  88.         schedule(name, startTime, endTime, 0);  
  89.     }  
  90.   
  91.     @Override  
  92.     public void schedule(Date startTime, Date endTime, int repeatCount) {  
  93.         schedule(null, startTime, endTime, 0);  
  94.     }  
  95.   
  96.     @Override  
  97.     public void schedule(String name, Date startTime, Date endTime, int repeatCount) {  
  98.         schedule(name, startTime, endTime, 0, 0L);  
  99.     }  
  100.   
  101.     @Override  
  102.     public void schedule(Date startTime, Date endTime, int repeatCount, long repeatInterval) {  
  103.         schedule(null, startTime, endTime, repeatCount, repeatInterval);  
  104.     }  
  105.   
  106.     @Override  
[java]  view plain copy
  1.        <span style="color:#ff0000">//根据传入时间触发注入的jobDetail  
  2. span>   public void schedule(String name, Date startTime, Date endTime, int repeatCount, long repeatInterval) {  
  3. if (name == null || name.trim().equals("")) {  
  4.     name = UUID.randomUUID().toString();  
  5. }  
  6.   
  7. try {  
  8.     scheduler.addJob(<span style="color:#ff0000">jobDetail</span>, true);  
  9.     System.out.println("startTime="+startTime);  
  10.     SimpleTrigger SimpleTrigger = new SimpleTrigger(name, Scheduler.DEFAULT_GROUP, jobDetail.getName(),  
  11.             Scheduler.DEFAULT_GROUP, startTime, endTime, repeatCount, repeatInterval);  
  12.     SimpleTrigger.getJobDaaMap().put('传入参数key','传入参数值'); <span style="color:#ff0000">//启动计划任务时可以调用此处传入的参数</span>  
[java]  view plain copy
  1.         scheduler.scheduleJob(SimpleTrigger);  
  2.         scheduler.rescheduleJob(name, Scheduler.DEFAULT_GROUP, SimpleTrigger);  
  3.   
  4.     } catch (SchedulerException e) {  
  5.         throw new RuntimeException(e);  
  6.     }  
  7. }  
  8.   
  9. @Override  
  10. <span style="color:#ff6600">//删除暂停计划</span>  
[java]  view plain copy
  1. public void removeSchedule(String name) {  
  2.     // TODO Auto-generated method stub  
  3.     try {  
  4.         scheduler.pauseTrigger(name,Scheduler.DEFAULT_GROUP);//ֹͣ������  
  5.         scheduler.unscheduleJob(name,Scheduler.DEFAULT_GROUP);//�Ƴ���  
  6.         scheduler.deleteJob(name,Scheduler.DEFAULT_GROUP);//ɾ������  
  7.     } catch (SchedulerException e) {  
  8.         // TODO Auto-generated catch block  
  9.         e.printStackTrace();  
  10.     }  
  11. }  
  12.   
  13. 在xml中注入  
[java]  view plain copy
  1.  <bean name="quartzService" class="com.quartz.QuartzServiceImpl" />  
[java]  view plain copy
  1.    

5.如何调用

     ApplicationContext springContext = new ClassPathXmlApplicationContext(new String[]{"classpath:com/springResource/*.xml"});
     QuartzServiceImpl quartzService = (QuartzServiceImpl)springContext.getBean("quartzService");  

      quartzService.setJobDetail(jobDetail);                  //动态设置任务

     quartzService.schedule("name=testQuartz2",DateUtil.parse("2012-12-12 23:42:00"));         //动态设置定时器时间

 

6设置不并发执行 <property name="concurrent" value="false"/>  

 

  1.    <bean id="demoJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean" depends-on="demoService">  
  2.         <property name="targetObject" ref="demoService"/>  
  3.         <property name="targetMethod" value="demoQuartz">  
  4.           
  5.         </property>  
  6.         <property name="concurrent" value="false"/>  
  7.     </bean>  

 


三.最简单的方法，动态设置定时器

首先我们观察xml配置
    <bean id="backupDatabaseTrigger" class=" org.springframework.scheduling.quartz.CronTriggerBean">
        <property name=" jobDetail">
             <!-- 要执行的bean --> 
<ref bean="backupDatabaseJobDetail"/>
        </property>
         <!-- cron表达式 --> 
        <property name=" cronExpression">
            <!-- 每隔90分钟执行一次-->
            <value>0 0/90 * * * ?</value>
        </property>
    </bean> 
 
得出结论
        1个定时任务，需要 CronTriggerBean类和 jobDetail 跟   cronExpression参数

那么我们就可以这样做了
    <bean id="backupDatabaseTrigger" class=" com.MyCronTriggerBean">
        <property name=" jobDetail">
             <!-- 要执行的bean --> 
<ref bean="backupDatabaseJobDetail"/>
        </property>
    </bean> 

MyCronTriggerBean extends CronTriggerBean{
setCronExpression                  //cronExpression你就可以动态设置了撒
}

耳东东1990
关注
专栏目录
Quartz的配置问题
whj0427的专栏
11-22 390
环境：Tomcat 6.0.10 + Quartz 1.6.0 quartz_reminder.xml： [code] Job_DataTransmit DEFAULT scheduling.QuartzStart Trigger_DataTrans...
【JAVA秒会技术之搞定Quartz定时任务】Quartz在Spring中的集成与应用
weixin_34259159的博客
01-22 99
Quartz在Spring中的集成与应用 一、Quqrtz简介 Quartz是一个完全由Java编写的开源任务调度的框架，通过触发器设置作业定时运行规则，控制作业的运行时间。主要用来执行定时任务，如：定时发送信息、定时生成报表等等。 简而言之，Quartz是一个定时器组件，是可以整合Spring使用的一个定时器。 二、Quqrt...
spring集成quartz会重复调用2次的问题
weixin_30859423的博客
12-14 98
quartz是配置在a.xml中，而a.xml是被h.xml import进来的。 所以把quartz配置从a.xml移到h.xml中，重复调用2次的问题就解决了。 估计还是在spring在import a.xml时，把a.xml读了2次，所以也就创建了2遍任务。 转载于:https://www.cnblogs.com/siukun/archive/2011/12/14/2287380.html...
org.quartz.plugins.xml.JobInitializationPlugin] [ERROR] - Error scheduling jobs: no protocol
hongyang070的专栏
07-10 4174
解决这个问题的原文：http://www.gmjjavadesigns.com/gmjd/en_US/entry/quartz_1_6_and_oc4j代码：/* * Copyright 2004-2005 OpenSymphony * * Licensed under the Apache License, Version 2.0 (the "Lic
4-Quartz与Spring Boot的集成
qq_35752835的博客
06-03 654
Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，完全由Java开发，可以用来执行定时任务，类似于java.util.Timer。负责执行相关任务触发器Trigger负责指定相关Job的执行时间，执行间隔，运行次数负责将将指定的触发器应用到指定的任务中
Spring Boot2.0 集成 Quartz
Less Is More
06-14 418
在项目开发中，经常需要定时任务来帮助我们来做一些内容，比如定时派息、跑批对账、业务监控等。Spring Boot 体系中现在有两种方案可以选择，第一种是 Spring Boot 内置的方式简单注解就可以使用，当然如果需要更复杂的应用场景还是得 Quartz 上场，Quartz 目前是 Java 体系中最完善的定时方案。 首先来看看 Spring Boot 自带的定时方案。 Spring Boot 内置定时 pom 包配置 pom 包里面只需要引入 Spring Boot Starter 包即可，Sp
Spring Boot 集成Quartz的简单入门
qq_41978323的博客
12-21 4738
Spring Boot集成Quartz的简单入门
spring boot集成quartz scheduler
qq_37588808的博客
11-27 9835
工具、版本 开发工具：IntelliJ IDEA JDK：1.8 spring-boot:2.5.6（事例使用，可根据自己版本调整） maven：3.6.3 依赖jar <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> </d
quartz整合springbatch动态集群定时实现mysql参考
08-08
Quartz和Spring Batch是两种非常重要的Java开源框架，它们在企业级应用开发中扮演着重要角色。Quartz主要用于任务调度，而Spring Batch则专注于批量处理。在这个“quartz_springbatch_dynamic”项目中，我们将看到...
Spring 集成 Quartz
05-30
集成Spring和Quartz的好处在于，你能够利用Spring的依赖注入和AOP特性，使得任务的管理和维护变得更加灵活和简单。例如，Job可以直接注入服务层或DAO层的对象，实现业务逻辑。同时，Spring的声明式事务管理也能在Job...
quartz+spring集成完整开发，富含文档说明
09-11
Quartz和Spring是两个在Java开发中非常重要的框架。Quartz是一个开源的作业调度框架，它允许开发者创建、调度和管理任务，而Spring是一个全面的企业级应用开发框架，提供了依赖注入、面向切面编程以及丰富的模块，如...
Spring整合Quartz开发代码实例
08-19
3. 良好的可扩展性：Quartz提供了一个灵活的插件架构，使得开发者可以轻松地开发和集成新的插件来满足不同的需求。 4. spring框架的支持：Spring框架提供了一个强大的依赖注入机制，可以轻松地整合Quartz scheduler...
SpringColoud中集成Quartz集群_实现quartz分布式定时器--SpringCloud工作笔记179
添柴程序猿的专栏
06-24 718
首先实现分布式的定时器,其实就是在集群中要始终保持一个任务,只有一个实例中执行,而,quartz是基于数据库的锁来实现的,集群中的各个quartz之间是不通信的,而如果我们自己去设计的,也可以实现,之前我们就是基于,redis实现的,系统多活.这里说一下,如何在springboot的环境下实现quartz的集成,以及分布式使用:1.去创建数据库表mysql的表: 下载quartz集群需要创建的表，下载地址：Downloads去下载quartz以后,然后在:\docs\dbTables 在这个目录中有my
ssm面向品牌会员的在线商城.zip
11-09
基于SSM的毕业设计源码
高分springboot毕设+vue多彩吉安红色旅游网站的设计与实现_eewy-Java源码.zip
最新发布
11-09
本项目是一个基于Spring Boot和Vue.js技术栈的多彩吉安红色旅游网站的设计与实现。该项目旨在打造一个集信息展示、在线互动、旅游服务于一体的综合性红色旅游平台，通过信息化手段传承和弘扬吉安地区的红色文化。 项目的主要功能包括：红色景点介绍、旅游线路规划、在线预订服务、用户评论互动以及后台管理系统等。通过Spring Boot框架搭建的后端服务，实现了数据的存储、处理与业务逻辑；而Vue.js则用于构建用户友好的前端界面，提供了流畅的用户体验。 此外，项目还注重用户体验优化，通过响应式设计确保网站在不同设备上的良好展示效果。同时，后台管理系统为管理员提供了便捷的数据管理和内容更新功能，确保网站信息的实时性和准确性。 此项目不仅适合作为计算机相关专业学生的毕业设计，帮助他们提升实践能力和技术水平，也适合Java学习者进行项目实战练习，加深对相关技术的理解和应用。
技术资料分享SD卡2.0协议很好的技术资料.zip
11-09
技术资料分享SD卡2.0协议很好的技术资料.zip
Spring集成Quartz，动态配置定时任务调度
总之，Spring Quartz集成是一个非常有用的工具，可以帮助开发人员在Spring应用程序中轻松实现定时任务调度。它提供了丰富的API和配置方式，使得任务的管理变得更加简单和灵活。通过灵活配置任务的触发时间，并能自由...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值