`
dannyhz
  • 浏览: 397860 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
文章分类
社区版块
存档分类
最新评论

Quartz 1.7的例子 如何实现 schedule trigger job之间的调用

 
阅读更多
http://blog.csdn.net/liuxiao723846/article/details/46533059


引用


一、Quartz简介

Quartz是一个由James House创立的开源项目,是一个功能强大的作业调度工具,可以计划的执行任务,定时、循环或在某一个时间来执行我们需要做的事,这可以给我们工作上带来很大的帮助。例如,你的程序中需要每个月的一号导出报表、定时发送邮件或程序需要每隔一段执行某一任务……等等,都可以用Quartz来解决。


Quartz大致可分为三个主要的核心:


1、调度器Scheduler:是一个计划调度器容器,容器里面可以盛放众多的JobDetail和Trigger,当容器启动后,里面的每个JobDetail都会根据Trigger按部就班自动去执行.


2、任务Job:要执行的具体内容。JobDetail:具体的可执行的调度程序,包含了这个任务调度的方案和策略。


3、触发器Trigger:调度参数的配置,什么时候去执行调度。


可以这么理解它的原理:调度器就相当于一个容器,装载着任务和触发器。任务和触发器又是绑定在一起的,然而一个任务可以对应多个触发器,但一个触发器却只能对应一个任务。当JobDetail和Trigger在scheduler容器上注册后,形成了装配好的任务作业(JobDetail和Trigger所组成的一对儿),就可以伴随容器启动而调度执行了

二、实例:下面例子采用了quartz1.7实现两个任务(job)的切换、添加、移除
1、任务调度:
[java] view plain copy
package quartz; 
 
import org.quartz.CronTrigger; 
import org.quartz.JobDetail; 
import org.quartz.Scheduler; 
import org.quartz.SchedulerFactory; 
import org.quartz.impl.StdSchedulerFactory; 
 
/**
* @Description: 定时任务管理类

* @ClassName: QuartzManager
* @date 2014-6-26 下午03:15:52
* @version V2.0
*/ 
public class QuartzManager { 
    private static SchedulerFactory gSchedulerFactory = new StdSchedulerFactory(); 
    private static String JOB_GROUP_NAME = "EXTJWEB_JOBGROUP_NAME"; 
    private static String TRIGGER_GROUP_NAME = "EXTJWEB_TRIGGERGROUP_NAME"; 
 
    /**
     * @Description: 添加一个定时任务,使用默认的任务组名,触发器名,触发器组名
     * 
     * @param jobName
     *            任务名
     * @param cls
     *            任务
     * @param time
     *            时间设置,参考quartz说明文档
     * 
     * @date 2014-6-26 下午03:47:44
     * @version V2.0
     */ 
    @SuppressWarnings("unchecked") 
    public static void addJob(String jobName, Class cls, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            JobDetail jobDetail = new JobDetail(jobName, JOB_GROUP_NAME, cls);// 任务名,任务组,任务执行类 
            // 触发器 
            CronTrigger trigger = new CronTrigger(jobName, TRIGGER_GROUP_NAME);// 触发器名,触发器组 
            trigger.setCronExpression(time);// 触发器时间设定 
            sched.scheduleJob(jobDetail, trigger); 
            // 启动 
            if (!sched.isShutdown()) { 
                sched.start(); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 添加一个定时任务
     * 
     * @param jobName
     *            任务名
     * @param jobGroupName
     *            任务组名
     * @param triggerName
     *            触发器名
     * @param triggerGroupName
     *            触发器组名
     * @param jobClass
     *            任务
     * @param time
     *            时间设置,参考quartz说明文档
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:48:15
     * @version V2.0
     */ 
    @SuppressWarnings("unchecked") 
    public static void addJob(String jobName, String jobGroupName, 
            String triggerName, String triggerGroupName, Class jobClass, 
            String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            JobDetail jobDetail = new JobDetail(jobName, jobGroupName, jobClass);// 任务名,任务组,任务执行类 
            // 触发器 
            CronTrigger trigger = new CronTrigger(triggerName, triggerGroupName);// 触发器名,触发器组 
            trigger.setCronExpression(time);// 触发器时间设定 
            sched.scheduleJob(jobDetail, trigger); 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 修改一个任务的触发时间(使用默认的任务组名,触发器名,触发器组名)
     * 
     * @param jobName
     * @param time
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:49:21
     * @version V2.0
     */ 
    @SuppressWarnings("unchecked") 
    public static void modifyJobTime(String jobName, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            CronTrigger trigger = (CronTrigger) sched.getTrigger(jobName,TRIGGER_GROUP_NAME); 
            if (trigger == null) { 
                return; 
            } 
            String oldTime = trigger.getCronExpression(); 
            if (!oldTime.equalsIgnoreCase(time)) { 
                JobDetail jobDetail = sched.getJobDetail(jobName,JOB_GROUP_NAME); 
                Class objJobClass = jobDetail.getJobClass(); 
                removeJob(jobName); 
                addJob(jobName, objJobClass, time); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 修改一个任务的触发时间
     * 
     * @param triggerName
     * @param triggerGroupName
     * @param time
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:49:37
     * @version V2.0
     */ 
    public static void modifyJobTime(String triggerName, 
            String triggerGroupName, String time) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            CronTrigger trigger = (CronTrigger) sched.getTrigger(triggerName,triggerGroupName); 
            if (trigger == null) { 
                return; 
            } 
            String oldTime = trigger.getCronExpression(); 
            if (!oldTime.equalsIgnoreCase(time)) { 
                CronTrigger ct = (CronTrigger) trigger; 
                // 修改时间 
                ct.setCronExpression(time); 
                // 重启触发器 
                sched.resumeTrigger(triggerName, triggerGroupName); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 移除一个任务(使用默认的任务组名,触发器名,触发器组名)
     * 
     * @param jobName
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:49:51
     * @version V2.0
     */ 
    public static void removeJob(String jobName) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器 
            sched.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器 
            sched.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description: 移除一个任务
     * 
     * @param jobName
     * @param jobGroupName
     * @param triggerName
     * @param triggerGroupName
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:50:01
     * @version V2.0
     */ 
    public static void removeJob(String jobName, String jobGroupName, 
            String triggerName, String triggerGroupName) { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.pauseTrigger(triggerName, triggerGroupName);// 停止触发器 
            sched.unscheduleJob(triggerName, triggerGroupName);// 移除触发器 
            sched.deleteJob(jobName, jobGroupName);// 删除任务 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description:启动所有定时任务
     * 
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:50:18
     * @version V2.0
     */ 
    public static void startJobs() { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            sched.start(); 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 
 
    /**
     * @Description:关闭所有定时任务
     * 
     * 
     * @Title: QuartzManager.java
     * @date 2014-6-26 下午03:50:26
     * @version V2.0
     */ 
    public static void shutdownJobs() { 
        try { 
            Scheduler sched = gSchedulerFactory.getScheduler(); 
            if (!sched.isShutdown()) { 
                sched.shutdown(); 
            } 
        } catch (Exception e) { 
            throw new RuntimeException(e); 
        } 
    } 

2、具体的任务执行:
[java] view plain copy
package quartz; 
 
import java.text.SimpleDateFormat; 
import java.util.Date; 
 
import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
 
/**
* @Description: 任务执行类
*
* @ClassName: QuartzJob
* @date 2014-6-26 下午03:37:11
* @version V2.0
*/ 
public class QuartzJob implements Job { 
 
    @Override 
    public void execute(JobExecutionContext arg0) throws JobExecutionException { 
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "我是任务1-----------------");   
    } 


具体任务2:
[java] view plain copy
package quartz; 
 
import java.text.SimpleDateFormat; 
import java.util.Date; 
 
import org.quartz.Job; 
import org.quartz.JobExecutionContext; 
import org.quartz.JobExecutionException; 
 
/**
* @Description: 任务执行类
*
* @ClassName: QuartzJob
* @date 2014-6-26 下午03:37:11
* @version V2.0
*/ 
public class QuartzJob implements Job { 
 
    @Override 
    public void execute(JobExecutionContext arg0) throws JobExecutionException { 
        System.out.println(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date())+ "我是任务2===================");   
    } 


3、测试:
[java] view plain copy
package quartz; 
 
 
/**
* @Description: 测试
*
* @ClassName: QuartzTest
* @version V2.0
*/ 
public class QuartzTest { 
    public static void main(String[] args) { 
        try { 
            String job_name = "动态任务调度"; 
            System.out.println("【系统启动】开始(每1秒输出一次)...");   
            QuartzManager.addJob(job_name, QuartzJob.class, "0/1 * * * * ?");   
             
            Thread.sleep(5000);   
            System.out.println("【修改时间】开始(每2秒输出一次)...");   
            QuartzManager.modifyJobTime(job_name, "10/2 * * * * ?");   
            Thread.sleep(6000);   
            System.out.println("【移除定时】开始...");   
            QuartzManager.removeJob(job_name);   
            System.out.println("【移除定时】成功");   
             
            System.out.println("【再次添加定时任务】开始(每10秒输出一次)...");   
            QuartzManager.addJob(job_name+"1", QuartzJob1.class, "*/10 * * * * ?");   
            Thread.sleep(60000);   
            System.out.println("【移除定时】开始...");   
            QuartzManager.removeJob(job_name+"1");   
            System.out.println("【移除定时】成功"); 
        } catch (Exception e) { 
            e.printStackTrace(); 
        } 
    } 


代码下载:http://download.csdn.net/detail/liuxiao723846/8826285
文章参考:http://blog.csdn.net/pengpegv5yaya/article/details/37595889


分享到:
评论

相关推荐

    quartz1.7 jar包

    quartz1.7 jar包 可用

    Quartz1.7 动态添加、修改和删除定时任务(非spring集成版)

    4. **注册Job和Trigger**:调用`Scheduler`的`scheduleJob(JobDetail, Trigger)`方法,将`JobDetail`和`Trigger`关联到调度器。 5. **启动Scheduler**:调用`Scheduler`的`start()`方法,开始调度。 动态修改和...

    一个简单的实现quartz的例子

    这个"一个简单的实现quartz的例子"提供了基础的Quartz使用方法,虽然可能不包含所有功能,但足以帮助初学者理解其核心概念。 Quartz的核心组件包括: 1. **Job**:这是你要调度的任务,它定义了具体的工作逻辑。你...

    quartz实例,quartz入门例子

    1. **Job**:工作,它是实际要执行的任务,可以定义一个Java类实现`org.quartz.Job`接口来创建Job。 2. **Trigger**:触发器,决定Job何时执行。Quartz提供了多种类型的Trigger,如SimpleTrigger(简单触发器)和...

    quartz 1.7.3

    3. **定义作业和触发器**: 通过实现`org.quartz.Job`接口定义作业,然后创建对应的`Trigger`实例,将两者关联并添加到`Scheduler`中。 4. **使用JobDetailBuilder和TriggerBuilder**: Spring提供了便捷的API,如`...

    quartz集群

    Quartz允许开发者创建作业(Job)和触发器(Trigger),并安排它们在特定时间执行,非常适合在企业级应用中用于批处理或自动化任务。 这篇博客文章(链接已给出)可能涵盖了以下Quartz集群的关键知识点: 1. **...

    一个java Quartz的小例子

    在这个小例子中,我们将深入理解如何使用Java Quartz来实现定时任务。 首先,我们需要引入Quartz的依赖。在Maven项目中,可以在pom.xml文件中添加以下依赖: ```xml <groupId>org.quartz-scheduler ...

    一个最简单的定时任务Quartz的例子

    在Quartz中,我们通过实现`org.quartz.Job`接口来创建自定义的Job类,并通过`org.quartz.Trigger`来设定执行时间。 1. **引入依赖**:在项目中,你需要引入Quartz的依赖库。对于Maven项目,可以在pom.xml文件中添加...

    spring quartz简单例子

    3. **集成Spring与Quartz**:Spring提供了一个名为`SpringJDBCJobStore`的job存储实现,它允许Quartz使用Spring的数据源,简化数据库连接的管理。此外,Spring还提供了一个`SchedulerFactoryBean`,它是Quartz ...

    定时调用 Quartz.jar,实现定时调用

    使用`scheduleJob()`方法将`Job`与`Trigger`关联,告诉Quartz何时以及如何运行这个任务。 ```java scheduler.scheduleJob(job, trigger); ``` 7. **执行方法**: 在`IndexSchedulerJob`类的`execute()`方法中...

    Spring+Quartz实现任务调度的小例子

    在Spring中,我们可以定义一个实现了`org.springframework.scheduling.quartz.JobDetailBean`的bean,以及一个实现了`org.springframework.scheduling.quartz.CronTriggerBean`的bean,来分别表示Job和Trigger。...

    作业调度Quartz小例子

    scheduler.scheduleJob(job, trigger); scheduler.start(); ``` 在这个示例中,我们创建了一个名为 "myJob" 的 Job,并使用 CronScheduleBuilder 创建了一个每分钟触发的 CronTrigger。然后,我们将 Job 和 Trigger...

    Quartz2.2.1的15个例子的代码

    scheduler.scheduleJob(job, trigger); scheduler.start(); ``` 5. **CronTrigger** 使用Cron表达式定义复杂的触发时间,例如每天的8:30执行: ```java CronTrigger cronTrigger = (CronTrigger) ...

    quartz的基本使用,配置job,jobdetail,trigger,Scheduler

    1. **Job**:Job是执行的具体任务,它是实现了`org.quartz.Job`接口的类。你可以自定义Job类,实现你需要的任务逻辑。 2. **JobDetail**:JobDetail是Job的详细信息,它包含了Job的类信息以及一些附加属性。通过`...

    quartz包和官方例子

    - Quartz可以部署在集群环境中,多个Scheduler实例可以共享相同的Job和Trigger,实现高可用性和负载均衡。 5. **监听器**: - Quartz提供了多种监听器,如JobListener、TriggerListener和SchedulerListener,可以...

    quartz例子

    在博客中,作者可能详细解释了如何创建一个简单的Quartz应用,包括如何编写Job类,配置Trigger以及如何启动Scheduler。此外,还可能涉及了如何通过API动态修改或暂停Job的执行,以及如何处理并发执行和Job持久化等...

    quartz使用例子

    本文将基于提供的代码片段,深入解析Quartz的使用方法,包括如何定义Job、配置Trigger以及实现自定义的TriggerListener。 #### 一、定义Job 在Quartz中,Job是执行的具体任务。为了使用Spring框架进行整合,我们...

    Quartz Job Scheduling Framework 中文版

    而调度Job和Trigger则可以使用Scheduler的`scheduleJob()`方法。 5. **持久化**: Quartz支持将Job和Trigger的信息持久化到数据库或其他存储,这样即使应用重启,之前安排的作业也会自动恢复。这使得Quartz能够在...

    quartz所需要的jar包

    然后,可以通过创建Job类来定义要执行的任务,定义Trigger来决定任务何时执行。Quartz的Scheduler接口则用于启动、停止和管理这些任务。通过灵活的配置,开发者可以设置复杂的调度规则,如定时、间隔执行,甚至根据...

    quartz 调用两次任务

    在 Quartz 中,任务(Job)是通过实现 `org.quartz.Job` 接口的类来创建的,而调度则是通过 `Trigger` 对象来完成的。当一个任务被定义并附加到触发器后,Quartz 调度器会在指定的时间点启动这个任务。然而,如果一...

Global site tag (gtag.js) - Google Analytics