分类

从实现的技术上来分类，目前主要有三种技术

  1. Java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少，这篇文章将不做详细介绍。
  2. 使用Quartz，这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂，稍后会详细介绍。
  3. Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多，稍后会介绍。

从作业类的继承方式来讲，可以分为两类：

  1. 作业类需要继承自特定的作业类基类，如Quartz中需要继承自org.springframework.scheduling.quartz.QuartzJobBean；java.util.Timer中需要继承自java.util.TimerTask。
  2. 作业类即普通的java类，不需要继承自任何基类。

注:个人推荐使用第二种方式，因为这样所以的类都是普通类，不需要事先区别对待。

  • #### 从任务调度的触发时机来分，这里主要是针对作业使用的触发器，主要有以下两种：
  1. 每隔指定时间则触发一次，在Quartz中对应的触发器为：org.springframework.scheduling.quartz.SimpleTriggerBean
  2. 每到指定时间则触发一次，在Quartz中对应的调度器为：org.springframework.scheduling.quartz.CronTriggerBean

注：并非每种任务都可以使用这两种触发器，如java.util.TimerTask任务就只能使用第一种。Quartz和spring task都可以支持这两种触发条件。

用法说明

Quartz

Maven依赖
<!-- Framework -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-orm</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${springframework.version}</version>
        </dependency>
        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.16</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.1</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>2.2.1</version>
</dependency>
<dependency>
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz-jobs</artifactId>
    <version>2.2.1</version>
</dependency>

方式一:作业类继承自特定的基类：org.springframework.scheduling.quartz.QuartzJobBean。

  • 第一步:定义作业类
public class MyTask extends QuartzJobBean {

    private Logger logger = LoggerFactory.getLogger(MyTask.class);

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        logger.info("++++++++++++++++++++++");
        logger.info("executeInternal");
        logger.info("++++++++++++++++++++++");
    }
}
  • 第二步:spring配置文件中配置作业类JobDetailBean
<bean name="myTask" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
        <property name="jobClass" value="com.yefan.task.quartz.MyTask"/>
        <property name="jobDataAsMap">
            <map>
                <entry key="timeout" value="0"/>
            </map>
        </property>
    </bean>
  • 第三步：配置作业调度的触发方式（触发器）

第一种SimpleTriggerBean，只支持按照一定频度调用任务，如每隔30分钟运行一次

<bean id="testTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerFactoryBean">
    <property name="jobDetail" ref="testJob"></property>
    <property name="startDelay" value="3000"></property>
    <property name="repeatInterval" value="2000"></property>
</bean>

第二种CronTriggerBean，支持到指定时间运行一次，如每天12:00运行一次等。

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
        <property name="jobDetail" ref="myTask"/>
        <!-- 每隔一秒运行一次 -->
        <property name="cronExpression" value="0/1 * * * * ?"/>
    </bean>
  • 第四步：配置调度工厂 
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref bean="cronTrigger"></ref>
        </list>
    </property>
</bean>

方式二:作业类不继承特定基类。

  • 第一步：编写任务类
public class TestJob {

    private Logger logger = LoggerFactory.getLogger(TestJob.class);

    public void doSomeThing() {

        logger.info("------------doSomeThing-------------");

        logger.info("*****:" + System.currentTimeMillis());

    }
}
  • 第二步：配置作业类
<!-- 要执行任务的任务类 -->
<bean id="testJob" class="com.yefan.task.quartz.TestJob"/>
  • 第三步：配置作业调度的触发方式（触发器）

同上，有两种方式

  • 第四步：配置调度工厂

同上

Spring Task

第一种：配置文件方式

  • 第一步：编写作业类
@Component
public class QuartzService {

    private Logger logger = LoggerFactory.getLogger(QuartzService.class);

    @Scheduled(cron = "0/2 * * * * *")
    public void process() {

        logger.info("-------------------");

        userService.saveUser();
        System.out.println("job run...");

        logger.info("--------------------");
    }

}
  • 第二步：spring配置文件中设置具体的任务
<task:scheduled-tasks>
        <task:scheduled ref="testJob" method="doSomeThing" cron="0/4 * * * * *"/>
    </task:scheduled-tasks>

    <context:component-scan base-package=" com.yefan.task.quartz " />

第二种：使用注解形式

  • 第一步:添加任务类

同方式一

  • 第二步:添加task相关的配置：
<task:scheduled-tasks>
        <task:scheduled ref="testJob" method="doSomeThing" cron="0/4 * * * * *"/>
    </task:scheduled-tasks>

    <context:component-scan base-package=" com.yefan.task.quartz " />
<task:annotation-driven/>
  • 第三步:在任务类的方法上添加@Scheduled注解
@Scheduled(cron = "0/2 * * * * *")
public void process() {

    logger.info("-------------------");

    System.out.println("job run...");

    logger.info("--------------------");
}