Traitement par lots avec flux de données Spring Cloud

1. Vue d’ensemble

Dans le lien:/spring-cloud-data-flux-stream-processing[premier]article de la série, nous avons présenté le composant architectural de Spring Cloud Data Flow et son utilisation pour créer un pipeline de données en continu.

Contrairement à un pipeline de flux, dans lequel une quantité illimitée de données est traitée, un traitement par lots facilite la création de services de courte durée dans lesquels les tâches sont exécutées à la demande .

** 2. Serveur de flux de données local et Shell

Local Data Flow Server est un composant responsable du déploiement d’applications, tandis que le Data Flow Shell

Dans le lien:/spring-cloud-data-flux-stream-processing[article précédent], nous avons utilisé Spring Initilizr pour les configurer en tant qu’application de démarrage Spring.

Après avoir ajouté l’annotation @ EnableDataFlowServer à la classe principale server’s et l’annotation @ EnableDataFlowShell à la classe principale du shell, ils sont prêts à être lancés en effectuant:

mvn spring-boot:run

Le serveur démarrera sur le port 9393 et un shell sera prêt à interagir avec ce dernier à l’invite.

Vous pouvez vous reporter à l’article précédent pour savoir comment obtenir et utiliser un Local Data Flow Server et son client shell.

3. L’application batch

Comme avec le serveur et le shell, nous pouvons utiliser Spring Initilizr pour configurer une application batch root Spring Boot .

Après avoir atteint le site Web, il suffit de choisir un Group , un nom Artifact et de sélectionner Cloud Task dans la zone de recherche des dépendances.

Une fois que cela est fait, cliquez sur le bouton Generate Project pour commencer à télécharger l’artefact Maven.

L’artefact est préconfiguré et avec un code de base. Voyons comment l’éditer afin de construire notre application batch.

3.1. Dépendances Maven

Tout d’abord, ajoutons quelques dépendances Maven. Comme il s’agit d’une application batch, nous devons importer des bibliothèques à partir du Spring Batch Project :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-batch</artifactId>
</dependency>

De plus, étant donné que Spring Cloud Task utilise une base de données relationnelle pour stocker les résultats d’une tâche exécutée, nous devons ajouter une dépendance à un pilote de SGBDR: ``

<dependency>
    <groupId>com.h2database</groupId>
    <artifactId>h2</artifactId>
</dependency>

Nous avons choisi d’utiliser la base de données H2 en mémoire fournie par Spring. Cela nous donne une méthode simple pour amorcer le développement. Cependant, dans un environnement de production, vous souhaiterez configurer votre propre DataSource .

N’oubliez pas que les versions des artefacts seront héritées du fichier pom.xml parent de Spring Boot.

3.2. Classe principale

Pour activer la fonctionnalité souhaitée, il est essentiel d’ajouter les annotations @ EnableTask et @ EnableBatchProcessing à la classe principale Spring Boot’s . Cette annotation de niveau de classe indique à Spring Cloud Task de tout amorcer:

@EnableTask
@EnableBatchProcessing
@SpringBootApplication
public class BatchJobApplication {

    public static void main(String[]args) {
        SpringApplication.run(BatchJobApplication.class, args);
    }
}

3.3. Configuration du travail

Enfin, configurons un travail - dans ce cas, une simple impression d’un Chaîne dans un fichier journal:

@Configuration
public class JobConfiguration {

    private static Log logger
      = LogFactory.getLog(JobConfiguration.class);

    @Autowired
    public JobBuilderFactory jobBuilderFactory;

    @Autowired
    public StepBuilderFactory stepBuilderFactory;

    @Bean
    public Job job() {
        return jobBuilderFactory.get("job")
          .start(stepBuilderFactory.get("jobStep1")
          .tasklet(new Tasklet() {

              @Override
              public RepeatStatus execute(StepContribution contribution,
                ChunkContext chunkContext) throws Exception {

                logger.info("Job was run");
                return RepeatStatus.FINISHED;
              }
        }).build()).build();
    }
}

Pour plus d’informations, vous pouvez voir notre article de lien:/introduction-to-spring-batch[Introduction à Spring Batch].

Enfin, notre application est prête. Nous allons l’installer dans notre dépôt Maven local. Pour cela, cd dans le répertoire racine du projet et lancez la commande:

mvn clean install

Il est maintenant temps de placer l’application dans le Data Flow Server.

4. Enregistrement de l’application

Pour enregistrer l’application dans le registre d’applications, nous devons fournir un nom unique, un type d’application et un URI pouvant être résolu en artefact d’application.

Accédez au shell de flux de données Cloud __Spring et lancez la commande à l’invite:

app register --name batch-job --type task
  --uri maven://org.baeldung.spring.cloud:batch-job:jar:0.0.1-SNAPSHOT

5. Créer une tâche

Une définition de tâche peut être créée à l’aide de la commande:

task create myjob --definition batch-job

Cela crée une nouvelle tâche avec le nom myjob pointant vers la candidature précédemment enregistrée.

Une liste des définitions de tâches en cours peut être obtenue en utilisant la commande:

task list

6. Lancer une tâche

Pour lancer une tâche, nous pouvons utiliser la commande:

task launch myjob

Une fois la tâche lancée, son état est stocké dans une base de données relationnelle. Nous pouvons vérifier l’état de nos exécutions de tâches avec la commande:

task execution list

7. Révision du résultat

Dans cet exemple, le travail imprime simplement une chaîne dans un fichier journal. Les fichiers journaux se trouvent dans le répertoire affiché dans la sortie du journal du Data Flow Server .

Pour voir le résultat, nous pouvons suivre le journal:

tail -f PATH__TO__LOG\spring-cloud-dataflow-2385233467298102321\myjob-1472827120414\myjob[...]---[main]o.s.batch.core.job.SimpleStepHandler: Executing step:[jobStep1][...]---[main]o.b.spring.cloud.JobConfiguration: Job was run[...]---[main]o.s.b.c.l.support.SimpleJobLauncher:
  Job:[SimpleJob:[name=job]]completed with the following parameters:
   [{}]and the following status:[COMPLETED]----

[[Conclusion]]

===  **  8. Conclusion**

Dans cet article, nous avons montré comment traiter le traitement par lots en utilisant __Spring Cloud Data Flow__.

L'exemple de code se trouve dans le projet https://github.com/eugenp/tutorials/tree/master/spring-cloud-data-flow[GitHub]

TOC