streamalism.org

1. Oversikt

Målet med Spring Cloud Task er å tilby funksjonaliteten til å lage kortvarige mikrotjenester for Spring Boot-applikasjon.

I Spring Cloud Task har vi fleksibiliteten til å kjøre en hvilken som helst oppgave dynamisk, fordele ressurser etter behov og hente resultatene etter at oppgaven er fullført.

Tasks er en ny primitiv innen Spring Cloud Data Flow som lar brukerne utføre praktisk talt alle Spring Boot-applikasjoner som en kortvarig oppgave.

2. Utvikle en enkel oppgaveapplikasjon

2.1. Legge til relevante avhengigheter

For å starte kan vi legge til avhengighetsadministrasjon med vår-sky-oppgave-avhengigheter:

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

Denne avhengighetsadministrasjonen styrer versjoner av avhengigheter gjennom importområdet.

Vi må legge til følgende avhengigheter:

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

Dette er lenken til Maven Central of vår-sky-oppgave-kjerne.

Nå, for å starte vår Spring Boot-applikasjon, trenger vi spring-boot-starter med den aktuelle forelderen.

Vi skal bruke Spring Data JPA som et ORM-verktøy, så vi må legge til avhengigheten for det også:

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

Detaljer om bootstrapping av en enkel Spring Boot-applikasjon med Spring Data JPA er tilgjengelig her.

Vi kan sjekke den nyeste versjonen av spring-boot-starter-parent on Maven Central.

2.2. De @EnableTask Kommentar

For å starte funksjonaliteten til Spring Cloud Task, må vi legge til @EnableTask kommentar:

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

Merknaden bringer SimpleTaskConfiguration klasse på bildet som i sin tur registrerer TaskRepository og dens infrastruktur. Som standard brukes et minnekart til å lagre statusen til TaskRepository.

Den primære informasjonen til TaskRepository er modellert i TaskExecution klasse. De bemerkede feltene i denne klassen er oppgavenavn, starttid, sluttid, exitMessage. De exitMessage lagrer tilgjengelig informasjon på utgangstidspunktet.

Hvis en utgang er forårsaket av en feil under alle omstendigheter av applikasjonen, vil hele unntaksspor lagres her.

Spring Boot gir et grensesnitt ExitCodeExceptionMapper som kartlegger ufangede unntak fra utgangskoder som muliggjør gransket feilsøking. Cloud Task lagrer informasjonen i datakilden for fremtidig analyse.

2.3. Konfigurere en Datakilde til TaskRepository

Kartet i minnet for å lagre TaskRepository forsvinner når oppgaven er avsluttet, og vi mister data relatert til oppgavehendelser. For å lagre på en permanent lagring, skal vi bruke MySQL som datakilde med Spring Data JPA.

Datakilden er konfigurert i application.yml fil. Å konfigurere Spring Cloud Task til å bruke den oppgitte datakilden som lagring av TaskRepository, må vi lage en klasse som strekker seg DefaultTaskConfigurer.

Nå kan vi sende konfigurert Datakilde som et konstruktørargument til superklassens konstruktør:

@Autowired private DataSource dataSource; offentlig klasse HelloWorldTaskConfigurer utvider DefaultTaskConfigurer {offentlig HelloWorldTaskConfigurer (DataSource dataSource) {super (dataSource); }}

For å ha konfigurasjonen ovenfor i handling, må vi kommentere en forekomst av Datakilde med @Autowired kommentar og injisere forekomsten som konstruktør-argument av en HelloWorldTaskConfigurer bønne definert ovenfor:

@Bean offentlig HelloWorldTaskConfigurer getTaskConfigurer () {returner nye HelloWorldTaskConfigurer (dataSource); }

Dette fullfører konfigurasjonen for å lagre TaskRepository til MySQL-databasen.

2.4. Gjennomføring

I vårstøvel, vi kan utføre en hvilken som helst oppgave rett før applikasjonen er ferdig oppstart. Vi kan bruke ApplicationRunner eller CommandLineRunner grensesnitt for å lage en enkel oppgave.

Vi må implementere løpe metode for disse grensesnittene og erklære implementeringsklassen som en bønne:

@Komponent offentlig statisk klasse HelloWorldApplicationRunner implementerer ApplicationRunner {@Override public void run (ApplicationArguments arg0) kaster Unntak {System.out.println ("Hello World from Spring Cloud Task!"); }}

Nå, hvis vi kjører applikasjonen vår, bør vi få oppgaven vår til å produsere nødvendig utdata med nødvendige tabeller opprettet i MySQL-databasen og logge hendelsesdataene til oppgaven.

3. Livssyklus for en Spring Cloud Task

I begynnelsen oppretter vi en oppføring i TaskRepository. Dette er indikasjonen på at alle bønner er klare til å brukes i applikasjonen og løpe metoden for Runner-grensesnittet er klar til å kjøres.

Etter fullført gjennomføring av løpe metoden eller i svikt i ApplicationContext begivenhet, TaskRepository vil bli oppdatert med en annen oppføring.

I løpet av oppgavens livssyklus kan vi registrere lyttere tilgjengelig fra TaskExecutionListener grensesnitt. Vi trenger en klasse som implementerer grensesnittet med tre metoder - onTaskEnd, onTaksFailed og onTaskStartup utløst i respektive hendelser i oppgaven.

Vi må erklære bønnen til implementeringsklassen i vår TaskDemo klasse:

@Bean offentlig TaskListener taskListener () {returner ny TaskListener (); }

4. Integrasjon med Spring Batch

Vi kan utføre Spring Batch Job som en oppgave og logge hendelser for jobbutførelsen ved hjelp av Spring Cloud Task. For å aktivere denne funksjonen må vi legge til Batchavhengigheter knyttet til Boot og Cloud:

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

Her er lenken til Maven Central of vår-sky-oppgave-batch.

For å konfigurere en jobb som en oppgave, må vi ha Jobbean registrert i JobConfiguration klasse:

@Bean public Job job2 () {return jobBuilderFactory.get ("job2") .start (stepBuilderFactory.get ("job2step1"). Oppgave (ny Tasklet () {@ Override public RepeatStatus utfører (StepContribution-bidrag, ChunkContext chunkContext) kaster Unntak {System.out.println ("Denne jobben er fra Baeldung"); returner RepeatStatus.FINISHED;}}). Build ()). Build (); }

Vi trenger å dekorere TaskDemo klasse med @EnableBatchProcessing kommentar:

//..Andre merknader .. @EnableBatchProcessing offentlig klasse TaskDemo {// ...}

De @EnableBatchProcessing merknader muliggjør Spring Batch-funksjoner med en grunnkonfigurasjon som kreves for å sette opp batchjobber.

Nå, hvis vi kjører applikasjonen, @EnableBatchProcessing merknad vil utløse kjøring av Spring Batch Job og Spring Cloud Task vil logge hendelsene for kjøringen av alle batchjobber med den andre oppgaven som utføres i springcloud database.

5. Starte en oppgave fra Stream

Vi kan utløse oppgaver fra Spring Cloud Stream. For å tjene dette formålet har vi @EnableTaskLaucnher kommentar. Når vi legger til merknaden med Spring Boot-appen, vil en TaskSink være tilgjengelig:

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

De TaskSink mottar meldingen fra en strøm som inneholder en GenericMessage inneholder TaskLaunchRequest som nyttelast. Deretter utløser det en oppgave basert på koordinering gitt i oppgavelanseringsforespørselen.

Å ha TaskSink funksjonell, krever vi en bønne konfigurert som implementerer TaskLauncher grensesnitt. For testformål håner vi implementeringen her:

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

Vi må merke oss her at TaskLauncher grensesnittet er bare tilgjengelig etter at du har lagt til spring-cloud-deployer-local avhengighet:

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

Vi kan teste om oppgaven ble lansert ved å påkalle inngang av Synke grensesnitt:

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

Nå oppretter vi en forekomst av TaskLaunchRequest og send det som en nyttelast på GenericMessage gjenstand. Da kan vi påberope oss inngang kanalen til Synke holde GenericMessage objekt i kanalen.

6. Konklusjon

I denne opplæringen har vi utforsket hvordan Spring Cloud Task utfører, og hvordan du konfigurerer den til å logge hendelsene i en database. Vi observerte også hvordan Spring Batch-jobben er definert og lagret i TaskRepository. Til slutt forklarte vi hvordan vi kan utløse oppgave fra Spring Cloud Stream.

Som alltid er koden tilgjengelig på GitHub.