Quelles sont les différentes manières d'implémenter des tâches planifiées en Java ?

Comment implémenter des tâches planifiées en Java : 1. Utilisez la classe "java.util.Timer" fournie avec Java. Cette classe vous permet de planifier une tâche "java.util.TimerTask" ; Quartz; 3. , Utilisez les tâches fournies avec Spring 3.0.

L'environnement d'exploitation de ce tutoriel : système Windows 7, version Java 8, ordinateur DELL G3.

Récemment, certaines tâches planifiées doivent être effectuées lors du développement du projet. Par exemple, il est nécessaire d'analyser les informations du journal de la veille au petit matin de chaque jour. méthodes d'implémentation des tâches planifiées. Puisque le projet utilise le framework spring, je vais donc le présenter en conjonction avec le framework spring.

1. Classification

• Du point de vue de la technologie de mise en œuvre, il existe actuellement trois technologies principales (ou trois produits) :

  1. La propre classe java.util.Timer de Java, celle-ci. La classe vous permet de planifier une tâche java.util.TimerTask. L'utilisation de cette méthode permet à votre programme d'être exécuté à une certaine fréquence, mais pas à une heure spécifiée. Généralement moins utilisé, cet article ne le présentera pas en détail.

  2. Utilisez Quartz, qui est un planificateur relativement puissant qui permet d'exécuter votre programme à une heure spécifiée ou à une certaine fréquence. La configuration est un peu compliquée, comme nous le verrons plus tard.

  3. Les tâches fournies avec Spring 3.0 et versions ultérieures peuvent être considérées comme un Quartz léger, et elles sont beaucoup plus simples à utiliser que Quartz, qui sera présenté plus tard.

• En termes de méthodes d'héritage des classes d'emplois, elles peuvent être divisées en deux catégories :

  1. Les classes d'emplois doivent hériter d'une classe de base de classe d'emplois spécifique, comme dans Quartz Il doit être hérité de org.springframework.scheduling.quartz.QuartzJobBean ; java.util.Timer doit être hérité de java.util.TimerTask.

  2. La classe de travail est une classe Java ordinaire et n'a pas besoin d'hériter d'une classe de base.

Remarque : je recommande personnellement d'utiliser la deuxième méthode, car tous les cours sont des cours communs et n'ont pas besoin d'être traités différemment à l'avance.

• À partir du moment de déclenchement de la planification des tâches, voici principalement les déclencheurs utilisés pour les tâches. Il existe principalement les deux types suivants :

  À chaque heure spécifiée. , le déclencheur correspondant dans Quartz est : org.springframework.scheduling.quartz.SimpleTriggerBean

  2 Déclenchez une fois à chaque heure spécifiée, le planificateur correspondant dans Quartz est : org.springframework.quartz.CronTriggerBean

  .

Remarque : Toutes les tâches ne peuvent pas utiliser ces deux déclencheurs. Par exemple, la tâche java.util.TimerTask ne peut utiliser que le premier. Les tâches à quartz et à ressort peuvent prendre en charge ces deux conditions de déclenchement.

2. Instructions d'utilisation

Présentez en détail comment utiliser chaque outil de planification de tâches, y compris Quartz et Spring Task.

Quartz

Tout d'abord, la classe de travail hérite d'une classe de base spécifique : org.springframework.scheduling.quartz.QuartzJobBean.

Étape 1 : Définir la classe de travail

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("定时任务执行中…");
}
}

Étape 2 : Configurer la classe de travail JobDetailBean dans le fichier de configuration Spring

<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 a deux attributs. L'attribut jobClass est la classe de tâches que nous définissons dans le code Java et l'attribut jobDataAsMap est la valeur d'attribut qui doit être injectée. dans la classe de tâches.

Étape 3 : Configurer la méthode de déclenchement (déclencheur) de la planification des tâches

Quartz a deux déclencheurs de tâches, à savoir

org .springframework.scheduling. quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

Le premier SimpleTriggerBean ne prend en charge que l'appel de tâches à une certaine fréquence, par exemple une exécution toutes les 30 minutes .

La méthode de configuration est la suivante :

<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>

Le deuxième type de CronTriggerBean prend en charge l'exécution une fois à une heure spécifiée, par exemple une fois par jour à 12h00.

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

Veuillez vous référer à l'annexe pour la syntaxe de l'expression cronExpression.

Étape 4 : Configurer la fabrique de planification

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

Remarque : Ce paramètre précise le nom du déclencheur précédemment configuré.

Étape 5 : Démarrez simplement votre application, c'est-à-dire déployez le projet sur Tomcat ou d'autres conteneurs.

Deuxièmement, la classe d'emplois n'hérite pas d'une classe de base spécifique. (Recommandé)

Spring peut prendre en charge cette approche grâce à deux classes :

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework scheduling.quartz. .MethodInvokingJobDetailFactoryBean

Ces deux classes correspondent respectivement aux deux méthodes de planification de tâches supportées par spring, à savoir la méthode de tâche timer et la méthode Quartz fournies avec Java mentionnées ci-dessus. Ici, j'écris uniquement sur l'utilisation de MethodInvokingJobDetailFactoryBean. L'avantage de l'utilisation de cette classe est que notre classe de tâches n'a plus besoin d'hériter d'aucune classe, mais est un pojo ordinaire.

Étape 1 : Écrivez une classe de tâches

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

Comme vous pouvez le voir, il s'agit d'une classe ordinaire et possède une méthode.

Étape 2 : Configurer la classe d'emploi

<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表达式，具体写法这里不介绍了，详情见上篇文章附录。

这个配置不消多说了，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"/>

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

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

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

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!