Java batchverwerking gemakkelijk gemaakt…

Heden ten dage is alle hype rond de gedistribueerde real-time verwerkingsframeworks, zoals Apache Hadoop, Apache Kafka of Apache Spark. Deze frameworks zijn beproefd en noodzakelijk voor bedrijven als Facebook, Netflix of LinkedIn, maar ze zijn niet echt ontwikkelaarvriendelijk – de leercurve is hoog en het beheer van de infrastructuur waarop ze draaien is geen triviale taak.

En laten we eerlijk zijn – we werken niet allemaal voor een bedrijf als de bovengenoemde, dat elke dag terabytes aan gegevens verwerkt.

Vaak hoeven we alleen maar wat complexe bedrijfsprocessen op te lossen met een bescheiden hoeveelheid gegevens. Zelf moet ik mijn eerste klant nog tegenkomen die meer dan een terabyte aan relevante gegevens heeft binnen hetzelfde bedrijfsproces.

Wat ik wel heb moeten doen – al een paar keer – is, een paar echt moeilijke berekeningen maken op enkele gigabytes aan gegevens. En voor dit soort berekeningen heb ik nooit het juiste Java framework gevonden om me te helpen de klus betrouwbaar en in een nette code te klaren.

Ja, er is Spring Batch (zeker niet mijn favoriet) of Quartz, maar deze frameworks laten je allemaal aangepaste interfaces implementeren en ze voegen een hoop overhead toe terwijl ik alleen maar wat langlopende taken op de achtergrond wil uitvoeren.

Zo, nu JobRunr.io!

JobRunr stelt je in staat om achtergrond taken te maken met alleen maar Java 8 lambda’s! Een voorbeeld:

BackgroundJob.enqueue(() -> myService.doWork());

Deze ene regel code zorgt ervoor dat de lambda – inclusief type, methode en argumenten – wordt geserialiseerd naar persistente opslag (een RDBMS zoals Oracle, Postgres, MySql en MariaDB of een NoSQL database die binnenkort zal worden ondersteund). Een speciale worker pool van threads zal dan deze achtergrond taken in de wachtrij zo snel mogelijk uitvoeren.

Moet je morgen een achtergrond taak plannen? Volgende week? Volgende maand? JobRunr heeft u gedekt:

BackgroundJob.schedule(() -> System.out.println("Reliable!"), now().plusHours(5));

Even terugkerende taken zijn nog nooit zo eenvoudig geweest – JobRunr maakt het mogelijk om elk soort terugkerende taak uit te voeren met behulp van CRON expressions.

BackgroundJob.scheduleRecurringly(() -> service.doWork(), Cron.daily());

De voordelen:

• Gemakkelijk: er is geen nieuw framework te leren – gewoon gebruik maken van uw bestaande Java 8 vaardigheden.
• Eenvoudig: omdat u geen speciale interfaces hoeft te implementeren of abstracte klassen hoeft uit te breiden, is uw code bijna agnostisch ten opzichte van JobRunr. U kunt uw bestaande services zonder enige wijziging hergebruiken.
• Fouttolerant: Slechte dingen gebeuren – een service die u gebruikt kan down zijn, schijven kunnen vol raken, SSL-certificaten verlopen, … . Als JobRunr een uitzondering tegenkomt, zal het standaard de achtergrondtaak opnieuw plannen met een exponentieel back-off beleid. Als de achtergrondtaak tien keer blijft falen, zal deze naar de Failed status gaan. U kunt dan besluiten om de mislukte job opnieuw in te plannen wanneer de hoofdoorzaak is opgelost.
• Transparant: JobRunr bevat een ingebouwd dashboard waarmee u uw jobs kunt monitoren. Het geeft je een overzicht van al je achtergrondjobs en je kunt de status van elke job in detail bekijken.
• Gedistribueerd: omdat de lambda of achtergrondjob wordt geserialiseerd naar persistente opslag, kan het achtergrondproces over JVM-grenzen reizen en dit maakt gedistribueerde verwerking mogelijk. Moet u 1.000.000 achtergrond taken verwerken? Voeg tijdelijk extra achtergrond jobservers toe – laten we zeggen 10 – die deze jobs kunnen verwerken en uw totale verwerkingstijd zal worden gedeeld door bijna 10.
• Zelf-onderhoudbaar: u hoeft geen handmatige storage clean-up uit te voeren – JobRunr houdt het zo schoon als mogelijk en verwijdert succesvol afgeronde jobs automatisch.