Java Quartz 2.2和Tomcat 7的简单示例

我想在java动态web应用程序中使用Quartz 2.2创建一个调度器。我不熟悉这项工作。我尝试了网上所有的教程。我正在尝试上下文侦听器方法来初始化调度程序。这好像不管用。hello world程序仅适用于一般java应用程序。对于web应用程序来说，它看起来很棘手

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/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>test.ananth</groupId>
<artifactId>test-app</artifactId>
<packaging>war</packaging>
<version>1.0-SNAPSHOT</version>
<name>test-app Maven Webapp</name>
<url>http://maven.apache.org</url>
<dependencies>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.apache.tomcat</groupId>
        <artifactId>servlet-api</artifactId>
        <version>6.0.30</version>
    </dependency>
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.16</version>
    </dependency>

    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
        <version>2.2.0</version>
    </dependency>

    <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-api</artifactId>
        <version>1.6.6</version>
    </dependency>

    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>3.8.1</version>
        <scope>test</scope>
    </dependency>
</dependencies>
<build>
    <finalName>test-app</finalName>
</build>

HelloJob.java：

    package com.test;

    import org.quartz.Job;
    import org.quartz.JobExecutionContext;
    import org.quartz.JobExecutionException;

    public class HelloJob implements Job {

public HelloJob() {
}

public void execute(JobExecutionContext context)
        throws JobExecutionException {

    System.out.println("Hello!  HelloJob is executing.");
}
    }

servlet.java 包com.test

import static org.quartz.JobBuilder.newJob;
import static org.quartz.SimpleScheduleBuilder.simpleSchedule;
import static org.quartz.TriggerBuilder.newTrigger;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServlet;

import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.impl.StdSchedulerFactory;

public class MyServlet extends HttpServlet {

    /**
     * 
     */
    private static final long serialVersionUID = 1567185871113714035L;

    public void init(ServletConfig cfg) {
        String key = "org.quartz.impl.StdSchedulerFactory.KEY";
        ServletContext servletContext = cfg.getServletContext();
        StdSchedulerFactory factory = (StdSchedulerFactory) servletContext
                .getAttribute(key);
        // Scheduler quartzScheduler = factory.getScheduler("MyQuartzScheduler");
        Scheduler sched;
        try {
            sched = factory.getScheduler("MyQuartzScheduler");
            //sched = factory.getScheduler();//MyQuartzScheduler
            sched.start();

            // define the job and tie it to our HelloJob class
            JobDetail job = newJob(HelloJob.class).withIdentity("myJob",
                    "group1").build();

            // Trigger the job to run now, and then every 40 seconds
            Trigger trigger = newTrigger()
                    .withIdentity("myTrigger", "group1")
                    .startNow()
                    .withSchedule(
                            simpleSchedule().withIntervalInSeconds(4)
                                    .repeatForever()).build();

            // Tell quartz to schedule the job using our trigger
            sched.scheduleJob(job, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

    }
}

Web.xml：

<!DOCTYPE web-app PUBLIC
 "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
 "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <context-param>
        <context-param>
            <param-name>quartz:shutdown-on-unload</param-name>
            <param-value>false</param-value>
        </context-param>
        <context-param>
            <param-name>quartz:wait-on-shutdown</param-name>
            <param-value>true</param-value>
        </context-param>
        <context-param>
            <param-name>quartz:start-scheduler-on-load</param-name>
            <param-value>true</param-value>
        </context-param>
        <context-param>
            <param-name>quartz:config-file</param-name>
            <param-value>/WEB-INF/quartz.properties</param-value>
        </context-param>

        <listener>
            <listener-class>
                org.quartz.ee.servlet.QuartzInitializerListener
            </listener-class>
        </listener>

        <listener>
            <listener-class>com.test.ApplicationStartup</listener-class>
        </listener>
        <display-name>Archetype Created Web Application</display-name>
</web-app>

石英：卸载时关机
假的
石英：等待关机
真的
quartz:加载时启动计划程序
真的
石英：配置文件
/WEB-INF/quartz.properties
org.quartz.ee.servlet.QuartzInitializerListener
com.test.ApplicationStartup
Web应用程序创建的原型

我正在使用maven web app archtype。

Contents

• Eclipse项目
• 和Maven
• 无XML

---

Eclipse项目 如果您使用的是eclipse中的典型项目，最基本的示例的结构类似于：

C:。
|
+---src
|| log4j.dtd
|| log4j.xml
||石英特性
|| quartz_data.xml
|   |
|\---组织
|\---保尔瓦加斯
|\---测试
|\---石英
|TestJob.java
|
\---网络内容
\---WEB-INF
|web.xml
|
\---解放党
jta-1.1.jar
log4j-1.2.17.jar
石英-2.1.5.jar
slf4j-api-1.6.5.jar
slf4j-log4j12-1.6.5.jar

其中每个文件的代码如下所示：

web.xml

org.quartz.ee.servlet.QuartzInitializerListener

quartz.properties

#------------------------------------线程-----------------#
#同时可以运行多少个作业？
org.quartz.threadPool.threadCount=5
#------------------------------------插件-----------------#
#类加载每个作业和触发器的配置数据。
#在本例中，数据位于XML文件中。
org.quartz.plugin.jobInitializer.class=org.quartz.plugins.xml.XMLSchedulingDataProcessorPlugin

quartz_data.xml

测试作业
org.paulvargas.test.quartz.TestJob
测试作业
测试作业
0 0/5 * 1/1 * ? *

作业每5分钟执行一次（请参见

cron expression

标记中的表达式

0/5*1/1*？*

）。如果需要另一个表达式，可以使用

TestJob.java

package org.paulvargas.test.quartz；
导入org.quartz.Job；
导入org.quartz.JobExecutionContext；
导入org.quartz.JobExecutionException；
公共类TestJob实现作业{
@凌驾
public void execute（最终作业执行上下文ctx）
抛出JobExecutionException异常{
System.out.println（“执行作业”）；
}
}

log4j.xml

---

和Maven 如果您使用的是Maven，则同一项目的结构为：

C:。
|pom.xml
|
\---src
\---主要
+---爪哇
|\---组织
|\---保尔瓦加斯
|\---测试
|\---石英
|TestJob.java
|
+---资源
|log4j.dtd
|log4j.xml
|石英晶体特性
|quartz_data.xml
|
\---网络应用
|index.jsp
|
\---WEB-INF
web.xml

文件

pom.xml

：

4.0.0
测试
巴西夸茨
战争
1.0-快照
巴西夸茨
http://maven.apache.org
javax.servlet
servlet api
2.5
假如
org.quartz-scheduler
石英
2.2.1
org.quartz-scheduler
石英工作
2.2.1
javax.transaction
jta
1.1
org.slf4j
slf4j-log4j12
1.7.5
org.apache.maven.plugins
maven编译器插件
2.0.2
1.5
1.5

---

无XML *这需要servet3.0+（tomcat7+、glassfish3+、jbossas7）

您只需要两个文件：

TestJob.java

来自上一个示例和以下侦听器：

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.annotation.WebListener;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.quartz.impl.StdSchedulerFactory;

@WebListener
public class QuartzListener extends QuartzInitializerListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        super.contextInitialized(sce);
        ServletContext ctx = sce.getServletContext();
        StdSchedulerFactory factory = (StdSchedulerFactory) ctx.getAttribute(QUARTZ_FACTORY_KEY);
        try {
            Scheduler scheduler = factory.getScheduler();
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("simple").withSchedule(
                    CronScheduleBuilder.cronSchedule("0 0/1 * 1/1 * ? *")).startNow().build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (Exception e) {
            ctx.log("There was an error scheduling the job.", e);
        }
    }

}

为避免冲突，请不要同时在

web.xml

中设置默认侦听器。在最后一个示例中，默认线程数为10。由于调度程序是在待机模式下启动的，因此需要调用

scheduler.start（）。
“simple”
标识是可选的，但是您可以使用它来重新安排作业（太好了！）。e、 g:

谢谢那太完美了，我刚刚解决了我的项目相关问题。感谢大家，对我来说，关于SOF问题的最佳答案之一是类不允许我从spring中注入参数。使用Tomcat 7，当添加侦听器并将JAR放在服务器库文件夹中时，我会收到一条错误listenerStart消息。当我将JAR移动到应用程序WEB-INF/lib时，它还会产生错误：似乎已启动线程。。。但却未能阻止它。说到石英，Tomcat是一个特例吗？@AndreaLigios真棒！：D优秀的研究和分析能力。现在是更新答案的时候了。谢谢分享
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.annotation.WebListener;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.ee.servlet.QuartzInitializerListener;
import org.quartz.impl.StdSchedulerFactory;

@WebListener
public class QuartzListener extends QuartzInitializerListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        super.contextInitialized(sce);
        ServletContext ctx = sce.getServletContext();
        StdSchedulerFactory factory = (StdSchedulerFactory) ctx.getAttribute(QUARTZ_FACTORY_KEY);
        try {
            Scheduler scheduler = factory.getScheduler();
            JobDetail jobDetail = JobBuilder.newJob(TestJob.class).build();
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity("simple").withSchedule(
                    CronScheduleBuilder.cronSchedule("0 0/1 * 1/1 * ? *")).startNow().build();
            scheduler.scheduleJob(jobDetail, trigger);
            scheduler.start();
        } catch (Exception e) {
            ctx.log("There was an error scheduling the job.", e);
        }
    }

}

ServletContext ctx = request.getServletContext();
StdSchedulerFactory factory = (StdSchedulerFactory) ctx.getAttribute(QuartzListener.QUARTZ_FACTORY_KEY);
Scheduler scheduler = factory.getScheduler();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("simple").withSchedule(
        CronScheduleBuilder.cronSchedule(newCronExpression)).startNow().build();
Date date = scheduler.rescheduleJob(new TriggerKey("simple"), trigger);