Spirng整合Quartz构建MAVEN工程

最新推荐文章于 2023-08-06 22:41:07 发布

Smile_Miracle

最新推荐文章于 2023-08-06 22:41:07 发布

阅读量1.5k

点赞数 1

本文链接：https://blog.csdn.net/Smile_Miracle/article/details/70597551

版权

框架专栏收录该内容

18 篇文章 0 订阅

订阅专栏

定时任务在许多项目中是要实时用到的一种技术，比较简单的定时任务我们可以运用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中运行你的定时任务。

Smile_Miracle

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Spirng整合Quartz构建MAVEN工程

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

扫一扫