23 Pola Desain Bab 19: Model Rantai Tanggung Jawab Java
Definisi: Memungkinkan banyak objek memiliki kesempatan untuk memproses permintaan, sehingga menghindari hubungan kopling antara pengirim dan penerima permintaan. Hubungkan objek -objek ini ke dalam rantai dan lewati permintaan di sepanjang rantai sampai suatu objek memprosesnya.
Jenis: Pola perilaku
Diagram kelas:
Pertama -tama mari kita lihat sepotong kode:
tes public void (int i, permintaan permintaan) {if (i == 1) {handler1.response (permintaan); } lain jika (i == 2) {handler2.response (permintaan); } lain jika (i == 3) {handler3.response (permintaan); } lain jika (i == 4) {handler4.response (permintaan); } else {handler5.response (permintaan); }}Logika bisnis kode adalah sebagai berikut: Metode ini memiliki dua parameter: Integer I dan permintaan permintaan. Menurut nilai i, yang akan menangani permintaan, jika saya == 1, itu akan ditangani oleh Handler1, jika saya == 2, itu akan ditangani oleh Handler2, dan sebagainya.
Dalam pemrograman, metode pemrosesan bisnis semacam ini sangat umum. Semua kelas yang diminta proses termasuk jika ... lain ... pernyataan penilaian bersyarat yang terhubung ke dalam rantai tanggung jawab untuk memproses permintaan. Saya percaya semua orang sering menggunakannya. Keuntungan dari metode ini adalah bahwa ia sangat intuitif, sederhana dan jelas, dan relatif mudah dipelihara, tetapi metode ini juga memiliki beberapa sakit kepala:
Kode membengkak: Dalam aplikasi aktual, kondisi penilaian biasanya tidak begitu sederhana untuk menentukan apakah itu 1 atau 2. Ini mungkin memerlukan perhitungan yang kompleks, mungkin menanyakan database, dll. Ini akan memiliki banyak kode tambahan. Jika ada banyak kondisi penilaian, maka ini jika ... lain ... pernyataan pada dasarnya tidak mungkin dibaca.
Gelar kopling tinggi: Jika kita ingin terus menambahkan kelas yang diminta proses, kita harus terus menambahkan yang lain jika persyaratan penilaian; Selain itu, urutan kondisi ini juga ditulis kepada orang mati. Jika kami ingin mengubah pesanan, kami hanya dapat memodifikasi pernyataan kondisi ini.
Karena kami telah memahami kekurangannya, kami perlu menemukan cara untuk menyelesaikannya. Logika bisnis skenario ini sangat sederhana: jika kondisi 1 terpenuhi, itu akan diproses oleh Handler1, dan jika tidak terpenuhi, itu akan diturunkan; Jika kondisi 2 dipenuhi, itu akan diproses oleh Handler2, dan jika tidak terpenuhi, itu akan diturunkan, dan seterusnya sampai akhir kondisi. Faktanya, metode perbaikan juga sangat sederhana, yaitu menempatkan bagian dari kondisi penilaian ke dalam kelas pemrosesan. Ini adalah prinsip model koneksi tanggung jawab.
Struktur model rantai tanggung jawab
Diagram kelas dari pola rantai tanggung jawab sangat sederhana, terdiri dari kelas yang diproses secara abstrak dan serangkaian kelas implementasinya:
Kelas pemrosesan abstrak: Kelas pemrosesan abstrak terutama mencakup variabel anggota yang menunjuk ke kelas pemrosesan berikutnya dan wasit metode yang menangani permintaan. Gagasan utama dari metode HandRequest adalah bahwa jika kondisi pemrosesan dipenuhi, kelas pemrosesan ini akan diproses, jika tidak maka akan diproses oleh Nexthandler.
Kelas Pemrosesan Khusus: Kelas pemrosesan spesifik terutama mengimplementasikan logika pemrosesan spesifik dan kondisi yang berlaku untuk pemrosesan.
Setelah memahami gagasan umum model rantai tanggung jawab, akan lebih mudah untuk dipahami ketika melihat kode:
level kelas {private int level = 0; level publik (level int) {this.level = level; }; public boolean di atas (level level) {if (this.level> = level.level) {return true; } return false; }} permintaan kelas {level level; permintaan publik (level level) {this.level = level; } level publik getLevel () {level kembali; }} Class Response {} abstrak class handler {private handler nexthandler; handleRequest respon akhir publik (permintaan permintaan) {respons response = null; if (this.getHandlelevel (). Di atas (request.getlevel ())) {response = this.response (request); } else {if (this.nexthandler! = null) {this.nexthandler.handleRequest (request); } else {System.out.println ("----------"); }} return response; } public void setNexThandler (pawang pawang) {this.nexthandler = handler; } level abstrak yang dilindungi getHandlerlevel (); respons abstrak publik (permintaan permintaan); } class concreteHandler1 Extends Handler {level protected getHandlevel () {return new level (1); } Respons Tanggapan Publik (Permintaan Permintaan) { System.out.println ("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ConcreteHandler2 Extends Handler {level yang dilindungi getHandlevel () {return new level (3); System.out.println ("------ Permintaan diproses oleh prosesor 3 -----"); handler1.setNexthandler (handler2);Dalam kode, kelas level mensimulasikan kondisi penentuan; Permintaan dan respons sesuai dengan permintaan dan respons masing -masing; Penangan kelas abstrak terutama menilai kondisi, dan tingkat pemrosesan disimulasikan di sini. Hanya tingkat pemrosesan kelas pemrosesan yang lebih tinggi dari tingkat permintaan yang dapat diproses, jika tidak maka akan diserahkan ke prosesor berikutnya untuk diproses.
Atur hubungan eksekusi depan dan belakang rantai di kelas klien, dan serahkan permintaan ke kelas pemrosesan pertama selama eksekusi. Ini adalah pola rantai tanggung jawab. Fungsi yang diselesaikan sama dengan pernyataan if ... lain ... dalam artikel sebelumnya.
Pro dan kontra dari model rantai tanggung jawab
Dibandingkan dengan jika ... lain ..., pola rantai tanggung jawab memiliki kemampuan kopling yang lebih rendah karena mendistribusikan penilaian bersyarat ke dalam berbagai kelas pemrosesan, dan urutan pemrosesan prioritas dari kelas pemrosesan ini dapat ditetapkan sesuka hati. Model rantai tanggung jawab juga memiliki kelemahannya, yang sama dengan pernyataan IF ... lain ... yaitu, sebelum menemukan kelas pemrosesan yang benar, semua kondisi penilaian harus dieksekusi. Ketika rantai tanggung jawab relatif panjang, masalah kinerja lebih serius.
Skenario yang berlaku untuk model rantai tanggung jawab
Sama seperti contoh awal, jika Anda merasa kewalahan saat menggunakan pernyataan if ... lain ... untuk mengatur rantai tanggung jawab dan kodenya terlihat buruk, Anda dapat menggunakan mode rantai tanggung jawab untuk membalasnya.
Meringkaskan
Model rantai tanggung jawab sebenarnya adalah versi fleksibel jika ... lain ... pernyataan. Ini menempatkan kondisi penilaian ini ke dalam setiap kelas pemrosesan. Keuntungan dari ini adalah lebih fleksibel, tetapi juga membawa risiko. Misalnya, ketika menyiapkan hubungan antara kelas pemrosesan sebelum dan sesudah kelas pemrosesan, Anda harus sangat berhati -hati untuk menilai hubungan antara logika bersyarat sebelum dan sesudah kelas pemrosesan, dan berhati -hatilah untuk tidak memiliki referensi melingkar dalam rantai.
Di atas adalah semua konten artikel ini. Saya berharap ini akan membantu untuk pembelajaran semua orang dan saya harap semua orang akan lebih mendukung wulin.com.