Pola Pencari Layanan dan Implementasi Java

1. Perkenalan

Dalam tutorial ini, kita akan belajar tentang pola desain Service Locator di Java .

Kami akan menjelaskan konsepnya, menerapkan contoh dan menyoroti pro dan kontra penggunaannya.

2. Memahami Pola

Tujuan dari pola Service Locator adalah untuk mengembalikan contoh layanan sesuai permintaan. Ini berguna untuk memisahkan konsumen layanan dari kelas beton.

Implementasi akan terdiri dari komponen-komponen berikut:

  • Klien - objek klien adalah konsumen layanan. Ini bertanggung jawab untuk meminta permintaan dari pencari layanan
  • Lokasi Layanan - adalah titik masuk komunikasi untuk mengembalikan layanan dari cache
  • Cache - objek untuk menyimpan referensi layanan untuk digunakan kembali nanti
  • Penginisialisasi - membuat dan mendaftarkan referensi ke layanan di cache
  • Layanan - komponen Layanan mewakili layanan asli atau implementasinya

Objek layanan asli dicari oleh pencari lokasi dan dikembalikan sesuai permintaan.

3. Implementasi

Sekarang, mari kita praktikkan dan lihat konsepnya melalui sebuah contoh.

Pertama, kita akan membuat antarmuka MessagingService untuk mengirim pesan dengan berbagai cara:

public interface MessagingService { String getMessageBody(); String getServiceName(); }

Selanjutnya, kami akan menentukan dua implementasi antarmuka di atas, yang mengirim pesan melalui email dan SMS:

public class EmailService implements MessagingService { public String getMessageBody() { return "email message"; } public String getServiceName() { return "EmailService"; } }

The SMSService definisi kelas mirip dengan EmailService kelas.

Setelah mendefinisikan dua layanan, kita harus mendefinisikan logika untuk menginisialisasinya:

public class InitialContext { public Object lookup(String serviceName) { if (serviceName.equalsIgnoreCase("EmailService")) { return new EmailService(); } else if (serviceName.equalsIgnoreCase("SMSService")) { return new SMSService(); } return null; } }

Komponen terakhir yang kita butuhkan sebelum meletakkan objek pelacak layanan adalah cache.

Dalam contoh kami, ini adalah kelas sederhana dengan properti List :

public class Cache { private List services = new ArrayList(); public MessagingService getService(String serviceName) { // retrieve from the list } public void addService(MessagingService newService) { // add to the list } } 

Terakhir, kita dapat mengimplementasikan kelas pencari lokasi kita:

public class ServiceLocator { private static Cache cache = new Cache(); public static MessagingService getService(String serviceName) { MessagingService service = cache.getService(serviceName); if (service != null) { return service; } InitialContext context = new InitialContext(); MessagingService service1 = (MessagingService) context .lookup(serviceName); cache.addService(service1); return service1; } }

Logikanya di sini cukup sederhana.

Kelas memegang sebuah instance dari Cache. Kemudian, dalam metode getService () , pertama-tama akan memeriksa cache untuk sebuah instance layanan.

Kemudian, jika nilainya null, itu akan memanggil logika inisialisasi dan menambahkan objek baru ke cache.

4. Pengujian

Mari kita lihat bagaimana kita bisa mendapatkan contoh sekarang:

MessagingService service = ServiceLocator.getService("EmailService"); String email = service.getMessageBody(); MessagingService smsService = ServiceLocator.getService("SMSService"); String sms = smsService.getMessageBody(); MessagingService emailService = ServiceLocator.getService("EmailService"); String newEmail = emailService.getMessageBody();

Pertama kali kita mendapatkan EmailService dari ServiceLocator contoh baru dibuat dan kembali . Kemudian, setelah memanggilnya di lain waktu, EmailService akan dikembalikan dari cache.

5. Lokasi Layanan vs Injeksi Ketergantungan

Sekilas, pola Lokasi Layanan mungkin terlihat mirip dengan pola terkenal lainnya - yaitu, Injeksi Ketergantungan.

Pertama, penting untuk diperhatikan bahwa baik Dependency Injection dan pola Service Locator adalah implementasi dari konsep Inversi Kontrol .

Sebelum melangkah lebih jauh, pelajari lebih lanjut tentang Injeksi Ketergantungan di artikel ini.

Perbedaan utamanya di sini adalah bahwa objek klien masih membuat dependensinya . Ini hanya menggunakan locator untuk itu, artinya membutuhkan referensi ke objek locator.

Sebagai perbandingan, saat menggunakan injeksi dependensi, kelas diberi dependensi. Injector dipanggil hanya sekali saat startup untuk memasukkan dependensi ke dalam kelas.

Terakhir, mari pertimbangkan beberapa alasan untuk menghindari penggunaan pola Service Locator.

Salah satu argumen yang menentangnya adalah bahwa pengujian unit menjadi sulit. Dengan injeksi ketergantungan, kita bisa meneruskan objek tiruan dari kelas dependen ke instance yang diuji. Di sisi lain, ini adalah hambatan dengan pola Lokasi Layanan.

Masalah lainnya adalah lebih sulit menggunakan API berdasarkan pola ini. Alasannya adalah karena dependensi disembunyikan di dalam kelas dan hanya diverifikasi pada waktu proses.

Terlepas dari semua ini, pola Lokasi Layanan mudah dikodekan dan dipahami, dan dapat menjadi pilihan yang bagus untuk aplikasi kecil.

6. Kesimpulan

Panduan ini menunjukkan bagaimana dan mengapa menggunakan pola desain Service Locator. Ini membahas perbedaan utama antara pola desain Service Locator dan konsep Injeksi Ketergantungan.

Secara umum, terserah pengembang untuk memilih cara mendesain kelas dalam aplikasi.

Pola Service Locator adalah pola langsung untuk memisahkan kode. Namun, dalam kasus menggunakan kelas dalam beberapa aplikasi, injeksi ketergantungan adalah pilihan yang tepat.

Seperti biasa, kode lengkap tersedia di proyek Github.