So erstellen Sie eine geplante Springboot-Aufgabe

Wenn Sie mehr über Springboot erfahren möchten, klicken Sie auf: JAVA-Tutorial

Es ist sehr einfach, geplante Aufgaben mit SpringBoot zu erstellen. Derzeit gibt es drei Hauptmethoden, um sie zu erstellen:

1. Basierend auf Anmerkungen (@. Geplant)

2. Schnittstellenbasiert (SchedulingConfigurer) Ich glaube, jeder kennt Ersteres, aber im tatsächlichen Gebrauch möchten wir oft die angegebene Zeit aus der Datenbank lesen, um geplant dynamisch auszuführen Zu diesem Zeitpunkt ist das schnittstellenbasierte Timing genau das Richtige für Sie.

3. Festlegen geplanter Multithread-Aufgaben basierend auf Anmerkungen

1. Statisch: basierend auf Anmerkungen

Basierend auf Anmerkungen@ScheduledDer Standardwert ist ein einzelner Thread. Wenn mehrere Aufgaben gestartet werden, wird die Ausführungszeit der Aufgabe durch die Ausführungszeit der vorherigen Aufgabe beeinflusst.

1. Erstellen Sie einen Timer

Die Verwendung von SpringBoot zum Erstellen geplanter Aufgaben basierend auf Anmerkungen ist sehr einfach und kann mit nur wenigen Zeilen erledigt werden von Code. Der Code lautet wie folgt:

@Component
@Configuration      //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling   // 2.开启定时任务
public class SaticScheduleTask {
    //3.添加定时任务
    @Scheduled(cron = "0/5 * * * * ?")
    //或直接指定时间间隔，例如：5秒
    //@Scheduled(fixedRate=5000)
    private void configureTasks() {
        System.err.println("执行静态定时任务时间: " + LocalDateTime.now());
    }
}

Cron-Ausdrucksparameter stellen jeweils Folgendes dar:

Sekunden (0~59) Beispielsweise bedeutet 0/5 alle 5 Sekunden

Minuten (0~59)

Stunde (0~23)

Tag (0~31),

Monat (0~11)

Wochentag (kann 1-7 oder SO/MON/DI/MI/DO/FR/SA ausgefüllt werden)

@Scheduled: Zusätzlich zu Unterstützung für flexible Parameterausdrücke cron Darüber hinaus werden auch einfache Verzögerungsoperationen wie „fixedDelay“ und „fixedRate“ unterstützt. Geben Sie einfach die entsprechende Anzahl von Millisekunden ein.

2. Starten Sie den Test

Starten Sie die Anwendung und Sie können die folgenden Informationen auf der Konsole ausdrucken:

Natürlich ist die Verwendung der @Scheduled-Annotation sehr praktisch, aber der Nachteil besteht darin, dass wir beim Anpassen des Ausführungszyklus die Anwendung neu starten müssen, damit sie wirksam wird, was etwas unpraktisch ist. Um einen Echtzeiteffekt zu erzielen, können Sie über die Schnittstelle geplante Aufgaben erledigen.

2. Dynamisch: Basierend auf der Schnittstelle

Basierend auf der Schnittstelle (

) SchedulingConfigurer

1. Abhängigkeitspakete importieren

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>2.0.4.RELEASE</version>
    </parent>

    <dependencies>
        <dependency><!--添加Web依赖 -->
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency><!--添加MySql依赖 -->
             <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <dependency><!--添加Mybatis依赖 配置mybatis的一些初始化的东西-->
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.1</version>
        </dependency>
        <dependency><!-- 添加mybatis依赖 -->
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.5</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

2. Datenbankeinträge hinzufügen

Öffnen Sie die lokale Datenbank MySQL, öffnen Sie das Abfragefenster nach Belieben und führen Sie dann den Skriptinhalt wie folgt aus:

DROP DATABASE IF EXISTS `socks`;
CREATE DATABASE `socks`;
USE `SOCKS`;
DROP TABLE IF EXISTS `cron`;
CREATE TABLE `cron`  (
  `cron_id` varchar(30) NOT NULL PRIMARY KEY,
  `cron` varchar(30) NOT NULL  
);
INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');

Fügen Sie dann die Datenquelle zu application.yml im Projekt hinzu:

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/socks
    username: root
    password: 123456

3. Erstellen Sie einen Timer

Nachdem die Datenbank die Daten vorbereitet hat, schreiben wir die geplante Aufgabe Hier wird TriggerTask hinzugefügt, das die in der Datenbank vorhandenen Daten durchläuft und den Ausführungszyklus und den Inhalt der Ausführung verwandter geplanter Aufgaben festlegt.

Der spezifische Code lautet wie folgt:

@Component
@Configuration      //1.主要用于标记配置类，兼备Component的效果。
@EnableScheduling   // 2.开启定时任务
public class DynamicScheduleTask implements SchedulingConfigurer {

    @Mapper
    public interface CronMapper {
        @Select("select cron from cron limit 1")
        public String getCron();
    }

    @Autowired      //注入mapper
    @SuppressWarnings("all")
    CronMapper cronMapper;

    /**
     * 执行定时任务.
     */
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

        taskRegistrar.addTriggerTask(
                //1.添加任务内容(Runnable)
                () -> System.out.println("执行动态定时任务: " + LocalDateTime.now().toLocalTime()),
                //2.设置执行周期(Trigger)
                triggerContext -> {
                    //2.1 从数据库获取执行周期
                    String cron = cronMapper.getCron();
                    //2.2 合法性校验.
                    if (StringUtils.isEmpty(cron)) {
                        // Omitted Code ..
                    }
                    //2.3 返回执行周期(Date)
                    return new CronTrigger(cron).nextExecutionTime(triggerContext);
                }
        );
    }

}

4. Starten Sie den Test

Überprüfen Sie nach dem Starten der Anwendung die Konsole und die Druckzeit beträgt Wir erwarten einmal alle 10 Sekunden:

Öffnen Sie dann Navicat und ändern Sie den Ausführungszyklus so, dass er alle 6 Sekunden ausgeführt wird, wie in der Abbildung gezeigt:

Beim Blick auf die Konsole stellten wir fest, dass sich der Ausführungszyklus geändert hat und wir die Anwendung nicht neu starten müssen, was sehr praktisch ist. Wie im Bild gezeigt:

Hinweis: Wenn beim Ändern der Datenbank ein Formatfehler auftritt, wird die geplante Aufgabe angehalten, auch wenn die Änderung nicht erfolgt ist korrekt; zu diesem Zeitpunkt müssen Sie das Projekt nur neu starten, um es wiederherzustellen.

3. Multithreaded geplante Aufgaben

Multithreaded geplante Aufgaben basierend auf Anmerkungen festlegen

1 -threaded geplante Aufgaben Aufgabe

//@Component注解用于对那些比较中立的类进行注释；
//相对与在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释
@Component
@EnableScheduling   // 1.开启定时任务
@EnableAsync        // 2.开启多线程
public class MultithreadScheduleTask {

        @Async
        @Scheduled(fixedDelay = 1000)  //间隔1秒
        public void first() throws InterruptedException {
            System.out.println("第一个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
            System.out.println();
            Thread.sleep(1000 * 10);
        }

        @Async
        @Scheduled(fixedDelay = 2000)
        public void second() {
            System.out.println("第二个定时任务开始 : " + LocalDateTime.now().toLocalTime() + "\r\n线程 : " + Thread.currentThread().getName());
            System.out.println();
        }
    }

2. Starten Sie den Test

Überprüfen Sie nach dem Starten der Anwendung die Konsole:

Wie aus der Konsole hervorgeht, beeinflussen sich die erste geplante Aufgabe und die zweite geplante Aufgabe nicht gegenseitig.

Darüber hinaus ist Da Multithreading aktiviert ist, die Ausführungszeit der ersten Die Aufgabe ist auch nicht durch ihre eigene Ausführungszeit begrenzt. Bitte beachten Sie daher, dass wiederholte Vorgänge zu Datenanomalien führen können.

Das obige ist der detaillierte Inhalt vonSo erstellen Sie eine geplante Springboot-Aufgabe. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!