Comment créer une tâche planifiée Springboot

Si vous souhaitez en savoir plus sur Springboot, vous pouvez cliquer sur : Tutoriel JAVA

Il est très simple de créer des tâches planifiées à l'aide de SpringBoot. Il existe actuellement trois manières principales de les créer :

1. Basé sur des annotations (@. Planifié)

2. Basé sur une interface (SchedulingConfigurer) Je pense que tout le monde connaît le premier, mais dans la réalité, nous souhaitons souvent lire l'heure spécifiée dans la base de données pour exécuter dynamiquement la planification. tâches. À l’heure actuelle, le timing basé sur l’interface est là où les tâches sont utiles.

3. Définition de tâches planifiées multithread basées sur des annotations

1. Statique : basée sur des annotations

Basé sur les annotations@ScheduledLa valeur par défaut est un seul thread Lorsque plusieurs tâches sont démarrées, le temps d'exécution de la tâche sera affecté par le temps d'exécution de la tâche précédente.

1. Créer un minuteur

Utiliser SpringBoot pour créer des tâches planifiées basées sur des annotations est très simple et peut être complété en quelques lignes seulement. de code. Le code est le suivant :

@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());
    }
}

Les paramètres de l'expression Cron représentent respectivement :

secondes (0~59) Par exemple, 0/5 signifie toutes les 5 secondes

minutes (0~59)

heure (0~23)

jour (0~31), besoin de calculer

mois (0~11)

Jour de la semaine (peut être renseigné de 1 à 7 ou SUN/MON/TUE/WED/JEU/VEN/SAT)

@Scheduled : En plus de prise en charge de l'expression de paramètre flexible cron De plus, il prend également en charge les opérations de retard simples, telles que fixDelay et fixRate, il suffit de remplir le nombre correspondant de millisecondes.

2. Démarrez le test

Démarrez l'application et vous pourrez voir les informations suivantes imprimées sur la console :

Évidemment, utiliser l'annotation @Scheduled est très pratique, mais l'inconvénient est que lorsque nous ajustons le cycle d'exécution, nous devons redémarrer l'application pour prendre effet, ce qui est quelque peu gênant. Afin d'obtenir un effet en temps réel, vous pouvez utiliser l'interface pour effectuer des tâches planifiées.

2. Dynamique : Basé sur l'interface

Basé sur l'interface (SchedulingConfigurer)

1. Importer des packages de dépendances

<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. Ajouter des enregistrements de base de données

Ouvrez le base de données locale mysql , ouvrez la fenêtre de requête à volonté, puis exécutez le contenu du script, comme suit :

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 * * * * ?');

Ajoutez ensuite la source de données à application.yml dans le projet :

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

3. Créer une minuterie

Une fois que la base de données a préparé les données, nous écrivons la tâche planifiée. ajouté ici est TriggerTask, qui consiste à parcourir les données que nous avons dans la base de données. Définir le cycle d'exécution et le contenu de l'exécution des tâches planifiées associées.
Le code spécifique est le suivant :

@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. Démarrez le test

Après avoir démarré l'application, vérifiez le console et le temps d'impression est Nous nous attendons à une fois toutes les 10 secondes :

Ensuite, ouvrez Navicat et modifiez le cycle d'exécution pour exécuter toutes les 6 secondes, comme indiqué sur la figure :

En regardant la console, nous avons constaté que le cycle d'exécution a changé et que nous n'avons pas besoin de redémarrer l'application, ce qui est très pratique. Comme le montre l'image :

Remarque : Si une erreur de format se produit lors de la modification de la base de données, la tâche planifiée s'arrêtera, même si la modification est correct ; pour le moment, redémarrez uniquement le projet pour restaurer.

3. Tâches planifiées multi-thread

Définir des tâches planifiées multi-thread basées sur des annotations

1. -tâches planifiées threadées Tâche

//@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. Démarrez le test

Après avoir démarré l'application, vérifiez la console :

Comme on peut le voir depuis la console, la première tâche planifiée et la deuxième tâche planifiée ne s'affectent pas

De plus, Le multi-threading étant activé, le temps d'exécution de la première ; La tâche n'est pas non plus limitée par son propre temps d'exécution, veuillez donc noter que des opérations répétées peuvent provoquer des anomalies de données.

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!