Eine Einführung in die Spring Cloud-Aufgabe
1. Überblick
The goal of Spring Cloud Task is to provide the functionality of creating short-lived microservices for Spring Boot application.
In Spring Cloud Task haben wir die Flexibilität, jede Aufgabe dynamisch auszuführen, Ressourcen bei Bedarf zuzuweisen und die Ergebnisse nach Abschluss der Aufgabe abzurufen.
Tasks is a new primitive within Spring Cloud Data Flow allowing users to execute virtually any Spring Boot application as a short-lived task.
2. Entwickeln einer einfachen Aufgabenanwendung
2.1. Relevante Abhängigkeiten hinzufügen
Zu Beginn können wir einen Abschnitt zum Abhängigkeitsmanagement mitspring-cloud-task-dependencies: hinzufügen
org.springframework.cloud
spring-cloud-task-dependencies
1.2.2.RELEASE
pom
import
Dieses Abhängigkeitsmanagement verwaltet Versionen von Abhängigkeiten über den Importbereich.
Wir müssen die folgenden Abhängigkeiten hinzufügen:
org.springframework.cloud
spring-cloud-starter-task
org.springframework.cloud
spring-cloud-task-core
This ist die Verbindung zum Maven Central vonspring-cloud-task-core.
Um unsere Spring Boot-Anwendung zu starten, benötigen wirspring-boot-starter mit dem entsprechenden übergeordneten Element.
Wir werden Spring Data JPA als ORM-Tool verwenden, daher müssen wir auch die Abhängigkeit dafür hinzufügen:
org.springframework.boot
spring-boot-starter-data-jpa
1.5.10
Die Details zum Bootstrapping einer einfachen Spring Boot-Anwendung mit Spring Data JPA sind inhere verfügbar.
Wir können die neueste Version vonspring-boot-starter-parent onMaven Central überprüfen.
2.2. Die Annotation@EnableTask
Um die Funktionalität von Spring Cloud Task zu booten, müssen Sie die Anmerkung von@EnableTaskhinzufügen:
@SpringBootApplication
@EnableTask
public class TaskDemo {
// ...
}The annotation brings SimpleTaskConfiguration class in the picture which in turns registers the TaskRepository and its infrastructure. Standardmäßig wird eine In-Memory-Map verwendet, um den Status vonTaskRepository zu speichern.
Die Primärinformationen vonTaskRepository werden in der KlasseTaskExecution modelliert. Die angegebenen Felder dieser Klasse sindtaskName,startTime,endTime,exitMessage. DasexitMessage speichert die verfügbaren Informationen zum Ausgangszeitpunkt.
Wenn ein Exit durch einen Fehler in einem Anwendungsfall verursacht wird, wird der vollständige Ausnahmestapel-Trace hier gespeichert.
Spring Boot provides an interface ExitCodeExceptionMapper which maps uncaught exceptions to exit codes allowing scrutinized debug. Die Cloud-Aufgabe speichert die Informationen in der Datenquelle für zukünftige Analysen.
2.3. DataSource konfigurieren FürTaskRepository
Die speicherinterne Zuordnung zum Speichern derTaskRepository verschwindet nach Beendigung der Aufgabe und wir verlieren Daten im Zusammenhang mit Aufgabenereignissen. Zum Speichern in einem permanenten Speicher verwenden wir MySQL als Datenquelle mit Spring Data JPA.
Die Datenquelle wird in der Dateiapplication.ymlkonfiguriert. Um Spring Cloud Task so zu konfigurieren, dass die bereitgestellte Datenquelle als Speicher fürTaskRepository verwendet wird, müssen Sie eine Klasse erstellen, dieDefaultTaskConfigurer erweitert.
Jetzt können wir konfigurierteDatasource als Konstruktorargument an den Konstruktor der Oberklasse senden:
@Autowired
private DataSource dataSource;
public class HelloWorldTaskConfigurer extends DefaultTaskConfigurer{
public HelloWorldTaskConfigurer(DataSource dataSource){
super(dataSource);
}
}Um die obige Konfiguration in Aktion zu setzen, müssen wir eine Instanz vonDataSource mit@Autowired Annotation versehen und die Instanz als Konstruktorargument einer oben definiertenHelloWorldTaskConfigurer-Bean einfügen:
@Bean
public HelloWorldTaskConfigurer getTaskConfigurer() {
return new HelloWorldTaskConfigurer(dataSource);
}Damit ist die Konfiguration zum Speichern vonTaskRepository in der MySQL-Datenbank abgeschlossen.
2.4. Implementierung
In Spring Boot,we can execute any Task just before application finishes its startup. Wir könnenApplicationRunner oderCommandLineRunner Schnittstellen verwenden, um eine einfache Aufgabe zu erstellen.
Wir müssen dierun-Methode dieser Schnittstellen implementieren und die implementierende Klasse als Bean deklarieren:
@Component
public static class HelloWorldApplicationRunner
implements ApplicationRunner {
@Override
public void run(ApplicationArguments arg0) throws Exception {
System.out.println("Hello World from Spring Cloud Task!");
}
}Wenn wir jetzt unsere Anwendung ausführen, sollten wir unsere Aufgabe veranlassen, die erforderliche Ausgabe mit den erforderlichen Tabellen zu erzeugen, die in unserer MySQL-Datenbank erstellt wurden und die Ereignisdaten der Aufgabe aufzeichnen.
3. Lebenszyklus einer Spring Cloud-Aufgabe
Zu Beginn erstellen wir einen Eintrag inTaskRepository. Dies ist der Hinweis darauf, dass alle Beans zur Verwendung in der Anwendung bereit sind und dierun-Methode der Runner-Schnittstelle zur Ausführung bereit ist.
Nach Abschluss der Ausführung derrun-Methode oder bei einem Fehler desApplicationContext-Ereignisses wirdTaskRepository mit einem anderen Eintrag aktualisiert.
During the task life-cycle, we can register listeners available from TaskExecutionListener interface. Wir brauchen eine Klasse, die die Schnittstelle mit drei Methoden implementiert -onTaskEnd,onTaksFailed undonTaskStartup, die in den jeweiligen Ereignissen der Aufgabe ausgelöst werden.
Wir müssen die Bean der implementierenden Klasse in unsererTaskDemo-Klasse deklarieren:
@Bean
public TaskListener taskListener() {
return new TaskListener();
}4. Integration mit Spring Batch
Wir können Spring Batch Job als Task ausführen und Ereignisse der Jobausführung mit Spring Cloud Task protokollieren. Um diese Funktion zu aktivieren, müssen Stapelabhängigkeiten für Boot und Cloud hinzugefügt werden:
org.springframework.boot
spring-boot-starter-batch
org.springframework.cloud
spring-cloud-task-batch
Here ist die Verbindung zum Maven Central vonspring-cloud-task-batch.
Um einen Job als Task zu konfigurieren, muss die Job-Bean in der KlasseJobConfigurationregistriert sein:
@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 example");
return RepeatStatus.FINISHED;
}
}).build()).build();
}We need to decorate the TaskDemo class with @EnableBatchProcessing annotation:
//..Other Annotation..
@EnableBatchProcessing
public class TaskDemo {
// ...
}Die Annotation@EnableBatchProcessing aktiviert Spring Batch-Funktionen mit einer Basiskonfiguration, die zum Einrichten von Batch-Jobs erforderlich ist.
Wenn wir nun die Anwendung ausführen, löst die Annotation@EnableBatchProcessingdie Ausführung des Spring-Batch-Jobs aus, und die Spring Cloud-Task protokolliert die Ereignisse der Ausführung aller Batch-Jobs mit der anderen Task, die in der Datenbankspringcloudausgeführt wird .
5. Starten einer Aufgabe aus dem Stream
Wir können Aufgaben aus Spring Cloud Stream auslösen. Zu diesem Zweck haben wir die Annotation@EnableTaskLaucnher. Sobald wir die Annotation mit der Spring Boot App hinzugefügt haben, wird ein TaskSink verfügbar sein:
@SpringBootApplication
@EnableTaskLauncher
public class StreamTaskSinkApplication {
public static void main(String[] args) {
SpringApplication.run(TaskSinkApplication.class, args);
}
}DieTaskSink empfangen die Nachricht von einem Stream, derGenericMessage enthält, dieTaskLaunchRequest als Nutzlast enthalten. Anschließend wird eine auf der in der Task-Startanforderung angegebenen Koordinate basierende Task ausgelöst.
To have TaskSink functional, we require a bean configured that implements TaskLauncher interface. Zu Testzwecken verspotten wir die Implementierung hier:
@Bean
public TaskLauncher taskLauncher() {
return mock(TaskLauncher.class);
}Wir müssen hier beachten, dass dieTaskLauncher-Schnittstelle nur verfügbar ist, nachdem diespring-cloud-deployer-local-abhängigkeit hinzugefügt wurde:
org.springframework.cloud
spring-cloud-deployer-local
1.3.1.RELEASE
Wir können testen, ob die Task gestartet wurde, indem wirinput derSink-Schnittstelle aufrufen:
public class StreamTaskSinkApplicationTests {
@Autowired
private Sink sink;
//
}Jetzt erstellen wir eine Instanz vonTaskLaunchRequest und senden diese als Nutzlast vonGenericMessage<TaskLaunchRequest> Objekt. Dann können wir den KanalinputdesSink aufrufen und das ObjektGenericMessageim Kanal behalten.
6. Fazit
In diesem Lernprogramm haben wir untersucht, wie Spring Cloud Task ausgeführt wird und wie es so konfiguriert wird, dass seine Ereignisse in einer Datenbank protokolliert werden. Wir haben auch beobachtet, wie der Spring Batch-Job inTaskRepository definiert und gespeichert wird. Zuletzt haben wir erklärt, wie wir Task in Spring Cloud Stream auslösen können.
Wie immer ist der Codeover on GitHub verfügbar.