Een inleiding tot Spring Cloud-taak

1. Overzicht

Het doel van Spring Cloud Task is om de functionaliteit te bieden voor het creëren van kortstondige microservices voor de Spring Boot-applicatie.

In Spring Cloud Task hebben we de flexibiliteit om elke taak dynamisch uit te voeren, resources op aanvraag toe te wijzen en de resultaten op te halen nadat de taak is voltooid.

Tasks is een nieuwe primitief binnen Spring Cloud Data Flow waarmee gebruikers vrijwel elke Spring Boot-applicatie als een kortstondige taak kunnen uitvoeren.

2. Het ontwikkelen van een eenvoudige taakapplicatie

2.1. Relevante afhankelijkheden toevoegen

Om te beginnen kunnen we een sectie voor afhankelijkheidsbeheer toevoegen met spring-cloud-task-afhankelijkheden:

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

Dit afhankelijkheidsbeheer beheert versies van afhankelijkheden via het importbereik.

We moeten de volgende afhankelijkheden toevoegen:

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

Dit is de link naar de Maven Central van spring-cloud-task-core.

Om nu onze Spring Boot-applicatie te starten, hebben we spring-boot-starter met de betreffende ouder.

We gaan Spring Data JPA gebruiken als een ORM-tool, dus daarvoor moeten we ook de afhankelijkheid toevoegen:

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

De details van het opstarten van een eenvoudige Spring Boot-applicatie met Spring Data JPA zijn hier beschikbaar.

We kunnen de nieuwste versie van het spring-boot-starter-parent On Maven Central.

2.2. De @EnableTask Annotatie

Om de functionaliteit van Spring Cloud Task op te starten, moeten we @EnableTask annotatie:

@SpringBootApplication @EnableTask openbare klasse TaskDemo {// ...} 

De annotatie brengt SimpleTaskConfiguration klasse op de foto die om beurten de TaskRepository en zijn infrastructuur. Standaard wordt een in-memory map gebruikt om de status van het TaskRepository.

De primaire informatie van TaskRepository is gemodelleerd in Taakuitvoering klasse. De vermelde velden van deze klasse zijn Opdrachtnaam, starttijd, eindtijd, exitMessage. De exitMessage slaat de beschikbare informatie op bij het verlaten van de tijd.

Als een exit wordt veroorzaakt door een storing in de applicatie, wordt hier de volledige uitzonderingsstacktracering opgeslagen.

Spring Boot biedt een interface ExitCodeExceptionMapper die niet-afgevangen uitzonderingen toewijst aan exitcodes, waardoor een nauwkeurige foutopsporing mogelijk is. De Cloud Task slaat de informatie op in de gegevensbron voor toekomstige analyse.

2.3. Configureren van een Databron voor TaskRepository

De in-memory map om het TaskRepository verdwijnt zodra de taak is beëindigd en we verliezen gegevens met betrekking tot taakgebeurtenissen. Om permanent op te slaan, gaan we MySQL gebruiken als gegevensbron met Spring Data JPA.

De gegevensbron is geconfigureerd in application.yml het dossier. Om Spring Cloud Task te configureren om de verstrekte gegevensbron te gebruiken als opslag voor TaskRepository, we moeten een klasse maken die zich uitbreidt DefaultTaskConfigurer.

Nu kunnen we geconfigureerd verzenden Databron als een constructorargument voor de constructor van de superklasse:

@Autowired privé DataSource dataSource; openbare klasse HelloWorldTaskConfigurer breidt DefaultTaskConfigurer uit {openbare HelloWorldTaskConfigurer (DataSource dataSource) {super (dataSource); }}

Om de bovenstaande configuratie in werking te hebben, moeten we een instantie van Databron met @Autowired annotatie en injecteer de instantie als constructor-argument van een HelloWorldTaskConfigurer boon hierboven gedefinieerd:

@Bean openbaar HelloWorldTaskConfigurer getTaskConfigurer () {retourneer nieuwe HelloWorldTaskConfigurer (dataSource); }

Dit voltooit de configuratie om op te slaan TaskRepository naar MySQL-database.

2.4. Implementatie

In Spring Boot, we kunnen elke taak uitvoeren net voordat de applicatie klaar is met opstarten. We kunnen gebruiken ToepassingRunner of CommandLineRunner interfaces om een ​​eenvoudige taak te maken.

We moeten het rennen methode van deze interfaces en declareer de implementatieklasse als een bean:

@Component openbare statische klasse HelloWorldApplicationRunner implementeert ApplicationRunner {@Override public void run (ApplicationArguments arg0) genereert uitzondering {System.out.println ("Hallo wereld van Spring Cloud Task!"); }}

Als we nu onze applicatie draaien, zouden we onze taak moeten krijgen om de nodige uitvoer te produceren met de vereiste tabellen die zijn gemaakt in onze MySQL-database en de gebeurtenisgegevens van de taak vastleggen.

3. Levenscyclus van een Spring Cloud-taak

In het begin maken we een vermelding in de TaskRepository. Dit is de indicatie dat alle bonen klaar zijn om te worden gebruikt in de applicatie en het rennen methode van de Runner-interface is klaar om te worden uitgevoerd.

Na voltooiing van de uitvoering van het rennen methode of bij een mislukking van ApplicationContext evenement, TaskRepository wordt bijgewerkt met een ander item.

Tijdens de taakcyclus kunnen we luisteraars registreren die beschikbaar zijn vanaf TaskExecutionListener koppel. We hebben een klasse nodig die de interface implementeert met drie methoden: onTaskEnd, onTaksFailed en onTaskStartup geactiveerd in respectieve gebeurtenissen van de taak.

We moeten de boon van de uitvoerende klasse in ons TaskDemo klasse:

@Bean openbare TaskListener taskListener () {retourneer nieuwe TaskListener (); }

4. Integratie met Spring Batch

We kunnen Spring Batch Job als een taak uitvoeren en gebeurtenissen van de uitvoering van de Job loggen met behulp van Spring Cloud Task. Om deze functie in te schakelen, moeten we batchafhankelijkheden toevoegen met betrekking tot Boot en Cloud:

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

Hier is de link naar de Maven Central van spring-cloud-task-batch.

Om een ​​taak als een taak te configureren, moeten we de Jobbean hebben geregistreerd in het JobConfiguration klasse:

@Bean public Job job2 () {return jobBuilderFactory.get ("job2") .start (stepBuilderFactory.get ("job2step1") .tasklet (nieuwe Tasklet () {@Override public RepeatStatus uitvoeren (StepContribution-bijdrage, ChunkContext chunkContext) genereert Uitzondering {System.out.println ("Deze taak is van Baeldung"); retourneer RepeatStatus.FINISHED;}}). Build ()). Build (); }

We moeten de TaskDemo les met @EnableBatchProcessing annotatie:

//..Andere aantekening .. @EnableBatchProcessing openbare klasse TaskDemo {// ...}

De @EnableBatchProcessing annotatie maakt Spring Batch-functies mogelijk met een basisconfiguratie die nodig is om batchtaken in te stellen.

Als we de applicatie nu uitvoeren, is het @EnableBatchProcessing annotatie activeert de uitvoering van de Spring Batch Job en Spring Cloud Task registreert de gebeurtenissen van de uitvoeringen van alle batchtaken met de andere taak die wordt uitgevoerd in de springcloud database.

5. Een taak starten vanuit Stream

We kunnen taken activeren vanuit Spring Cloud Stream. Om dit doel te dienen, hebben we de @EnableTaskLaucnher annotatie. Zodra we de annotatie hebben toegevoegd met de Spring Boot-app, is er een TaskSink beschikbaar:

@SpringBootApplication @EnableTaskLauncher openbare klasse StreamTaskSinkApplication {openbare statische leegte hoofd (String [] args) {SpringApplication.run (TaskSinkApplication.class, args); }}

De TaskSink ontvangt het bericht van een stream die een GenericMessage met TaskLaunchRequest als een lading. Vervolgens activeert het een taak op basis van de coördinaat die is opgegeven in het startverzoek van de taak.

Hebben TaskSink functioneel, hebben we een geconfigureerde boon nodig die implementeert TaskLauncher koppel. Voor testdoeleinden bespotten we de implementatie hier:

@Bean openbare TaskLauncher taskLauncher () {terug mock (TaskLauncher.class); }

We moeten hier opmerken dat de TaskLauncher interface is alleen beschikbaar na het toevoegen van de spring-cloud-deployer-local afhankelijkheid:

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

We kunnen testen of de taak is gestart door aan te roepen invoer van de Wastafel koppel:

openbare klasse StreamTaskSinkApplicationTests {@Autowired private Sink sink; //}

Nu maken we een instantie van TaskLaunchRequest en stuur dat als een lading van GenericMessage voorwerp. Dan kunnen we een beroep doen op de invoer kanaal van de Wastafel het behouden van de GenericMessage object in het kanaal.

6. Conclusie

In deze zelfstudie hebben we onderzocht hoe Spring Cloud Task presteert en hoe u deze kunt configureren om de gebeurtenissen in een database te loggen. We hebben ook gezien hoe Spring Batch-taak wordt gedefinieerd en opgeslagen in het TaskRepository. Ten slotte hebben we uitgelegd hoe we Task kunnen activeren vanuit Spring Cloud Stream.

Zoals altijd is de code beschikbaar op GitHub.