Achtergrondbanen in het voorjaar met JobRunr

1. Overzicht

In deze zelfstudie gaan we met JobRunr kijken naar gedistribueerde taakplanning en verwerking op de achtergrond in Java en deze laten integreren met Spring.

2. Over JobRunr

JobRunr is een bibliotheek die we in onze applicatie kunnen insluiten en waarmee we achtergrondtaken kunnen plannen met behulp van een Java 8-lambda. We kunnen elke bestaande methode van onze Spring-services gebruiken om een ​​baan te creëren zonder dat we een interface hoeven te implementeren. Een taak kan een kort of langlopend proces zijn en wordt automatisch overgebracht naar een achtergrondthread zodat het huidige webverzoek niet wordt geblokkeerd.

Om zijn werk te kunnen doen, analyseert JobRunr de Java 8 lambda. Het serialiseert het als JSON en slaat het op in een relationele database of een NoSQL-gegevensopslag.

3. JobRunr-functies

Als we zien dat we te veel achtergrondtaken produceren en onze server de belasting niet aankan, kunnen we dat gemakkelijk doen schaal horizontaal door gewoon extra exemplaren van onze applicatie toe te voegen. JobRunr zal de belasting automatisch delen en alle taken over de verschillende instanties van onze applicatie verdelen.

Het bevat ook een automatische functie voor opnieuw proberen met een exponentieel uitstelbeleid voor mislukte banen. Er is ook een ingebouwd dashboard waarmee we alle jobs kunnen volgen. JobRunr is zelfonderhoud - geslaagde taken worden automatisch verwijderd na een configureerbare hoeveelheid tijd, zodat het niet nodig is om de opslag handmatig op te schonen.

4. Installatie

Eenvoudigheidshalve gebruiken we een gegevensopslag in het geheugen om alle taakgerelateerde informatie op te slaan.

4.1. Maven-configuratie

Laten we meteen naar de Java-code gaan. Maar daarvoor moeten we de volgende Maven-afhankelijkheid hebben verklaard in onze pom.xml het dossier:

 org.jobrunr jobrunr-spring-boot-starter 1.1.0 

4.2. Lente-integratie

Voordat we meteen beginnen met het maken van achtergrondtaken, moeten we JobRunr initialiseren. Omdat we de jobrunr-spring-boot-starter afhankelijkheid, dit is eenvoudig. We hoeven slechts enkele eigenschappen toe te voegen aan het application.properties:

org.jobrunr.background-job-server.enabled = waar org.jobrunr.dashboard.enabled = waar

De eerste eigenschap vertelt JobRunr dat we een instantie van een BackgroundJobServer die verantwoordelijk is voor het verwerken van jobs. De tweede eigenschap vertelt JobRunr om het ingebedde dashboard te starten.

Standaard is het jobrunr-spring-boot-starter zal proberen je bestaande te gebruiken Databron in het geval van een relationele database om alle werkgerelateerde informatie op te slaan.

Omdat we echter een gegevensopslag in het geheugen gebruiken, moeten we een Opslagleverancier Boon:

@Bean openbare StorageProvider storageProvider (JobMapper jobMapper) {InMemoryStorageProvider storageProvider = nieuwe InMemoryStorageProvider (); storageProvider.setJobMapper (jobMapper); retourneer storageProvider; }

5. Gebruik

Laten we nu eens kijken hoe we met JobRunr achtergrondtaken in Spring kunnen maken en plannen.

5.1. Injecteer afhankelijkheden

Als we banen willen creëren, moeten we de JobScheduler en onze bestaande Spring-service met de methode waarvoor we banen willen creëren, in dit geval de VoorbeeldJobService:

@Inject privé JobScheduler jobScheduler; @Inject privé SampleJobService sampleJobService;

De JobScheduler class van JobRunr stelt ons in staat om nieuwe achtergrondtaken in de wachtrij te plaatsen of in te plannen.

De VoorbeeldJobService kan een van onze bestaande Spring-services zijn die een methode bevatten die te lang kan duren om te verwerken in een webverzoek. Het kan ook een methode zijn die een aantal andere externe services aanroept waaraan we veerkracht willen toevoegen, aangezien JobRunr de methode opnieuw zal proberen als er een uitzondering optreedt.

5.2. Brand-en-vergeet-banen creëren

Nu we onze afhankelijkheden hebben, kunnen we fire-and-forget-taken maken met behulp van de in de wachtrij plaatsen methode:

jobScheduler.enqueue (() -> sampleJobService.executeSampleJob ());

Jobs kunnen parameters hebben, net als elke andere lambda:

jobScheduler.enqueue (() -> sampleJobService.executeSampleJob ("een string"));

Deze regel zorgt ervoor dat de lambda - inclusief type, methode en argumenten - wordt geserialiseerd als JSON naar permanente opslag (een RDBMS zoals Oracle, Postgres, MySql en MariaDB of een NoSQL-database).

Een speciale werkgroep met threads die in alle verschillende BackgroundJobServers zal deze achtergrondtaken in de wachtrij zo snel mogelijk uitvoeren, op een first-in-first-out manier. JobRunr garandeert de uitvoering van uw job door één enkele medewerker door middel van optimistische vergrendeling.

5.3. Taken in de toekomst plannen

We kunnen ook taken in de toekomst plannen met behulp van de schema methode:

jobScheduler.schedule (() -> sampleJobService.executeSampleJob (), LocalDateTime.now (). plusHours (5));

5.4. Taken regelmatig plannen

Als we terugkerende banen willen hebben, moeten we de schemaRecurrently methode:

jobScheduler.scheduleRecurrently (() -> sampleJobService.executeSampleJob (), Cron.hourly ());

5.5. Aantekeningen maken met de @Job Annotatie

Om alle aspecten van een baan te beheersen, kunnen we onze servicemethode annoteren met de @Job annotatie. Dit maakt het mogelijk om de weergavenaam in het dashboard in te stellen en het aantal nieuwe pogingen te configureren voor het geval een taak mislukt.

@Job (name = "De voorbeeldtaak met variabele% 0", nieuwe pogingen = 2) public void executeSampleJob (String-variabele) {...}

We kunnen zelfs variabelen gebruiken die aan onze job worden doorgegeven in de weergavenaam door middel van de String.format () syntaxis.

Als we zeer specifieke gebruikssituaties hebben waarin we een specifieke taak alleen voor een bepaalde uitzondering opnieuw willen proberen, kunnen we onze eigen taak schrijven ElectStateFilter waar we toegang hebben tot de Job en volledige controle over hoe verder te gaan.

6. Dashboard

JobRunr wordt geleverd met een ingebouwd dashboard waarmee we onze taken kunnen volgen. We kunnen het vinden op // localhost: 8000 en alle taken inspecteren, inclusief alle terugkerende taken en een schatting van hoe lang het duurt voordat alle in de wachtrij geplaatste taken zijn verwerkt:

Er kunnen slechte dingen gebeuren, bijvoorbeeld een SSL-certificaat is verlopen of een schijf is vol. JobRunr zal de achtergrondtaak standaard opnieuw plannen met een exponentieel uitstelbeleid. Als de achtergrondtaak tien keer blijft mislukken, gaat deze pas naar de Mislukt staat. U kunt dan besluiten om de mislukte taak opnieuw in de wachtrij te plaatsen wanneer de hoofdoorzaak is opgelost.

Dit alles is zichtbaar in het dashboard, inclusief elke nieuwe poging met het exacte foutbericht en de volledige stacktrace van waarom een ​​taak is mislukt:

7. Conclusie

In dit artikel hebben we onze eerste basisplanner gebouwd met JobRunr met de jobrunr-spring-boot-starter. De belangrijkste afweging van deze tutorial is dat we een taak konden maken met slechts één regel code en zonder enige XML-gebaseerde configuratie of de noodzaak om een ​​interface te implementeren.

De volledige broncode voor het voorbeeld is beschikbaar op GitHub.