Welche verschiedenen Möglichkeiten gibt es, geplante Aufgaben in Java zu implementieren?

So implementieren Sie geplante Aufgaben in Java: 1. Verwenden Sie die mit Java gelieferte Klasse „java.util.Timer“. 2. Verwenden Sie Quartz. Verwenden Sie Spring3.0 mit Aufgaben.

Die Betriebsumgebung dieses Tutorials: Windows7-System, Java8-Version, DELL G3-Computer.

In letzter Zeit müssen während der Projektentwicklung einige geplante Aufgaben ausgeführt werden. Beispielsweise muss ich am frühen Morgen jedes Tages die Protokollinformationen analysieren. Ich habe diese Gelegenheit genutzt, um verschiedene Implementierungsmethoden für geplante Aufgaben zu klären . Da das Projekt das Spring Framework verwendet, habe ich es in Verbindung mit dem Spring Framework eingeführt.

1. Klassifizierung

• Aus Sicht der Implementierungstechnologie gibt es derzeit drei Haupttechnologien (oder drei Produkte):

  1. Javas eigene Klasse java.util.Timer. Mit dieser Klasse können Sie eine java.util-TimerTask-Aufgabe planen . Mit dieser Methode kann Ihr Programm mit einer bestimmten Häufigkeit, jedoch nicht zu einem bestimmten Zeitpunkt ausgeführt werden. Im Allgemeinen weniger verwendet, wird in diesem Artikel nicht im Detail darauf eingegangen.

  2. Verwenden Sie Quartz, einen relativ leistungsstarken Scheduler, der die Ausführung Ihres Programms zu einem bestimmten Zeitpunkt oder in einer bestimmten Häufigkeit ermöglicht. Die Konfiguration ist etwas kompliziert und wird später im Detail vorgestellt.

  3. Die mit Spring 3.0 und höher gelieferten Aufgaben können als leichter Quarz betrachtet werden und sind viel einfacher zu verwenden als Quarz, der später eingeführt wird.

• In Bezug auf die Vererbungsmethode der Jobklasse kann sie in zwei Kategorien unterteilt werden:

  1. Die Jobklasse muss von einer bestimmten Jobklassen-Basisklasse erben, z. B. muss Quartz von org.springframework.scheduling erben .quartz.QuartzJobBean ; java.util.Timer muss von java.util.TimerTask erben.

  2. Die Jobklasse ist eine gewöhnliche Java-Klasse und muss nicht von einer Basisklasse erben.

Hinweis: Ich persönlich empfehle die Verwendung der zweiten Methode, da alle Klassen gemeinsame Klassen sind und nicht im Vorfeld unterschiedlich behandelt werden müssen.

• Vom auslösenden Zeitpunkt der Aufgabenplanung werden hier hauptsächlich die folgenden Auslöser verwendet:

  1. Auslöser einmal zu jedem angegebenen Zeitpunkt. Die entsprechenden Auslöser in Quartz. scheduling.quartz.SimpleTriggerBean

  2. Es wird einmal zu jedem angegebenen Zeitpunkt ausgelöst. Der entsprechende Scheduler in Quartz ist: org.springframework.scheduling.quartz.CronTriggerBean

Hinweis: Diese beiden Trigger können verwendet werden. Beispielsweise kann die Aufgabe java.util.TimerTask nur die erste verwenden. Sowohl die Quarz- als auch die Federaufgabe können diese beiden Auslösebedingungen unterstützen.

2. Nutzungsanweisungen

Erklären Sie im Detail, wie Sie die einzelnen Aufgabenplanungstools verwenden, einschließlich Quarz- und Federaufgaben.

Quartz

Der erste Typ, die Jobklasse, erbt von einer bestimmten Basisklasse: org.springframework.scheduling.quartz.QuartzJobBean.

Schritt 1: Definieren Sie die Jobklasse

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

Schritt 2: Konfigurieren Sie die Jobklasse JobDetailBean in der Spring-Konfigurationsdatei

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

Beschreibung: org.springframework.scheduling.quartz.JobDetailBean hat zwei Attribute, jobClass Das Attribut ist die Aufgabenklasse, die wir im Java-Code definiert haben, und das Attribut jobDataAsMap ist der Attributwert, der in die Aufgabenklasse eingefügt werden muss.

Schritt 3: Konfigurieren Sie die Auslösemethode (Trigger) der Jobplanung

Quartz verfügt über zwei Job-Trigger, nämlich

org.springframework.scheduling.quartz.SimpleTriggerBean

org.springframework.scheduling.quartz.CronTriggerBean

Das erste SimpleTriggerBean unterstützt nur das Aufrufen von Aufgaben mit einer bestimmten Häufigkeit, z. B. die Ausführung einmal alle 30 Minuten.

Die Konfigurationsmethode lautet wie folgt:

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

Die zweite CronTriggerBean unterstützt die einmalige Ausführung zu einem bestimmten Zeitpunkt, beispielsweise einmal täglich um 12:00 Uhr.

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

Die Syntax des cronExpression-Ausdrucks finden Sie im Anhang.

Schritt 4: Konfigurieren Sie die Planungsfabrik

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

Hinweis: Dieser Parameter gibt den Namen des zuvor konfigurierten Triggers an.

Schritt 5: Starten Sie einfach Ihre Anwendung und stellen Sie das Projekt in Tomcat oder anderen Containern bereit.

Zweitens erbt die Jobklasse keine bestimmte Basisklasse. (Empfohlen)

Spring kann diese Methode dank zweier Klassen unterstützen:

org.springframework.scheduling.timer.MethodInvokingTimerTaskFactoryBean

org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean

Diese beiden Klassen entsprechen Spring bzw. Die beiden unterstützt Möglichkeiten zur Implementierung der Aufgabenplanung sind die oben erwähnte Timer-Task-Methode und die Quartz-Methode, die mit Java geliefert werden. Hier schreibe ich nur über die Verwendung von MethodInvokingJobDetailFactoryBean. Der Vorteil der Verwendung dieser Klasse besteht darin, dass unsere Aufgabenklasse nicht mehr von einer Klasse erben muss, sondern ein gewöhnliches Pojo ist.

Schritt 1: Schreiben Sie eine Aufgabenklasse

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

Wie Sie sehen, ist dies eine gewöhnliche Klasse und verfügt über eine Methode.

Schritt 2: Jobklasse konfigurieren

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

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

Das obige ist der detaillierte Inhalt vonWelche verschiedenen Möglichkeiten gibt es, geplante Aufgaben in Java zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!