Spring整合Quartz框架实现定时任务跑批（Maven完整版）

Quartz 介绍
Quartz is a full-featured, open source job scheduling service that can be integrated with, or

used along side virtually any Java application - from the smallest stand-alone application to

the largest e-commerce system. Quartz can be used to create simple or complex schedules for

executing tens, hundreds, or even tens-of-thousands of jobs;
Quartz框架是一个全功能、开源的任务调度服务，可以集成几乎任何的java应用程序—从小的单片机系统到大型
的电子商务系统。Quartz可以执行上千上万的任务调度。
Quartz核心的概念：scheduler任务调度、Job任务、Trigger触发器、JobDetail任务细节
Spring框架提供了对Quartz框架的支持，这对我们来说，方便了很多。我们还是通过Maven工程来演示。1，pom.xml配置文件内容如下：

<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.yangcq</groupId>
    <artifactId>SpringQuartzTest</artifactId>
    <version>1.0.0</version>
    <packaging>jar</packaging>
    <name>SpringQuartzTest</name>  

    <properties>
        <springframework.version>4.0.6.RELEASE</springframework.version><!-- Spring的版本 -->
        <quartz.version>2.2.1</quartz.version>                          <!-- Quartz的版本 -->
    </properties>  

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!-- Spring事务的依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springframework.version}</version>
        </dependency>  

        <!-- 定时任务框架Quartz的依赖-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>${quartz.version}</version>
        </dependency>  

    </dependencies>
</project>

2，定义我们自己的Job实现类。
Spring框架整合Quartz时，不是直接继承Job类，而是继承QuartzJobBean，
我们这里的一个实现如下：

package com.yangcq.quartz;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
/**
 *
 * @author yangcq
 * @description 由于Spring提供对Quartz的支持，所以直接使用Spring提供的API
 * @description 继承  org.springframework.scheduling.quartz.QuartzJobBean
 *
 */
public class EBankJob extends QuartzJobBean {
  /**
   *
   */
  private EBankJobBean eBankJobBean; 

  @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
    eBankJobBean.printAnotherMessage();
    }  

    public void setEBankJobBean(EBankJobBean eBankJobBean) {
        this.eBankJobBean = eBankJobBean;
    }  

}

这部分代码就是一个典型的spring注入，实际上调用了eBankJobBean的方法。具体job的执行是在executeInternal
方法里。
问题一：目前这种方法没有测试通过，分析一下什么原因？
问题二：MethodInvokingJobDetailFactoryBean 与 JobDetailBean 的区别，研究Spring源码
答：
1，QuartzJobBean是Spring框架下的一个抽象类，这个类实现了Quartz的Job接口。我们可以理解为，Spring对Job的
进一步封装，
public abstract class QuartzJobBean implements Job
2，JobDetailBean也是继承了Quartz下面的JobDetail接口，这里为什么是继承，本人也感到费解，按说JobDetail是
一个抽象接口，
应该用implements关键字实现这个接口，具体代码如下：
public class JobDetailBean extends JobDetail
3，MethodInvokingJobDetailFactoryBean，这个类为我们设置定时任务，提供了丰富的支持，如下：

  private String name;
  private String group;
  private boolean concurrent;
  private String targetBeanName;
  private String[] jobListenerNames;
  private String beanName;
  private ClassLoader beanClassLoader;
  private BeanFactory beanFactory;
  private JobDetail jobDetail;

package com.yangcq.quartz;
/**
 *
 * @author yangcq
 *
 */
public class EBankJobBean {
    public void printAnotherMessage(){
        System.out.println("CronTriggerBean 调用的定时任务...");
    }
}

因为是要将这些任务通过spring的配置文件来拼接到一起，我们来看看具体的配置文件该怎么设置。
在spring里，如果我们要执行一个计划任务，需要定义一个JobDetail，用它来封装我们具体执行的任务。结合前面纯quartz的示例，
我们发现它们其实本质上是一样的。这里的定义如下：
spring默认提供了一个叫MethodInvokingJobDetailFactoryBean，我们需要将定义好的对象和需要调用的方法传给它。
这里对应的是一种类型的jobDetail定义。对应的myBean定义如下：

package com.yangcq.quartz;
/**
 *
 * @author yangcq
 * @description SimpleTriggerFactoryBean 调用的定时任务
 */
public class MyJobBean {
    public void printMessage() {
        System.out.println("SimpleTriggerFactoryBean 调用的定时任务...");
    }
}

OK，下面写一个测试类，进行测试

package com.yangcq.quartz;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 *
 * @author yangcq
 * @description 启动定时任务main方法
 *
 */
public class StartUpQuartzJobs {

  static final Log log = LogFactory.getLog(StartUpQuartzJobs.class); // 日志

  public static void main(String args[]) throws Exception {
    log.info("开始启动定时任务 ...");
    ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
    log.info("定时任务启动成功...");
  }
}

接下来就是关键部分了，Spring核心配置文件的的配置，配置文件applicationContext.xml配置如下：

<?xml version="1.0" encoding="UTF-8"?>
<!-- Bean头部 -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
            http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd">  

    <!-- 启动包扫描功能，以便注册带有@Controller、@Service、@repository、@Component等注解的类成为spring的bean -->
    <context:component-scan base-package="com.yangcq.quartz" /> 

    <bean id="myJobBean" class="com.yangcq.quartz.MyJobBean"></bean>
    <bean id="eBankJobBean" class="com.yangcq.quartz.EBankJobBean"></bean>

    <bean id="simpleJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="myJobBean" />
        <property name="targetMethod" value="printMessage" />
    </bean>
    <!-- 这种封装的方式很简单，就是我定义了一个对象和它对应的方法。如果我们需要将它们封装成一个job了，只要把类的名字和 -->
    <!-- 对应的方法传进去就可以了。除了上述的JobDetail构造方式，还要一种更复杂一些，它的定义如下： -->
    <!--   这里因为要用到一些对象的引用，对这些对象或者参数的传递可以通过jobDataMap来处理。 -->
    <bean name="complexJobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="eBankJobBean" />
        <property name="targetMethod" value="printAnotherMessage" />
    </bean> 

    <!-- Spring提供了2中触发器：SimpleTriggerBean 和 CronTriggerBean -->

    <!-- Trigger触发器 ：从第1秒开始，每3秒执行一次 -->
    <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="simpleJobDetail" />
        <property name="startDelay" value="1000" />
        <property name="repeatInterval" value="3000" />
    </bean>
    <!-- Trigger触发器 ：从第1秒开始，每5秒执行一次 -->
    <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" ref="complexJobDetail" />
        <property name="cronExpression" value="0/5 * * * * ?" />
    </bean>  

    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="jobDetails">
            <list>
                <ref bean="simpleJobDetail" />
                <ref bean="complexJobDetail" />
            </list>
        </property>  

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

启动程序以后，控制台输出如下：
log4j:WARN No appenders could be found for logger (com.yangcq.quartz.StartUpQuartzJobs).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
SimpleTriggerFactoryBean 调用的定时任务...
CronTriggerBean 调用的定时任务...
SimpleTriggerFactoryBean 调用的定时任务...
CronTriggerBean 调用的定时任务...
SimpleTriggerFactoryBean 调用的定时任务...

总结
在这两个示例里，我们首先通过一个纯手工的过程来完成一个任务调度的示例。它的主要步骤为
1.定义job

  1. 定义trigger
  2. 定义scheduler来拼接。
    在后续使用spring的示例里，其实也是这么一个步骤，只不过spring提供了一些实现的支持，需要在配置文件里指定
    不同的jobDetail类型和trigger类型。

原文地址：http://blog.51cto.com/13981400/2294226

时间： 2024-07-31 12:52:26

Spring整合Quartz框架实现定时任务跑批（Maven完整版）的相关文章

使用Spring整合Quartz轻松完成定时任务

一.背景 上次我们介绍了如何使用Spring Task进行完成定时任务的编写,这次我们使用Spring整合Quartz的方式来再一次实现定时任务的开发,以下奉上开发步骤及注意事项等. 二.开发环境及必须jar包依赖 1.开发环境 Spring 4.2.6.RELEASE Maven 3.3.9 Jdk 1.7 Idea 15.04 2.必不可少jar包依赖 1 <dependency> 2 <groupId>org.springframework</groupId> 3

java 框架-spring 整合 quartz 框架 service层 注入不了job 类

    1.  spring  + quartz  启动 停止 添加job 功能  一 maven添加quartz  的jar 二 代码区 applicationContext.xml  导入 quartz.xml   <import resource="classpath:spring/quartz.xml"/> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns

Spring整合quartz框架实现任务定时调度

1.  首先需要引入需要的jar包,如上图所示. 2. 编写需要定时调度的测试类: package com.jp.task; import java.util.Date; public class TestTask{ private static int counter = 0; protected void execute() { long ms = System.currentTimeMillis(); System.out.println("\t\t" + "=====

spring整合quartz时间任务调度框架

spring整合quartz框架 1.创建maven工程 2.导入jar包(pom.xml) <dependencies> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.1</version> </dependency> <dependency&

Spring整合Quartz定时任务 在集群、分布式系统中的应用(Mysql数据库环境)

Spring整合Quartz定时任务 在集群.分布式系统中的应用(Mysql数据库环境) 转载:http://www.cnblogs.com/jiafuwei/p/6145280.html 单个Quartz实例能给予你很好的Job调度能力,但它不能满足典型的企业需求,如可伸缩性.高可靠性满足.假如你需要故障转移的能力并能运行日益增多的 Job,Quartz集群势必成为你应用的一部分了.使用 Quartz 的集群能力可以更好的支持你的业务需求,并且即使是其中一台机器在最糟的时间崩溃了也能确保所有的

Spring 3整合Quartz 2实现定时任务(转)

http://www.meiriyouke.net/?p=82 最近工作中需要用到定时任务的功能,虽然Spring3也自带了一个轻量级的定时任务实现,但感觉不够灵活,功能也不够强大.在考虑之后,决定整合更为专业的Quartz来实现定时任务功能. 首先,当然是添加依赖的jar文件,我的项目是maven管理的,以下的我项目的依赖: <dependencies> <dependency> <groupId>org.springframework</groupId>

spring整合quartz并持久化

spring整合quartz有两种方式: 一.常见是使用配置文件,将定时任务保存到内存中 简单示例: <!-- 短信催还提醒任务调度 --> <bean id="overdueRecall" class="com.sursen.souba.ddlibserve.quartz.OverdueRecallTimerTask" /> <!--定义定时执行overdueRecallTimerTask 这个bean中的overdueRecall(

Spring quartz Job不能依赖注入，Spring整合quartz Job任务不能注入

Spring quartz Job不能依赖注入,Spring整合quartz Job任务不能注入 Spring4整合quartz2.2.3中Job任务使用@Autowired不能注入 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ©Copyright 蕃薯耀 2017年9月6日 http://ww

Spring整合Quartz实现定时任务调度

一. 核心类 1. Job: 表示一个工作, 具体的业务处理都在这里. 2. JobDetail: 表示一个具体的可执行的调度程序. 3. Trigger: 用于调度参数的配置(什么时候去调用Job). 4. Scheduler: 表示一个调度容器, 容器中有一个线程池, 用来并行调度执行每个作业, 一个调度容器中可以注册多个JobDetail和Trigger. 二. 整合spring 1. 代码结构图: 2. applicationContext.xml <?xml version="1