初识Quartz（一）

首先需要一个任务：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

package quartz_project;

import java.util.Date;

import org.quartz.Job;

import org.quartz.JobExecutionContext;

import org.quartz.JobExecutionException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 一个简单的任务：打印Hello World

 *

 * @author caijw

 */

public class HelloJob implements Job {

    

    private static Logger _log = LoggerFactory.getLogger(HelloJob.class);

    @Override

    public void execute(JobExecutionContext ctx) throws JobExecutionException {

        //打印Hello World! - 当前日期

        _log.info("Hello World! - " + new Date());

    }

}

由上面代码可以看出，任务类要实现job接口，在execute方法中是任务的具体实现。

然后设定调度策略：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

package quartz_project;

import java.util.Date;

import org.quartz.DateBuilder;

import org.quartz.JobBuilder;

import org.quartz.JobDetail;

import org.quartz.Scheduler;

import org.quartz.SchedulerFactory;

import org.quartz.Trigger;

import org.quartz.TriggerBuilder;

import org.quartz.impl.StdSchedulerFactory;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 * 该例子将：

 * 1. 展示何如开始和结束quartz的调用器（scheduler），

 * 2. 展示在quartz中，调度器是如何运行作业（job）的。

 * 

 * @author caijw

 */

public class SimpleExample {

    public void run() throws Exception {

        Logger log = LoggerFactory.getLogger(SimpleExample.class);

        

        log.info("----- Initializing --------");

        //第一步我们必须获取一个调度器

        SchedulerFactory sf = new StdSchedulerFactory();

        Scheduler sched = sf.getScheduler();

        

        log.info("----- Initialization complete -------");

        

        //作业的执行时间（这里需要注意，下面详细说明）

        Date runTime = DateBuilder.evenMinuteDate(new Date());

        

        log.info("----- scheduling job --------");

        

        //创建一项作业

        JobDetail job = JobBuilder.newJob(HelloJob.class)

            .withIdentity("job1", "group1")

            .build();

        

        //创建一个触发器

        Trigger trigger = TriggerBuilder.newTrigger()

            .withIdentity("trigger1", "group1")

            .startAt(runTime).build(); //该触发器将在runTime时执行作业

        

        //告诉调度器使用该触发器来安排作业

        sched.scheduleJob(job, trigger);

        log.info(job.getKey() + " will run at: " + runTime);

        

        sched.start();//启动调度器

        log.info("------ started scheduler -------");

        

        log.info("------ waiting 65 seconds ------");

        try {

            Thread.sleep(65L * 1000L);

        } catch (Exception e) {

            log.error(e.getMessage(), e);

        }

        

        log.info("------- shutting down ------");

        sched.shutdown();//关闭调度器

        

        log.info("------- shutdown complete -------");

    }

}

注意：

1. Date runTime = DateBuilder.evenMinuteDate(new Date()); //当前时间的下一分钟

假如JVM在执行到这一句时，时间为17：23：22，那么runTime就是17：24：00

DateBuilder类似的方法：

2. 并不是把Job的实例注册到Scheduler中，而是JobDetail的实例。

3. Scheduler 实例被关闭之后你就不能调用它的 start() 方法了。这是因为 shutdown() 方法销毁了为 Scheduler 创建的所有的资源(线程，数据库连接等)。假如你在 shutdown() 之后调用 start()你将收到 SchedulerException 的异常。

4. Job 的实例要到该执行它们的时候才会实例化出来。每次 Job 被执行，一个新的 Job 实例会被创建（延迟加载的思想）。所以Job 不必担心线程安全性，因为同一时刻仅有一个线程去执行给定 Job 类的实例，甚至是并发执行同一 Job 也是如此。

Maven的配置文件：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

<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>quartz_project</groupId>

    <artifactId>quartz_project</artifactId>

    <version>0.0.1-SNAPSHOT</version>

    <packaging>jar</packaging>

    <name>quartz_project</name>

    <url>http://maven.apache.org</url>

    <properties>

        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>

    </properties>

    <dependencies>

        <dependency>

            <groupId>org.slf4j</groupId>

            <artifactId>slf4j-log4j12</artifactId>

            <version>1.6.1</version>

        </dependency>

        <dependency>

            <groupId>log4j</groupId>

            <artifactId>log4j</artifactId>

            <version>1.2.16</version>

        </dependency>

        <dependency>

            <groupId>org.quartz-scheduler</groupId>

            <artifactId>quartz</artifactId>

            <version>2.1.1</version>

        </dependency>

        <dependency>

            <groupId>junit</groupId>

            <artifactId>junit</artifactId>

            <version>4.10</version>

            <scope>test</scope>

        </dependency>

    </dependencies>

    

</project>

单元测试类：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

package quartz_project;

import org.junit.Test;

/**

 * 单元测试

 * 

 * @author caijw

 */

public class SimpleExampleTest {

    @Test

    public void testRun() throws Exception {

        SimpleExample example = new SimpleExample();

        example.run();

    }

}

执行结果分析：

?


1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

-------------------------------------------------------

 T E S T S

-------------------------------------------------------

Running quartz_project.SimpleExampleTest

[INFO] 25 一月 07:26:16.359 下午 main [quartz_project.SimpleExample]

----- Initializing --------

[INFO] 25 一月 07:26:16.437 下午 main [org.quartz.impl.StdSchedulerFactory]

Using default implementation for ThreadExecutor

[INFO] 25 一月 07:26:16.437 下午 main [org.quartz.simpl.SimpleThreadPool]

Job execution threads will use class loader of thread: main

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.core.SchedulerSignalerImpl]

Initialized Scheduler Signaller of type: class org.quartz.core.SchedulerSignalerImpl

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.core.QuartzScheduler]

Quartz Scheduler v.2.1.1 created.

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.simpl.RAMJobStore]

RAMJobStore initialized.

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.core.QuartzScheduler]

Scheduler meta-data: Quartz Scheduler (v2.1.1) ‘DefaultQuartzScheduler‘ with instanceId ‘NON_CLUSTERED‘

  Scheduler class: ‘org.quartz.core.QuartzScheduler‘ - running locally.

  NOT STARTED.

  Currently in standby mode.

  Number of jobs executed: 0

  Using thread pool ‘org.quartz.simpl.SimpleThreadPool‘ - with 10 threads.

  Using job-store ‘org.quartz.simpl.RAMJobStore‘ - which does not support persistence. and is not clustered.

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.impl.StdSchedulerFactory]

Quartz scheduler ‘DefaultQuartzScheduler‘ initialized from default resource file in Quartz package: ‘quartz.properties‘

[INFO] 25 一月 07:26:16.468 下午 main [org.quartz.impl.StdSchedulerFactory]

Quartz scheduler version: 2.1.1

[INFO] 25 一月 07:26:16.468 下午 main [quartz_project.SimpleExample]

----- Initialization complete -------

[INFO] 25 一月 07:26:16.484 下午 main [quartz_project.SimpleExample]

----- scheduling job --------

[INFO] 25 一月 07:26:16.500 下午 main [quartz_project.SimpleExample]

group1.job1 will run at: Sat Jan 25 19:27:00 CST 2014

[INFO] 25 一月 07:26:16.500 下午 main [org.quartz.core.QuartzScheduler]

Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED started.

[INFO] 25 一月 07:26:16.500 下午 main [quartz_project.SimpleExample]

------ started scheduler -------

[INFO] 25 一月 07:26:16.500 下午 main [quartz_project.SimpleExample]

------ waiting 65 seconds ------

[INFO] 25 一月 07:26:19.703 下午 Timer-0 [org.quartz.utils.UpdateChecker]

New Quartz update(s) found: 2.1.7 [http://www.terracotta.org/kit/reflector?kitID=default&pageID=QuartzChangeLog]

[INFO] 25 一月 07:27:00.031 下午 DefaultQuartzScheduler_Worker-1 [quartz_project.HelloJob]

Hello World! - Sat Jan 25 19:27:00 CST 2014

[INFO] 25 一月 07:27:21.500 下午 main [quartz_project.SimpleExample]

------- shutting down ------

[INFO] 25 一月 07:27:21.500 下午 main [org.quartz.core.QuartzScheduler]

Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutting down.

[INFO] 25 一月 07:27:21.500 下午 main [org.quartz.core.QuartzScheduler]

Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED paused.

[INFO] 25 一月 07:27:21.500 下午 main [org.quartz.core.QuartzScheduler]

Scheduler DefaultQuartzScheduler_$_NON_CLUSTERED shutdown complete.

[INFO] 25 一月 07:27:21.500 下午 main [quartz_project.SimpleExample]

------- shutdown complete -------

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 65.39 sec

Results :
时间： 2024-10-14 11:10:34

初识Quartz（一）的相关文章

初识Quartz（三）

本文将介绍CronTrigger的使用方法,CronTrigger相比 SimpleTrigger可以支持更复杂的作业计划.cron这一观念来自UNIX,在UNIX中,cron是一个运行于后台的守护程序,它负责所有基 于时间的时间.Unix cron守护进程每个一分钟被唤醒一次去检查叫做crontabs的配置文件,以此来决定是否有要执行的任务.个人觉得Quartz就是借鉴了它的名字和 相似的语法表达式,如果你之前接触过cron,那么理解本文将会很轻松. Quartz Trigger Cron E

初识Quartz（二）

简单作业: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 package quartz_project.example2; import java.util.Date; import org.quartz.Job; import org.quartz.JobExecutionContext; import org.quartz.JobExecutionException; import o

初识Quartz(入门案例)+常用的Cron表达式

1.Quartz架构图 1.实体层 package cn.happy.entity; //1. public class Plan { //时间 private String date; //任务 private String task; public Plan(String date, String task) { this.date = date; this.task = task; } public Plan() { } @Override public String toString()

Quartz使用(1) - 初识quartz

1. 背景 由于最新的工作项目中,需要使用quartz框架,以完成相关的任务的定时执行.经过两周的调研与使用,本系列博客会参考官网及网上相关博客,结合工作项目中的使用,详细介绍quartz的各个方面.如果有相关的错误,烦请不吝赐教.如果有相关的疑惑,可以评论,本人会抽空解答. 2. quartz是什么? Quartz is a richly featured, open source job scheduling library that can be integrated within vir

Quartz初识以及简单运用

1.初识Quartz 1.1.概述 Quartz是一个完全由Java编写的一个开源的任务调度框架,说的简单点就是开发人员可以通过Quartz根据时间间隔调度任务,例如: 每隔一小时命令程序执行一个任务 每个月命令程序执行一个任务 指定某月末日命令程序执行一个任务 -- Quartz下载地址:http://www.quartz-scheduler.org/downloads/ 1.2.Quartz API 1.2.1.Scheduler--与scheduler交互的主要API; Scheduler

Quartz使用(2) - Quartz核心接口Scheduler、Job

quartz的核心接口如下: 接口 含义 Scheduler scheduler的主要API接口 Job 任务实现接口,期望调度器能够执行 JobDetail 用于定义Job实例 Trigger 调度器基于特定时间来执行指定任务的组件 JobBuilder 用于定义.创建JobDetail实例 TriggerBuilder 用于定义.创建Trigger实例 1. Scheduler 一个调度器的生命周期为通过SchedulerFactory创建,直到执行其shutdown()方法.当Schedu

Quartz实现定时任务（一）

前言 有段时间没写blog了,说来惭愧,最近一直在给公司做P2P项目的服务端,但这都不是借口,高尔基曾说过(不太确定T_T),时间就像海绵里的水,只要愿意挤总是有的!所以写博客的节奏还是必须脉动回来,必须养成不断学习,不断记录,不断总结的好习惯.废话不多说,最近需要做一些服务器端的定时任务,决定使用Quartz去实现,之前也没接触过,所以就边学边做了,顺便把这个过程记录下来. 初识Quartz 首先看一下百科中对Quartz的简介:Quartz是OpenSymphony开源组织在Job sche

Quartz2.2.1教程 快速上手

一.初识quartz   JobDetail job = newJob(HelloJob.class).withIdentity("job1", "group1").build();   Trigger trigger = newTrigger().withIdentity("trigger1", "group1").startNow().build();   Scheduler scheduler = StdSchedule

Atitit.spring体系结构大总结

1. Srping mvc 1 2. Ioc 4 3. ApplicationContext在BeanFactory的基础上构建,区别 4 4. Aop 5 5. 3.2.4.1. @AspectJ形式的SpringAOP 5 6. spring的定时器 6 7. spring的事务处理 6 8. spring与struts的整合 6 9. spring与hibernate的整合 6 10. spring的持久层封装 使用jdbctemptate访问数据 6 11. 2.3.1.3.7. 方法注