Latar Belakang Pekerjaan di Spring dengan JobRunr

Pengaturcaraan

1. Gambaran keseluruhan

Dalam tutorial ini, kita akan melihat penjadualan dan pemrosesan pekerjaan latar belakang yang diedarkan di Java menggunakan JobRunr dan mengintegrasikannya dengan Spring.

2. Mengenai JobRunr

JobRunr adalah perpustakaan yang dapat kita masukkan ke dalam aplikasi kita dan yang memungkinkan kita menjadwalkan pekerjaan latar belakang menggunakan Java 8 lambda. Kami boleh menggunakan kaedah sedia ada perkhidmatan Spring kami untuk membuat pekerjaan tanpa perlu melaksanakan antara muka. Pekerjaan boleh menjadi proses jangka pendek atau lama, dan secara automatik akan dimuat ke utas latar belakang sehingga permintaan web saat ini tidak disekat.

Untuk menjalankan tugasnya, JobRunr menganalisis lambda Java 8. Ia menyusunnya sebagai JSON, dan menyimpannya ke dalam pangkalan data hubungan atau kedai data NoSQL.

3. Ciri JobRunr

Sekiranya kita melihat bahawa kita menghasilkan terlalu banyak pekerjaan latar belakang dan pelayan kita tidak dapat mengatasi beban, kita dapat dengan mudah skala secara mendatar dengan hanya menambahkan contoh aplikasi tambahan kita. JobRunr akan berkongsi beban secara automatik dan mengedarkan semua pekerjaan melalui pelbagai jenis aplikasi kami.

Ini juga mengandungi ciri percubaan automatik dengan dasar penggantian eksponensial untuk pekerjaan yang gagal. Terdapat juga papan pemuka terpasang yang membolehkan kami memantau semua pekerjaan. JobRunr menjaga diri - pekerjaan yang berjaya akan dihapus secara automatik setelah jangka waktu yang dapat dikonfigurasi sehingga tidak perlu melakukan pembersihan penyimpanan manual.

4. Persediaan

Demi kesederhanaan, kami akan menggunakan stor data dalam memori untuk menyimpan semua maklumat berkaitan pekerjaan.

4.1. Konfigurasi Maven

Mari lompat terus ke kod Java. Tetapi sebelum itu, kita perlu menyatakan pergantungan Maven berikut dalam fail pom.xml kami :

 org.jobrunr jobrunr-spring-boot-starter 1.1.0

4.2. Integrasi Musim Bunga

Sebelum kita langsung melangkah bagaimana membuat pekerjaan latar belakang, kita perlu menginisialisasi JobRunr. Oleh kerana kami menggunakan pergantungan jobrunr-spring-boot-starter , ini mudah. Kami hanya perlu menambahkan beberapa sifat pada aplikasi. Sifat :

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

Properti pertama memberitahu JobRunr bahawa kami ingin memulakan contoh BackgroundJobServer yang bertanggungjawab untuk memproses pekerjaan. Properti kedua memberitahu JobRunr untuk memulakan papan pemuka tertanam.

Secara lalai, jobrunr-spring-boot-starter akan cuba menggunakan DataSource yang ada sekiranya terdapat pangkalan data hubungan untuk menyimpan semua maklumat berkaitan pekerjaan.

Namun, kerana kami akan menggunakan stor data dalam memori, kami perlu menyediakan kacang StorageProvider :

@Bean public StorageProvider storageProvider(JobMapper jobMapper) { InMemoryStorageProvider storageProvider = new InMemoryStorageProvider(); storageProvider.setJobMapper(jobMapper); return storageProvider; }

5. Penggunaan

Sekarang, mari kita ketahui bagaimana membuat dan menjadualkan pekerjaan latar belakang pada musim bunga menggunakan JobRunr.

5.1. Ketergantungan Suntikan

Apabila kita ingin membuat pekerjaan, kita perlu menyuntik JobScheduler dan perkhidmatan Spring yang ada yang mengandungi kaedah yang ingin kita buat pekerjaan, dalam hal ini, SampleJobService :

@Inject private JobScheduler jobScheduler; @Inject private SampleJobService sampleJobService;

The JobScheduler kelas dari JobRunr membolehkan kita enqueue atau jadual kerja latar belakang baru.

The SampleJobService boleh menjadi mana-mana perkhidmatan Spring kami yang sedia ada yang mengandungi kaedah yang mungkin mengambil masa yang lama untuk mengendalikan dalam permintaan web. Ini juga boleh menjadi kaedah yang memanggil beberapa perkhidmatan luaran lain di mana kita ingin menambahkan ketahanan kerana JobRunr akan mencuba semula kaedah tersebut jika berlaku pengecualian.

5.2. Membuat Pekerjaan Fire-and-Forget

Sekarang kerana kita mempunyai kebergantungan kita, kita dapat membuat pekerjaan-dan-lupakan pekerjaan menggunakan kaedah enqueue :

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

Pekerjaan boleh mempunyai parameter, seperti lambda lain:

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

Garis ini memastikan bahawa lambda - termasuk jenis, kaedah, dan argumen - bersiri sebagai JSON ke penyimpanan berterusan (RDBMS seperti Oracle, Postgres, MySql, dan MariaDB atau pangkalan data NoSQL).

A dedicated worker pool of threads running in all the different BackgroundJobServers will then execute these queued background jobs as soon as possible, in a first-in-first-out manner. JobRunr guarantees the execution of your job by a single worker by means of optimistic locking.

5.3. Scheduling Jobs in the Future

We can also schedule jobs in the future using the schedule method:

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

5.4. Scheduling Jobs Recurrently

If we want to have recurrent jobs, we need to use the scheduleRecurrently method:

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

5.5. Annotating with the @Job Annotation

To control all aspects of a job, we can annotate our service method with the @Job annotation. This allows setting the display name in the dashboard and configuring the number of retries in case a job fails.

@Job(name = "The sample job with variable %0", retries = 2) public void executeSampleJob(String variable) { ... }

We can even use variables that are passed to our job in the display name by means of the String.format() syntax.

If we have very specific use cases where we would want to retry a specific job only on a certain exception, we can write our own ElectStateFilter where we have access to the Job and full control on how to proceed.

6. Dashboard

JobRunr comes with a built-in dashboard that allows us to monitor our jobs. We can find it at //localhost:8000 and inspect all the jobs, including all recurring jobs and an estimation of how long it will take until all the enqueued jobs are processed:

Bad things can happen, for example, an SSL certificate expired, or a disk is full. JobRunr, by default, will reschedule the background job with an exponential back-off policy. If the background job continues to fail ten times, only then will it go to the Failed state. You can then decide to re-queue the failed job when the root cause has been solved.

All of this is visible in the dashboard, including each retry with the exact error message and the complete stack trace of why a job failed:

7. Conclusion

Dalam artikel ini, kami membuat penjadual asas pertama kami menggunakan JobRunr dengan starter jobrunr-spring-boot-boot . Hasil utama dari tutorial ini adalah bahawa kita dapat membuat pekerjaan dengan hanya satu baris kod dan tanpa konfigurasi berasaskan XML atau keperluan untuk melaksanakan antara muka.

Kod sumber lengkap untuk contoh boleh didapati di GitHub.