What are the several ways to implement scheduled tasks in Java?

How to implement scheduled tasks in Java: 1. Use the "java.util.Timer" class that comes with Java. This class allows you to schedule a "java.util.TimerTask" task; 2. Use Quartz; 3. , Use the tasks that come with Spring 3.0.

The operating environment of this tutorial: windows7 system, java8 version, DELL G3 computer.

Recently, some scheduled tasks need to be performed during project development. For example, it is necessary to analyze the log information of the previous day in the early morning of every day. I took this opportunity to sort out several implementation methods of scheduled tasks. Since the project uses the spring framework , so I will introduce it in conjunction with the spring framework.

one. Classification

• From the perspective of implementation technology, there are currently three main technologies (or three products):

  1. Java’s own java.util.Timer Class, this class allows you to schedule a java.util.TimerTask task. Using this method allows your program to be executed at a certain frequency, but not at a specified time. Generally used less, this article will not introduce it in detail.

  2. Use Quartz, which is a relatively powerful scheduler that allows your program to be executed at a specified time or at a certain frequency. The configuration is a bit complicated, and will be discussed later. Detailed introduction.

  3. The tasks that come with Spring 3.0 and later can be regarded as a lightweight Quartz, and it is much simpler to use than Quartz, which will be introduced later.

• In terms of inheritance methods of job classes, they can be divided into two categories:

  1. Job classes need to inherit from a specific job class base class, such as in Quartz It needs to be inherited from org.springframework.scheduling.quartz.QuartzJobBean; java.util.Timer needs to be inherited from java.util.TimerTask.

  2. The job class is an ordinary java class and does not need to inherit from any base class.

Note: I personally recommend using the second method, because all classes are common classes and do not need to be treated differently in advance.

• From the trigger timing of task scheduling, here are mainly the triggers used for jobs. There are two main types:

  1. Every specified time. Triggered once, the corresponding trigger in Quartz is: org.springframework.scheduling.quartz.SimpleTriggerBean

  2. Triggered once every specified time, the corresponding scheduler in Quartz is: org.springframework. scheduling.quartz.CronTriggerBean

Note: Not every task can use these two triggers. For example, the java.util.TimerTask task can only use the first one. Both Quartz and spring task can support these two trigger conditions.

two. Usage instructions

Introduces in detail how to use each task scheduling tool, including Quartz and spring task.

Quartz

First, the job class inherits from a specific base class: org.springframework.scheduling.quartz.QuartzJobBean.

The first step: Define the job class

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;
public class Job1 extends QuartzJobBean {

private int timeout;
private static int i = 0;
//调度工厂实例化后，经过timeout时间开始执行调度
public void setTimeout(int timeout) {
this.timeout = timeout;
}

/**
* 要调度的具体任务
*/
@Override
protected void executeInternal(JobExecutionContext context)
throws JobExecutionException {
  System.out.println("定时任务执行中…");
}
}

The second step: Configure the job class JobDetailBean in the spring configuration file

<bean name="job1" class="org.springframework.scheduling.quartz.JobDetailBean">
<property name="jobClass" value="com.gy.Job1" />
<property name="jobDataAsMap">
<map>
<entry key="timeout" value="0" />
</map>
</property>
</bean>

Description: org.springframework.scheduling.quartz.JobDetailBean has two attributes. The jobClass attribute is the task class we define in the java code, and the jobDataAsMap attribute is the attribute value that needs to be injected into the task class.

Step 3: Configure the triggering method (trigger) of job scheduling

There are two types of job triggers in Quartz, namely

org .springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

The first SimpleTriggerBean only supports calling tasks at a certain frequency, such as running once every 30 minutes .

The configuration method is as follows:

<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
<property name="jobDetail" ref="job1" />  
<property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->  
<property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->  
</bean>

The second CronTriggerBean supports running once at a specified time, such as once every day at 12:00.

<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
  <property name="jobDetail" ref="job1" />  
  <!—每天12:00运行一次 -->  
  <property name="cronExpression" value="0 0 12 * * ?" />  
  </bean>

See the appendix for the syntax of cronExpression expressions.

Step 4: Configure the scheduling factory

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">  
 <property name="triggers">  
 <list>  
 <ref bean="cronTrigger" />  
 </list>  
 </property>  
</bean>

Description: This parameter specifies the name of the previously configured trigger.

Step 5: Just start your application, that is, deploy the project to tomcat or other containers.

Second, the job class does not inherit a specific base class. (Recommended)

Spring can support this method thanks to two classes:

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework. scheduling.quartz.MethodInvokingJobDetailFactoryBean

These two classes respectively correspond to the two methods of task scheduling supported by spring, namely the timer task method and the Quartz method that come with java as mentioned above. Here I only write about the usage of MethodInvokingJobDetailFactoryBean. The advantage of using this class is that our task class no longer needs to inherit from any class, but is an ordinary pojo.

Step 1: Write the task class

 public class Job2 {  
 public void doJob2() {  
 System.out.println("不继承QuartzJobBean方式-调度进行中...");  
 }  
 }

As you can see, this is an ordinary class and has a method.

Step 2: Configure job class

<bean id="job2"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
<property name="targetObject">
<bean class="com.gy.Job2" />
</property>
<property name="targetMethod" value="doJob2" />
<property name="concurrent" value="false" /><!-- 作业不并发调度 -->
</bean>

说明：这一步是关键步骤，声明一个MethodInvokingJobDetailFactoryBean，有两个关键属性：targetObject指定任务类，targetMethod指定运行的方法。往下的步骤就与方法一相同了，为了完整，同样贴出。

第三步：配置作业调度的触发方式（触发器）

Quartz的作业触发器有两种，分别是

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

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

配置方式如下：

 <bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">  
 <property name="jobDetail" ref="job2" />  
 <property name="startDelay" value="0" /><!-- 调度工厂实例化后，经过0秒开始执行调度 -->  
 <property name="repeatInterval" value="2000" /><!-- 每2秒调度一次 -->  
 </bean>

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

 <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">  
 <property name="jobDetail" ref="job2" />  
  <!—每天12:00运行一次 -->  
  <property name="cronExpression" value="0 0 12 * * ?" />  
 </bean>

以上两种方式根据实际情况任选一种即可

第四步：配置调度工厂 

<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
<property name="triggers">
<list>
<ref bean="cronTrigger" />
</list>
</property>
</bean>

说明：该参数指定的就是之前配置的触发器的名字。

第五步：启动你的应用即可，即将工程部署至tomcat或其他容器。

到此，spring中Quartz的基本配置就介绍完了，当然了，使用之前，要导入相应的spring的包与Quartz的包，这些就不消多说了。

其实可以看出Quartz的配置看上去还是挺复杂的，没有办法，因为Quartz其实是个重量级的工具，如果我们只是想简单的执行几个简单的定时任务，有没有更简单的工具，有！

Spring-Task

上节介绍了在Spring 中使用Quartz，本文介绍Spring3.0以后自主开发的定时任务工具，spring task，可以将它比作一个轻量级的Quartz，而且使用起来很简单，除spring相关的包外不需要额外的包，而且支持注解和配置文件两种

形式，下面将分别介绍这两种方式。

第一种：配置文件方式

第一步：编写作业类

即普通的pojo，如下：

  import org.springframework.stereotype.Service;  
  @Service  
  public class TaskJob {  
        5      public void job1() {  
          System.out.println(“任务进行中。。。”);  
      }  
  }

 第二步：在spring配置文件头中添加命名空间及描述

 <beans xmlns="http://www.springframework.org/schema/beans"  
    xmlns:task="http://www.springframework.org/schema/task"   
    xsi:schemaLocation="http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd">

 第三步：spring配置文件中设置具体的任务

<task:scheduled-tasks>   
         <task:scheduled ref="taskJob" method="job1" cron="0 * * * * ?"/>   
</task:scheduled-tasks>  
   
<context:component-scan base-package=" com.gy.mytask " />

说明：ref参数指定的即任务类，method指定的即需要运行的方法，cron及cronExpression表达式，具体写法这里不介绍了，详情见上篇文章附录。

061481f571d9fcde0fdd3d938e029bd4这个配置不消多说了，spring扫描注解用的。

到这里配置就完成了，是不是很简单。

第二种：使用注解形式

也许我们不想每写一个任务类还要在xml文件中配置下，我们可以使用注解@Scheduled，我们看看源文件中该注解的定义：

@Target({java.lang.annotation.ElementType.METHOD, java.lang.annotation.ElementType.ANNOTATION_TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface Scheduled
{
  public abstract String cron();

  public abstract long fixedDelay();

  public abstract long fixedRate();
}

 可以看出该注解有三个方法或者叫参数，分别表示的意思是：

cron：指定cron表达式

fixedDelay：官方文档解释：An interval-based trigger where the interval is measured from the completion time of the previous task. The time unit value is measured in milliseconds.即表示从上一个任务完成开始到下一个任务开始的间隔，单位是毫秒。

fixedRate：官方文档解释：An interval-based trigger where the interval is measured from the start time of the previous task. The time unit value is measured in milliseconds.即从上一个任务开始到下一个任务开始的间隔，单位是毫秒。

下面我来配置一下。

第一步：编写pojo

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component(“taskJob”)
public class TaskJob {
    @Scheduled(cron = "0 0 3 * * ?")
    public void job1() {
        System.out.println(“任务进行中。。。”);
    }
}

 第二步：添加task相关的配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/jdbc/spring-jdbc-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd"
    default-lazy-init="false">


    <context:annotation-config />
    <!—spring扫描注解的配置   -->
    <context:component-scan base-package="com.gy.mytask" />

    <!—开启这个配置，spring才能识别@Scheduled注解   -->
    <task:annotation-driven scheduler="qbScheduler" mode="proxy"/>
    <task:scheduler id="qbScheduler" pool-size="10"/>

说明：理论上只需要加上0e0f0f33160a2f99922e9b75ed96d092这句配置就可以了，这些参数都不是必须的。

 Ok配置完毕，当然spring task还有很多参数，我就不一一解释了，具体参考xsd文档http://www.springframework.org/schema/task/spring-task-3.0.xsd。

更多编程相关知识，请访问：编程视频！！

The above is the detailed content of What are the several ways to implement scheduled tasks in Java?. For more information, please follow other related articles on the PHP Chinese website!