Spirng整合Quartz构建MAVEN工程

最新推荐文章于 2024-09-01 16:17:46 发布
最新推荐文章于 2024-09-01 16:17:46 发布
阅读量1.5k 收藏 1
点赞数 1
分类专栏： 框架 文章标签： quartz spring maven 技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smile_Miracle/article/details/70597551
版权

定时任务在许多项目中是要实时用到的一种技术，比较简单的定时任务我们可以运用Apache自带的Timer定时工具类来完成，但是相对于项目具体的定时而言这个工具类就有点力不从心，这里不做多演示。这里我们说一下Spring整合Quartz构建Maven工程放入LINUX系统直接执行的方式,框架选型用的是SSM（Spring 4, Mybatis 3,Quartz 2.2）

第一步：POM文件

基于本人已经搭好的工程直接黏贴代码：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.lyt.springQtz</groupId>
  <artifactId>spring-quartz</artifactId>
  <version>0.0.1-SNAPSHOT</version>

       <properties>  
            <spring.version>4.0.2.RELEASE</spring.version>  
            <quartz.version>2.2.2</quartz.version>  
            <slf4j.version>1.6.1</slf4j.version>
            <jackson.version>1.9.13</jackson.version>
            <comLog.version>1.1.1</comLog.version>
            <fastJackson.version>2.8.6</fastJackson.version>
        </properties>  

        <dependencies> 
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>${fastJackson.version}</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.module</groupId>
                <artifactId>jackson-module-jaxb-annotations</artifactId>
                <version>${fastJackson.version}</version>
            </dependency>
            <dependency>
                <groupId>net.sf.json-lib</groupId>
                <artifactId>json-lib</artifactId>
                <version>2.4</version>
                <classifier>jdk15</classifier>指定jdk版本
            </dependency>
            <dependency>
                <groupId>commons-logging</groupId>
                <artifactId>commons-logging</artifactId>
                <version>${comLog.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>${slf4j.version}</version>
            </dependency>
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-log4j12</artifactId>
                <version>${slf4j.version}</version>
            </dependency>   
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-aop</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-beans</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-core</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-expression</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-jdbc</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-tx</artifactId>
                <version>${spring.version}</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <version>5.1.10</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis</artifactId>
                <version>3.1.1</version>
            </dependency>
            <dependency>
                <groupId>org.mybatis</groupId>
                <artifactId>mybatis-spring</artifactId>
                <version>1.2.1</version>
            </dependency>
            <dependency>
                <groupId>c3p0</groupId>
                <artifactId>c3p0</artifactId>
                <version>0.9.1.2</version>
            </dependency>       
            <dependency>
                <groupId>org.aspectj</groupId>
                <artifactId>aspectjweaver</artifactId>
                <version>1.6.8</version>
            </dependency>   

            <!-- Quartz framework -->  
            <dependency>  
                <groupId>org.quartz-scheduler</groupId>  
                <artifactId>quartz</artifactId>  
                <version>${quartz.version}</version>  
            </dependency>  
        </dependencies>  

        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <configuration>
                        <source>1.8</source>
                        <target>1.8</target>
                        <encoding>UTF-8</encoding>
                    </configuration>
                </plugin>
            </plugins>
        </build>

</project>

第二步：配置文件

一般项目中的定时任务都会基于数据库，这里对于mybatis整合spring和mybatis的基本配置就不做多演示，如果想要具体项目的可以下载：spring整合和Quartz实现定时任务调度

我们这里主要演示一下Spring整合quartz的配置文件编写，首先是具体的一些参数说明如下：

spring配置quartz 参数说明

配置文件：


<?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" 
    xmlns:task="http://www.springframework.org/schema/task"
    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
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd ">

    <!-- 扫描任务bean  -->  
    <context:component-scan base-package="com.zhy.quartz.job" />

    <bean id="simpleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
        <property name="targetObject" ref="simpleJob" />
        <property name="targetMethod" value="execute" />  
    </bean>  

    <!-- 增强型Job,每次执行过程中对其进行 增强-->  
    <bean name="firstComplexJobDetail"    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="com.zhy.quartz.job.FirstJob" />  
        <property name="jobDataMap">  
            <map>  
                <entry key="anotherJob" value-ref="anotherJob" />  
            </map>  
        </property> 
        <property name="durability" value="true" />  
    </bean> 

    <!-- 普通Job,实现QuartzJobBean接口成为受quartz scheduler管理的Job -->  
    <bean name="secondComplexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="com.zhy.quartz.job.SecondJob" />  
        <property name="durability" value="true" />  
    </bean>  

    <!-- ：简单触发器，使用 SimpleTriggerFactoryBean 你可以定义作业的启动时间、触发器之间的延迟时间以及 repeatInterval(频率) --> 
    <bean id="simpleTrigger"  class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">  
        <property name="jobDetail" ref="simpleJobDetail" />  
        <!-- 定义执行几次 -->
        <property name="startDelay" value="1000" />  
        <!-- 定义执行的间隔时间 -->
        <property name="repeatInterval" value="5000" />  
    </bean>


    <!-- 计划触发器，使用 CronTriggerFactoryBean 这种类型更加灵活，允许你针对特定实例选择计划方案以及将来要执行的频率 --> 
    <bean id="cronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="firstComplexJobDetail" />  
        <!--<property name="cronExpression" value="0/5 * * ? * SAT-SUN" />-->  
        <property name="cronExpression" value="${cron.firstJob}" />  
    </bean>  

    <!-- Run the job every 10 seconds -->      
    <bean id="secondCronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="secondComplexJobDetail" />  
        <property name="cronExpression" value="${cron.secondJob}" />  
    </bean>  


    <!-- SchedulerFactoryBean 将 jobDetails 和 triggers 整合在一起以配置 Quartz 调度器 -->  
    <bean  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="jobDetails">  
            <list>  
                <ref bean="simpleJobDetail" />  
                <ref bean="firstComplexJobDetail" />  
                <ref bean="secondComplexJobDetail" />  
            </list>  
        </property>  

        <property name="triggers">  
            <list>  
                <ref bean="simpleTrigger" />  
                <ref bean="cronTrigger" />  
                <ref bean="secondCronTrigger" />  
            </list>  
        </property>  
    </bean> 

</beans>

进行一下一步之前我们得说一下两个触发器工厂SimpleTriggerFactoryBean和CronTriggerFactoryBean之间的区别：

SimpleTrigger 当需要在规定的时间执行一次或在规定的时间段以一定的时间间隔重复触发执行Job时，SimpleTrigger就可以满足要求；SimpleTrigger的属性有：开始时间、结束时间、重复次数和重复的时间间隔，重复次数属性的值可以为0、正整数、或常量 SimpleTrigger.REPEAT_INDEFINITELY，重复的时间间隔属性值必须为0或长整型的正整数，以毫秒作为时间单位，当重复的时 间间隔为0时，意味着与Trigger同时触发执行（或几乎与Scheduler开始时同时触发执行）。如果有指定结束时间属性值，则结束时间属性优先于重复次数属性，这样的好处在于：当我们需要创建一个每间隔10秒钟触发一次直到指定的结束时间的 Trigger，而无需去计算从开始到结束的所重复的次数，我们只需简单的指定结束时间和使用REPEAT_INDEFINITELY作为重复次数的属性 值即可（我们也可以指定一个比在指定结束时间到达时实际执行次数大的重复次数）。

配置文件示例 :
执行2次
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
  <!--指定触发器关联的作业-->  
  <property name="jobDetail">  
      <ref bean="weekJobDetailFactoryBean"/>  
  </property>  
  <!--延迟10s-->  
  <property name="startDelay">  
      <value>10000</value>  
  </property>  
  <!--每60s启动一次-->  
  <property name="repeatInterval">  
      <value>60000</value>  
 </property>  
<!--重复一次-->  
 <property name="repeatCount">  
      <value>1</value>  
 </property>  
</bean>
执行1次：

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
  <property name="jobDetail">  
      <ref bean="weekJobDetailFactoryBean"/>  
  </property>  
  <property name="startDelay">  
      <value>10000</value>  
  </property>  
  <property name="repeatInterval">  
      <value>20000</value>  
 </property>  
 <property name="repeatCount">  (去掉可以按结束时间来循环，否则执行完后不会在执行了即使endTime时间没到)
      <value>0</value>  
 </property>  
    <property name="startTime">  
        <value>2013-08-14 11:07:00</value>  
    </property> 
 <property name="endTime"  value="2014-06-30 18:22:00" />  
</bean>

<bean id="dateEditor"   class="org.springframework.beans.propertyeditors.CustomDateEditor">   
      <constructor-arg>   
          <bean class="java.text.SimpleDateFormat">   
              <constructor-arg value="yyyy-MM-dd HH:mm:ss" />   
          </bean>   
      </constructor-arg>   
      <constructor-arg value="true" />   
</bean>   

   <bean class="org.springframework.beans.factory.config.CustomEditorConfigurer">   
       <property name="customEditors">   
           <map>   
               <entry key="java.util.Date">   
                   <ref local="dateEditor" />   
               </entry>   
           </map>   
       </property>   
   </bean>

CronTrigger 支持比 SimpleTrigger 更具体的调度，而且也不是很复杂。基于 cron 表达式，CronTrigger 支持类似日历的重复间隔，而不是单一的时间间隔。

Cron 表达式包括以下 7 个字段：

格式: [秒] [分] [小时] [日] [月] [周] [年]
序号 说明 是否必填 允许填写的值 允许的通配符
1 秒 是 0-59 , - * /
2 分 是 0-59 , - * /
3 小时 是 0-23 , - * /
4 日 是 1-31 , - * ? / L W
5 月 是 1-12 or JAN-DEC , - * /
6 周 是 1-7 or SUN-SAT , - * ? / L #
7 年 否 empty 或 1970-2099 , - * /

通配符说明：
1. 反斜线（/）字符表示增量值。例如，在秒字段中“5/15”代表从第 5 秒开始，每 15 秒一次。
2. 星号（）字符是通配字符，表示该字段可以接受任何可能的值（例如:在分的字段上设置 ““,表示每一分钟都会触发）。
3. 问号（?）问号表示这个字段不包含具体值。所以，如果指定月内日期，可以在月内日期字段中插入“?”，表示周内日期值无关紧要。字母 L 字符是 last 的缩写。放在月内日期字段中，表示安排在当月最后一天执行。在周内日期字段中，如果“L”单独存在，就等于“7”，否则代表当月内周内日期的最后一个实例。所以“0L”表示安排在当月的最后一个星期日执行。
4. - 表示区间，例如 在小时上设置 “10-12”,表示 10,11,12点都会触发。
5. 逗号（, ） 表示指定多个值，例如在周字段上设置 “MON,WED,FRI” 表示周一，周三和周五触发
6. 井号（#）字符为给定月份指定具体的工作日实例。把“MON#2”放在周内日期字段中，表示把任务安排在当月的第二个星期一。
7. L 表示最后的意思。在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于”7”或”SAT”。如果在”L”前加上数字，则表示该数据的最后一个。例如在周字段上设置”6L”这样的格式,则表示“本月最后一个星期五”。
8. W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置”15W”，表示离每月15号最近的那个工作日触发。如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。如果指定格式为 “1W”,它则表示每月1号往后最近的工作日触发。如果1号正是周六，则将在3号下周一触发。(注，”W”前只能设置具体的数字,不允许区间”-“)。
注：’L’和 ‘W’可以一组合使用。如果在日字段上设置”LW”，则表示在本月的最后一个工作日触发。

常用示例:
0 10 * * * ?————–每个小时过10分执行一次
0 0/32 8,12 * * ? ———-每天8:32,12:32 执行一次
0 0/2 * * * ?————–每2分钟执行一次
0 0 12 * * ?—————在每天中午12：00触发
0 15 10 ? * *—————每天上午10:15 触发
0 15 10 * * ?—————每天上午10:15 触发
0 15 10 * * ? *—————每天上午10:15 触发
0 15 10 * * ? 2005—————在2005年中的每天上午10:15 触发
0 * 14 * * ?—————每天在下午2：00至2：59之间每分钟触发一次
0 0/5 14 * * ?—————每天在下午2：00至2：59之间每5分钟触发一次
0 0/5 14,18 * * ?—————每天在下午2：00至2：59和6：00至6：59之间的每5分钟触发一次
0 0-5 14 * * ?—————每天在下午2：00至2：05之间每分钟触发一次
0 10,44 14 ? 3 WED—————每三月份的星期三在下午2：00和2：44时触发
0 15 10 ? * MON-FRI—————从星期一至星期五的每天上午10：15触发
0 15 10 15 * ?—————在每个月的每15天的上午10：15触发
0 15 10 L * ?—————在每个月的最后一天的上午10：15触发
0 15 10 ? * 6L—————在每个月的最后一个星期五的上午10：15触发
0 15 10 ? * 6L 2002-2005—————在2002, 2003, 2004 and 2005年的每个月的最后一个星期五的上午10：15触发
0 15 10 ? * 6#3—————在每个月的第三个星期五的上午10：15触发
0 0 12 1/5 * ?—————从每月的第一天起每过5天的中午12：00时触发
0 11 11 11 11 ?—————在每个11月11日的上午11：11时触发.

项目中我们多用到的是Cron表达式的运用，具体如何配置可以自己百度Cron表达式在线生成工具，我们只需要把我们相应的任务类继承QuartzJobBean类然后在配置文件cron.properties写好这个任务的表达式然后在整合文件Spring-quartz中将其配置好即可，如下：

<bean id="cronTrigger"  class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">  
        <property name="jobDetail" ref="firstComplexJobDetail" />  
        <!--<property name="cronExpression" value="0/5 * * ? * SAT-SUN" />-->  
        <property name="cronExpression" value="${cron.firstJob}" />  
    </bean>

然后我们再来说说Quartz之所以能实现任务调度的一个关键核心：SchedulerFactoryBean
顾名思义，这是一个调度器工厂，他是用来统一对实现了quartz定时任务的Bean文件的一个配置和调度，他自动把我们给这些Job设置的触发时间和具体任务执行Bean完美的整合从而实现定时任务的调度。这里就不细说。值得注意的是如果你配置了三个任务实体那么就应该有相应的三个触发器，这都是实时对应的,如下：

 <!-- SchedulerFactoryBean 将 jobDetails 和 triggers 整合在一起以配置 Quartz 调度器 -->  
    <bean  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="jobDetails">  
            <list>  
                <ref bean="simpleJobDetail" />  
                <ref bean="firstComplexJobDetail" />  
                <ref bean="secondComplexJobDetail" />  
            </list>  
        </property>  

        <property name="triggers">  
            <list>  
                <ref bean="simpleTrigger" />  
                <ref bean="cronTrigger" />  
                <ref bean="secondCronTrigger" />  
            </list>  
        </property>  
    </bean>

第三步：任务BEAN

实现任务bean其实简单，你只需要继承QuartzJobBean类即可，或者指定好Job名字和方法在配置文件中写好。就像线程，你只有实现了Runnable接口或者继承Thread类程序才会将其认作是一个线程。值得注意的是一个地方，其实只要你继承了QuartzJobBean类然后在配置文件中将其配置好就可以运行了，而quartz的配置中有个对当前任务进行增强的方法，如下：

①不用继承的方式：

整合文件配置：

 <bean id="simpleJobDetail"        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">  
        <property name="targetObject" ref="simpleJob" />
        <property name="targetMethod" value="execute" />  
    </bean>

具体任务类：

package com.zhy.quartz.job;

import org.springframework.stereotype.Component;

@Component("simpleJob")
public class SimpleJob {

    public void execute(){

        System.out.println("This is the simpleJob data");
    }

}

就像你看到的，指明方法和Job名，spring容器会自动装填。

②继承QuartzJobBean类的普通类型：

整合文件配置：

 <!-- 普通Job,实现QuartzJobBean接口成为受quartz scheduler管理的Job -->  
    <bean name="secondComplexJobDetail" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="com.zhy.quartz.job.SecondJob" />  
        <property name="durability" value="true" />  
    </bean>

具体任务类：

package com.zhy.quartz.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

@Component("secondJob")
public class SecondJob extends QuartzJobBean{

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        System.out.println("This is the second test data");
    }
}

③继承QuartzJobBean类的增强类型：

整合配置文件：

<!-- 增强型Job,每次执行过程中对其进行增强-->  
    <bean name="firstComplexJobDetail"    class="org.springframework.scheduling.quartz.JobDetailFactoryBean">  
        <property name="jobClass" value="com.zhy.quartz.job.FirstJob" />  
        <property name="jobDataMap">  
            <map>  
                <entry key="anotherJob" value-ref="anotherJob" />  
            </map>  
        </property> 
        <property name="durability" value="true" />  
    </bean> 

  <!-- SchedulerFactoryBean 将 jobDetails 和 triggers 整合在一起以配置 Quartz 调度器 -->  
    <bean  class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
        <property name="jobDetails">  
            <list>  
                <ref bean="simpleJobDetail" />  
                <ref bean="firstComplexJobDetail" />  
                <ref bean="secondComplexJobDetail" />  
            </list>  
        </property>  

        <property name="triggers">  
            <list>  
                <ref bean="simpleTrigger" />  
                <ref bean="cronTrigger" />  
                <ref bean="secondCronTrigger" />  
            </list>  
        </property>  
    </bean>

具体实现类：

package com.zhy.quartz.job;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Component;

@Component("firstJob")
public class FirstJob extends QuartzJobBean{

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        AnotherJob anotherJob = (AnotherJob) arg0.getMergedJobDataMap().get("anotherJob"); 
        System.out.println("This is the first test data");
        anotherJob.execute();
    }

}


package com.zhy.quartz.job;

import org.springframework.stereotype.Component;

@Component("anotherJob")
public class AnotherJob {

    public void execute(){

        System.out.println("This is another job data");
    }

}

第四步：配置Core代码执行

package com.zhy.quartz.core;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class QuartzCore {

    public static void main(String[] args) {
        System.out.println("Quartz is started.......");
        ApplicationContext context = new ClassPathXmlApplicationContext("spring/applicationContext-beans.xml");

    }

}

下面贴上bean配置文件代码：

<?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" 
    xmlns:task="http://www.springframework.org/schema/task"
    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
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-4.0.xsd ">

     <!-- 自动扫描job包 ,将带有注解的类 纳入spring容器管理 -->  
    <context:component-scan base-package="com.zhy.quartz"></context:component-scan>  

    <!-- 导入c3p0 properties -->
    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="locations">
            <array>  
                <value>classpath:env/*.properties</value>
            </array>  
        </property>  
    </bean>

    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="user" value="${db.user}"/>
        <property name="password" value="${db.password}"/>
        <property name="driverClass" value="${db.driverClass}"/>
        <property name="jdbcUrl" value="${db.jdbcUrl}"/>
        <property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
        <property name="minPoolSize" value="${c3p0.minPoolSize}"/>
        <property name="initialPoolSize" value="${c3p0.initialPoolSize}"/>
        <property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>
        <property name="acquireRetryAttempts" value="${c3p0.acquireRetryAttempts}"/>
        <property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>
        <property name="testConnectionOnCheckin" value="${c3p0.testConnectionOnCheckin}"/>
        <property name="automaticTestTable" value="${c3p0.automaticTestTable}"/>
        <property name="numHelperThreads" value="${c3p0.numHelperThreads}"/>
    </bean>

    <import resource="classpath:mybatis/applicationContext-mybatis.xml"/>
    <import resource="classpath:spring/applicationContext-transaction.xml"/>
    <import resource="classpath:spring/applicationContext-quartz.xml"/>

</beans>

具体的东西下载链接都有，大家可以一起探讨，配置好这个项目然后写好自己定时任务编写好linux指令执行这段Core代码即可在linux中运行你的定时任务。

Quartz在Maven项目的应用
小思的博客
11-22 8146
此篇博文主要介绍Quartz在Maven项目的应用，Quartz怎样在项目中启动，怎样实现一个简单的Quartz案例? 步骤： ①在项目新建一个quartz包 ②在quartz包下新建 DemoQuartz.java类（定时器的启动类） package com.zs.quartz.quartz.demo; import org.quartz.*; import org.quartz.impl.S...
spring+quartz+maven项目实例
12-19
【标题】"Spring+Quartz+Maven项目实例"是一个基于Spring框架集成Quartz作业调度库的实战项目，采用Maven作为构建工具。这个实例旨在展示如何在Java应用程序中实现定时任务，支持两种运行模式，既可以直接以独立的...
搭建springMVC+Mybatis+quartz+log4j+maven项目
07-01
搭建springMVC+Mybatis+quartz+log4j+maven项目
maven下整合spring和quartz
weixin_34414196的博客
07-28 104
2019独角兽企业重金招聘Python工程师标准>>> ...
Quartz任务调度框架
最新发布
qq_51076441的博客
09-01 947
Quartz作为 Spring 默认的调度框架，与 Spring 集成实现灵活可配置的调度功能，此外其支持多种调度方法，应用方式灵活，并具有分布式和集群能力。驱动流程：比如在确定时间后根据任务完成情况触发一个警告并通知系统维护：在具体时间点调度一个数据从数据库转到xml文件中在应用中提供消息提醒服务。
Maven项目下的Spring Quartz简单集成
wojiaolurenjia的博客
06-21 499
Quartz的简单集成
纯净版quartz定时任务【maven】
dbd5775的博客
06-28 201
Quartz是一个完全由Java编写的开源作业调度框架，为在Java应用程序中进行作业调度提供了简单却强大的机制。Quartz允许开发人员根据时间间隔来调度作业。它实现了作业和触发器的多对多的关系，还能把多个作业与不同的触发器关联。 简单的介绍一下下面的Quartz项目包括如何调度其他的类。 搭建定时任务服务 首先新建一个maven项目 然后配置pom文件，我们需要引如下ja...
spring整合quartz动态定时任务demo-spring-quartz-demo.zip
11-07
在Spring整合Quartz的过程中，我们需要完成以下步骤： 1. **引入依赖**：在项目的Maven或Gradle配置文件中添加Quartz和Spring相关库的依赖。 2. **配置Quartz**：在Spring的配置文件（如`applicationContext.xml`...
Java_Spring与Quartz的整合
08-11
通过以上步骤，我们可以实现Spring和Quartz的无缝整合，构建出一个强大且灵活的定时任务系统。注意，实际项目中还需要根据需求进行详细的配置和优化，确保系统的稳定性和性能。同时，提供的压缩包文件中并没有包含...
spring3.2+quartz2+maven
08-12
标题 "spring3.2+quartz2+maven" 指的是一个集成项目，它将Spring框架3.2版本、Quartz作业调度库2.0版本以及Maven构建工具结合在一起，用于创建一个具备定时任务功能的应用。在这个项目中，Spring提供依赖注入和管理...
spring整合quartz
08-02
首先，创建一个Maven工程是必要的，因为Maven是Java开发的标准构建工具，它可以帮助我们管理项目依赖。在`pom.xml`文件中，你需要添加Spring和Quartz的依赖。例如： ```xml <!-- Spring dependencies --> ...
maven-quartz（定时任务）最简单版本
05-12
maven-quartz（定时任务）最简单版本
maven_spring_quartz.rar
05-07
Spring集成的Quartz例子
quartz+maven，Java定时器
04-26
定时器模板，使用maven创建，里面有一个例子，加载后导入Tomcat可以直接看到效果，可直接修改。如果报错注意修改运行环境
quartz的maven依赖_Spring整合Quartz框架实现定时任务跑批（Maven完整版）
weixin_39745345的博客
12-22 541
Quartz 介绍Quartz is a full-featured, open source job scheduling service that can be integrated with, orused along side virtually any Java application - from the smallest stand-alone application tothe l...
ssm+maven+quarzt+redis框架整合
weixin_38374033的博客
03-20 349
1:创建maven项目 idea-&gt;file-&gt;new project-&gt;maven 创建maven项目点击加好添加一个name=archerypeVersion,value=RELEASE可以加快maven的项目的构建点击next完成刚创建完的目录： 添加java文件夹，设置根目录创建项目目录：2：编写pom.xml文件引入jar包  pom.xml&lt;project xm...
使用maven 创建Quartz 任务示例_01
Gblfy_Blog
08-16 669
文章目录1. 创建maven项目2. 添加Quartz 依赖3. 编写Quartz配置文件4. 编写Job实现类5. 编写main函数，创建Scheduler6. 创建JobDetail7. 编写Trigger，添加JobDetail8. 启动main函数，体验Quartz定时任务 Quartz 支持集群，但不支持分布式，简言之，一台服务器上执行不同定时任务。 1. 创建maven项目 2. 添加Quartz 依赖 <!-- https://mvnrepository.com/artifact
IEDA基于Spring Boot项目服务搭建QuartzJobBean实现定时任务调度(包含服务目录结构)详解
zhx__的博客
12-24 3664
IEDA基于Spring Boot项目服务搭建QuartzJobBean实现定时任务调度(包含服务目录结构)详解 文章目录IEDA基于Spring Boot项目服务搭建QuartzJobBean实现定时任务调度(包含服务目录结构)详解前言一、什么是QuartzJobBean任务调度？二、创建项目1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下
Spring boot集成quartz
weixin_42502300的博客
06-16 86
1、pom文件 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.o
Spring Boot与Quartz构建分布式任务调度平台
此外，Spring Boot集成了大量常用框架的Starter POMs，极大地简化了项目构建配置。 知识点二：Quartz调度器 Quartz是一个开源的作业调度库，它可以集成到任何Java应用程序中，从一个简单的独立应用程序到大型电子...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值