Stapelverarbeitung mit Spring Cloud-Datenfluss

1. Überblick

Im Artikel erster der Serie haben wir die Architekturkomponente von Spring Cloud Data Flow vorgestellt und deren Verwendung zur Erstellung einer Streaming-Datenpipeline beschrieben.

Im Gegensatz zu einer Stream-Pipeline, bei der eine unbegrenzte Datenmenge verarbeitet wird, können mit einem Stapelprozess einfach kurzlebige Services erstellt werden, bei denen Aufgaben nach Bedarf ausgeführt werden .

** 2. Local Data Flow Server und Shell

Der Local Data Flow Server ist eine Komponente, die für die Bereitstellung von Anwendungen verantwortlich ist, während die Data Flow Shell dies zulässt

Im Link:/spring-cloud-data-flow-stream-processing[vorheriger Artikel]verwendeten wir Spring Initilizr , um beide als Spring Boot-Anwendung einzurichten.

Nach dem Hinzufügen der Annotation @ EnableDataFlowServer zur Hauptklasse server’s und der Annotation @ EnableDataFlowShell zur Hauptklasse der Shell können sie gestartet werden, indem sie

mvn spring-boot:run

Der Server wird an Port 9393 gestartet und eine Shell kann von der Eingabeaufforderung aus mit dem Server interagieren.

Informationen zum Beziehen und Verwenden eines Local Data Flow Server und seines Shell-Clients finden Sie im vorherigen Artikel.

3. Die Batch-Anwendung

Wie beim Server und der Shell können wir Spring Initilizr verwenden, um eine root Spring Boot -Stapelanwendung einzurichten.

Wenn Sie die Website erreicht haben, wählen Sie einfach eine Group , einen Artifact -Namen und wählen Sie Cloud Task aus dem Suchfeld für Abhängigkeiten.

Klicken Sie anschließend auf die Schaltfläche Generate Project , um den Download des Maven-Artefakts zu starten.

Das Artefakt wird vorkonfiguriert und mit Basiscode geliefert. Mal sehen, wie man es bearbeitet, um unsere Stapelanwendung zu erstellen.

3.1. Abhängigkeiten von Maven

Fügen wir zunächst einige Abhängigkeiten von Maven hinzu. Da dies eine Stapelanwendung ist, müssen wir Bibliotheken aus dem Spring-Stapelprojekt importieren:

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

Da der Spring Cloud-Task zum Speichern der Ergebnisse einer ausgeführten Task eine relationale Datenbank verwendet, müssen wir einem RDBMS-Treiber eine Abhängigkeit hinzufügen:

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

Wir haben uns für die H2-In-Memory-Datenbank von Spring entschieden. Dies gibt uns eine einfache Methode der Bootstrapping-Entwicklung. In einer Produktionsumgebung möchten Sie jedoch Ihre eigene DataSource konfigurieren.

Beachten Sie, dass die Versionen der Artefakte von der übergeordneten pom.xml -Datei von Spring Boot geerbt werden.

3.2. Hauptklasse

Der Schlüssel zum Aktivieren der gewünschten Funktionalität wäre das Hinzufügen der Annotationen @ EnableTask und @ EnableBatchProcessing zur Hauptklasse __Spring Boot '. Diese Annotation auf Klassenebene weist Spring Cloud Task an, alles zu bootstrappen:

@EnableTask
@EnableBatchProcessing
@SpringBootApplication
public class BatchJobApplication {

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

3.3. Auftragskonfiguration

Zuletzt konfigurieren wir einen Job - in diesem Fall einen einfachen Ausdruck eines String in eine Protokolldatei:

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

Weitere Informationen finden Sie in unserem Link:/Einführung zu Spring-Batch-Artikel

Endlich ist unsere Bewerbung fertig. Installieren wir es in unserem lokalen Maven-Repository. Führen Sie dazu cd im Stammverzeichnis des Projekts aus und geben Sie den Befehl ein:

mvn clean install

Nun ist es an der Zeit, die Anwendung in den __Data Flow Server zu integrieren.

4. Registrierung der Anwendung

Um die Anwendung im App-Register zu registrieren, müssen Sie einen eindeutigen Namen, einen Anwendungstyp und einen URI angeben, der in das App-Artefakt aufgelöst werden kann.

Gehen Sie zur Spring Cloud Data Flow Shell und geben Sie den Befehl an der Eingabeaufforderung aus:

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

5. Aufgabe erstellen

Eine Aufgabendefinition kann mit dem Befehl erstellt werden:

task create myjob --definition batch-job

Dadurch wird eine neue Aufgabe mit dem Namen myjob erstellt, die auf die zuvor registrierte Batch-Jobanwendung verweist.

Eine Liste der aktuellen Aufgabendefinitionen erhalten Sie mit dem Befehl:

task list

6. Aufgabe starten

Um eine Aufgabe zu starten, können wir den Befehl verwenden:

task launch myjob

Sobald die Task gestartet wird, wird der Status der Task in einer relationalen Datenbank gespeichert. Wir können den Status unserer Aufgabenausführung mit dem Befehl überprüfen:

task execution list

7. Ergebnis überprüfen

In diesem Beispiel druckt der Job einfach eine Zeichenfolge in einer Protokolldatei. Die Protokolldateien befinden sich in dem Verzeichnis, das in der Protokollausgabe von Data Flow Server angezeigt wird.

Um das Ergebnis zu sehen, können wir das Protokoll protokollieren:

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. Fazit**

In diesem Artikel haben wir gezeigt, wie mit der Stapelverarbeitung durch die Verwendung von __Spring Cloud Data Flow__ verfahren werden kann.

Der Beispielcode ist im Projekt https://github.com/eugenp/tutorials/tree/master/spring-cloud-data-flow[GitHub zu finden.

TOC