Une introduction à la tâche Spring Cloud

1. Vue d'ensemble

L'objectif de Spring Cloud Task est de fournir la fonctionnalité de création de microservices de courte durée pour l'application Spring Boot .

Dans Spring Cloud Task, nous avons la flexibilité d'exécuter n'importe quelle tâche de manière dynamique, d'allouer des ressources à la demande et de récupérer les résultats une fois la tâche terminée.

Tasks est une nouvelle primitive de Spring Cloud Data Flow permettant aux utilisateurs d'exécuter pratiquement n'importe quelle application Spring Boot en tant que tâche de courte durée .

2. Développement d'une application de tâche simple

2.1. Ajout de dépendances pertinentes

Pour commencer, nous pouvons ajouter une section de gestion des dépendances avec spring-cloud-task-dependencies:

   org.springframework.cloud spring-cloud-task-dependencies 2.2.3.RELEASE pom import   

Cette gestion des dépendances gère les versions des dépendances via l'étendue d'importation.

Nous devons ajouter les dépendances suivantes:

 org.springframework.cloud spring-cloud-starter-task   org.springframework.cloud spring-cloud-task-core 

Ceci est le lien vers le Maven Central de spring-cloud-task-core .

Maintenant, pour démarrer notre application Spring Boot, nous avons besoin de spring-boot-starter avec le parent concerné.

Nous allons utiliser Spring Data JPA comme outil ORM, nous devons donc également ajouter la dépendance pour cela:

 org.springframework.boot spring-boot-starter-data-jpa 2.2.6.RELEASE 

Les détails du démarrage d'une simple application Spring Boot avec Spring Data JPA sont disponibles ici.

Nous pouvons vérifier la nouvelle version du printemps-boot-démarreur-mère o n Maven Central.

2.2. L' annotation @EnableTask

Pour amorcer la fonctionnalité de Spring Cloud Task, nous devons ajouter l' annotation @EnableTask :

@SpringBootApplication @EnableTask public class TaskDemo { // ... } 

L'annotation apporte la classe SimpleTaskConfiguration dans l'image qui à son tour enregistre le TaskRepository et son infrastructure . Par défaut, une mappe en mémoire est utilisée pour stocker l'état du TaskRepository .

Les informations principales de TaskRepository sont modélisées dans la classe TaskExecution . Les champs notés de cette classe sont taskName , startTime , endTime , exitMessage . Le EXITMESSAGE stocke les informations disponibles au moment de la sortie.

Si une sortie est provoquée par un échec dans n'importe quel événement de l'application, la trace complète de la pile d'exceptions sera stockée ici.

Spring Boot fournit une interface ExitCodeExceptionMapper qui mappe les exceptions non interceptées aux codes de sortie permettant un débogage scruté . La tâche cloud stocke les informations dans la source de données pour une analyse future.

2.3. Configuration d'un DataSource pour TaskRepository

La carte en mémoire pour stocker le TaskRepository disparaîtra une fois la tâche terminée et nous perdrons les données liées aux événements de tâche. Pour stocker dans un stockage permanent, nous allons utiliser MySQL comme source de données avec Spring Data JPA.

La source de données est configurée dans le fichier application.yml . Pour configurer Spring Cloud Task afin d'utiliser la source de données fournie comme stockage de TaskRepository , nous devons créer une classe qui étend DefaultTaskConfigurer .

Maintenant, nous pouvons envoyer la source de données configurée comme argument de constructeur au constructeur de la superclasse:

@Autowired private DataSource dataSource; public class HelloWorldTaskConfigurer extends DefaultTaskConfigurer{ public HelloWorldTaskConfigurer(DataSource dataSource){ super(dataSource); } }

Pour avoir la configuration ci-dessus en action, nous devons annoter une instance de DataSource avec l' annotation @Autowired et injecter l'instance en tant qu'argument constructeur d'un bean HelloWorldTaskConfigurer défini ci-dessus:

@Bean public HelloWorldTaskConfigurer getTaskConfigurer() { return new HelloWorldTaskConfigurer(dataSource); }

Ceci termine la configuration pour stocker TaskRepository dans la base de données MySQL.

2.4. la mise en oeuvre

Dans Spring Boot, nous pouvons exécuter n'importe quelle tâche juste avant que l'application ne termine son démarrage. Nous pouvons utiliser les interfaces ApplicationRunner ou CommandLineRunner pour créer une tâche simple.

Nous devons implémenter la méthode run de ces interfaces et déclarer la classe d'implémentation comme un bean:

@Component public static class HelloWorldApplicationRunner implements ApplicationRunner { @Override public void run(ApplicationArguments arg0) throws Exception { System.out.println("Hello World from Spring Cloud Task!"); } }

Maintenant, si nous exécutons notre application, nous devrions obtenir notre tâche de produire la sortie nécessaire avec les tables requises créées dans notre base de données MySQL enregistrant les données d'événement de la tâche.

3. Cycle de vie d'une tâche Spring Cloud

Au début, nous créons une entrée dans le TaskRepository . C'est l'indication que tous les beans sont prêts à être utilisés dans l'application et que la méthode d' exécution de l'interface Runner est prête à être exécutée.

À la fin de l'exécution de la méthode d' exécution ou en cas d'échec de l' événement ApplicationContext , TaskRepository sera mis à jour avec une autre entrée.

Pendant le cycle de vie de la tâche, nous pouvons enregistrer des écouteurs disponibles à partir de l' interface TaskExecutionListener . Nous avons besoin d'une classe implémentant l'interface ayant trois méthodes - onTaskEnd , onTaksFailed et onTaskStartup déclenchées dans les événements respectifs de la tâche.

Nous devons déclarer le bean de la classe d'implémentation dans notre classe TaskDemo :

@Bean public TaskListener taskListener() { return new TaskListener(); }

4. Intégration avec Spring Batch

We can execute Spring Batch Job as a Task and log events of the Job execution using Spring Cloud Task. To enable this feature we need to add Batch dependencies pertaining to Boot and Cloud:

 org.springframework.boot spring-boot-starter-batch   org.springframework.cloud spring-cloud-task-batch 

Here is the link to the Maven Central of spring-cloud-task-batch.

To configure a job as a Task we need to have the Job bean registered in the JobConfiguration class:

@Bean public Job job2() { return jobBuilderFactory.get("job2") .start(stepBuilderFactory.get("job2step1") .tasklet(new Tasklet(){ @Override public RepeatStatus execute( StepContribution contribution, ChunkContext chunkContext) throws Exception { System.out.println("This job is from Baeldung"); return RepeatStatus.FINISHED; } }).build()).build(); }

We need to decorate the TaskDemo class with @EnableBatchProcessing annotation:

//..Other Annotation.. @EnableBatchProcessing public class TaskDemo { // ... }

The @EnableBatchProcessing annotation enables Spring Batch features with a base configuration required to set up batch jobs.

Now, if we run the application, the @EnableBatchProcessing annotation will trigger the Spring Batch Job execution and Spring Cloud Task will log the events of the executions of all batch jobs with the other Task executed in the springcloud database.

5. Launching a Task from Stream

We can trigger Tasks from Spring Cloud Stream. To serve this purpose, we have the @EnableTaskLaucnher annotation. Once, we add the annotation with Spring Boot app, a TaskSink will be available:

@SpringBootApplication @EnableTaskLauncher public class StreamTaskSinkApplication { public static void main(String[] args) { SpringApplication.run(TaskSinkApplication.class, args); } }

The TaskSink receives the message from a stream that contains a GenericMessage containing TaskLaunchRequest as a payload. Then it triggers a Task-based on co-ordinate provided in the Task launch request.

To have TaskSink functional, we require a bean configured that implements TaskLauncher interface. For testing purpose, we're mocking the implementation here:

@Bean public TaskLauncher taskLauncher() { return mock(TaskLauncher.class); }

We need to note here that the TaskLauncher interface is only available after adding the spring-cloud-deployer-local dependency:

 org.springframework.cloud spring-cloud-deployer-local 2.3.1.RELEASE 

We can test whether the Task launched by invoking input of the Sink interface:

public class StreamTaskSinkApplicationTests { @Autowired private Sink sink; // }

Maintenant, nous créons une instance de TaskLaunchRequest et l'envoyons en tant que charge utile de l' objet GenericMessage . Ensuite, nous pouvons invoquer le canal d' entrée du Sink en conservant l' objet GenericMessage dans le canal.

6. Conclusion

Dans ce didacticiel, nous avons exploré le fonctionnement de Spring Cloud Task et comment le configurer pour enregistrer ses événements dans une base de données. Nous avons également observé comment le travail Spring Batch est défini et stocké dans le TaskRepository . Enfin, nous avons expliqué comment nous pouvons déclencher Task à partir de Spring Cloud Stream.

Comme toujours, le code est disponible sur sur GitHub.