Corak Pencari Perkhidmatan dan Pelaksanaan Java

1. Pengenalan

Dalam tutorial ini, kita akan belajar mengenai corak reka bentuk Service Locator di Java .

Kami akan menerangkan konsepnya, menerapkan contoh dan mengetengahkan kebaikan dan keburukan penggunaannya.

2. Memahami Corak

Tujuan corak Service Locator adalah untuk mengembalikan keadaan perkhidmatan berdasarkan permintaan. Ini berguna untuk memutuskan perkhidmatan pengguna dari kelas konkrit.

Pelaksanaan akan terdiri daripada komponen berikut:

  • Pelanggan - objek pelanggan adalah pengguna perkhidmatan. Ia bertanggungjawab untuk meminta permintaan dari pencari perkhidmatan
  • Service Locator - adalah titik masuk komunikasi untuk mengembalikan perkhidmatan dari cache
  • Cache - objek untuk menyimpan rujukan perkhidmatan untuk menggunakannya semula kemudian
  • Initializer - membuat dan mendaftarkan rujukan ke perkhidmatan dalam cache
  • Perkhidmatan - komponen Perkhidmatan mewakili perkhidmatan asal atau pelaksanaannya

Objek perkhidmatan asal dicari oleh pencari dan dikembalikan mengikut permintaan.

3. Pelaksanaan

Sekarang, mari kita praktikkan dan lihat konsep melalui contoh.

Pertama, kami akan membuat antara muka MessagingService untuk menghantar mesej dengan cara yang berbeza:

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

Seterusnya, kami akan menentukan dua pelaksanaan antara muka di atas, yang menghantar mesej melalui e-mel dan SMS:

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

The SMSService definisi kelas adalah sama dengan EmailService kelas.

Setelah menentukan dua perkhidmatan tersebut, kita harus menentukan logik untuk menginisialisasi mereka:

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 perlukan sebelum meletakkan objek pencari perkhidmatan bersama adalah cache.

Dalam contoh kami, ini adalah kelas sederhana dengan harta 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 } } 

Akhirnya, kami dapat melaksanakan kelas pencari perkhidmatan kami:

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; } }

Logiknya di sini agak mudah.

Kelas memegang contoh Cache. Kemudian, dalam kaedah getService () , ia akan memeriksa cache terlebih dahulu untuk contoh perkhidmatan.

Kemudian, jika tidak ada, ia akan memanggil logik permulaan dan menambahkan objek baru ke cache.

4. Ujian

Mari lihat bagaimana kita dapat memperoleh 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();

Kali pertama kami mendapat EmailService dari ServiceLocator, satu contoh baru dibuat dan dikembalikan . Kemudian, setelah memanggilnya pada masa akan datang, EmailService akan dikembalikan dari cache.

5. Service Locator vs Dependency Injection

Pada pandangan pertama, corak Service Locator mungkin kelihatan serupa dengan corak terkenal lain - iaitu Dependency Injection.

Pertama, penting untuk diperhatikan bahawa kedua Dependency Injection dan corak Service Locator adalah pelaksanaan konsep Inversion of Control .

Sebelum melangkah lebih jauh, ketahui lebih lanjut mengenai Dependency Injection dalam penulisan ini.

Perbezaan utama di sini adalah bahawa objek pelanggan masih mewujudkan kebergantungannya . Ia hanya menggunakan pencari untuk itu, yang bermaksud ia memerlukan rujukan ke objek pencari.

Sebagai perbandingan, semasa menggunakan suntikan kebergantungan, kelas diberi kebergantungan. Penyuntik dipanggil sekali sahaja pada permulaan untuk memasukkan kebergantungan ke dalam kelas.

Akhirnya, mari kita pertimbangkan beberapa sebab untuk mengelakkan menggunakan corak Service Locator.

Satu hujah menentangnya adalah bahawa ia menjadikan pengujian unit sukar. Dengan suntikan kebergantungan, kita dapat menyampaikan objek tiruan kelas bergantung kepada contoh yang diuji. Sebaliknya, ini adalah hambatan dengan corak Service Locator.

Masalah lain adalah lebih sukar untuk menggunakan API berdasarkan corak ini. Sebabnya adalah bahawa kebergantungan tersembunyi di dalam kelas dan ia hanya disahkan pada waktu runtime.

Walaupun semua ini, corak Service Locator mudah dikod dan difahami, dan boleh menjadi pilihan tepat untuk aplikasi kecil.

6. Kesimpulannya

Panduan ini menunjukkan bagaimana dan mengapa menggunakan corak reka bentuk Service Locator. Ia membincangkan perbezaan utama antara corak reka bentuk Service Locator dan konsep Dependency Injection.

Secara amnya, terserah kepada pemaju untuk memilih cara merancang kelas dalam aplikasi.

Corak Service Locator adalah corak mudah untuk mencabut kodnya. Namun, sekiranya menggunakan kelas dalam beberapa aplikasi, suntikan kebergantungan adalah pilihan yang tepat.

Seperti biasa, kod lengkap terdapat dalam projek Github.