1. Mode agen
Model proxy disebut proxy atau pengganti dalam bahasa Inggris, dan keduanya dapat diterjemahkan sebagai "agen" dalam bahasa Cina. Proxy yang disebut berarti bahwa satu orang atau lembaga mengambil tindakan atas nama orang lain atau lembaga lain. Dalam beberapa kasus, klien tidak ingin atau tidak dapat secara langsung merujuk ke suatu objek, dan objek proxy dapat bertindak sebagai perantara antara klien dan objek target.
Jelaskan perbedaan antara berbagai agen dengan hanya mensimulasikan proses eksekusi transaksi
1.1 proxy statis
Kode sumber dibuat oleh programmer atau secara otomatis dihasilkan oleh alat tertentu dan kemudian dikompilasi. Sebelum program berjalan, file .class dari kelas proxy sudah ada.
antarmuka publik persondao {void saveperson ();} Public Class PerondaoImpl mengimplementasikan persondao {@Override public void saveperson () {System.out.println ("Save Person"); }} transaksi kelas publik {void beginTransaction () {System.out.println ("Mulai transaksi"); } void commit () {System.out.println ("Commit"); }}Selanjutnya, tulis kelas proxy statis --- Implementasikan antarmuka persondao
/*** kelas proxy statis* @author qjc*/kelas publik persondaoproxy mengimplementasikan persondao {persondao persondao; Transaksi transaksi; personoproxy publik (persondao persondao, transaksi transaksi) {this.persondao = persondao; this.transaction = transaksi; } @Override public void saveperson () {this.transaction.begintransaction (); this.persondao.saveperson (); this.transaction.commit (); }}tes
/*** Tes proxy statis* @author qjc*/kelas publik testpersonproxy {@test public void testSave () {persondao persondao = new persondaoImpl (); Transaksi transaksi = transaksi baru (); Proxy persondaoproxy = persondaoproxy baru (persondao, transaksi); proxy.saveperson (); }}Meringkaskan:
1. Mode proxy statis tidak menggunakan kembali transaksi
2. Misalkan ada 100 kelas dan 100 proxy. Berapa banyak metode yang ada di antarmuka, berapa banyak metode yang harus diimplementasikan di lapisan proxy, dan berapa banyak transaksi yang harus dibuka dan diserahkan sebanyak mungkin metode.
3. Jika suatu proksi mengimplementasikan beberapa antarmuka, jika salah satu antarmuka berubah (metode ditambahkan), maka proxy juga perlu berubah sesuai.
1.2 Proxy Dinamis JDK
Dynamic Proxy Class: Dibuat secara dinamis menggunakan mekanisme refleksi saat program berjalan.
Proksi dinamis JDK harus memenuhi empat kondisi: 1. Antarmuka target 2. Target kelas 3. Interceptor 4. Kelas proxy
Menggunakan antarmuka persondao, kelas persondaoImpl dan kelas transaksi dalam contoh sebelumnya
Tulis pencegat
impor java.lang.reflect.invocationHandler; impor java.lang.reflect.method;/** * interceptor * 1. Impor kelas target di * 2. Impor hal -hal di * 3. Invoke Completion: Mulai Transaksi, Panggil Metode Objek Target, dan Komit Transaksi * * @Author QJC */Public Classion Intercept Objek Target, dan Transaksi Invocies * @Author QJC */Public Class Intercept Objek Target, dan Transaksi Invoced {@Author QJC */Public Class Menandat // Target Transaksi Transaksi Pribadi Target; Interceptor publik (target objek, transaksi transaksi) {this.target = target; this.transaction = transaksi; } / *** @param Proxy Instance dari kelas proxy objek target* Metode @param yang sesuai dengan contoh metode yang memanggil metode antarmuka pada instance proxy* @param args array objek yang ditularkan ke dalam nilai parameter metode pada Metode Proxy, Metode Public, NEBOKS PUBLOK, NADE PUBLOK, NODE OBAT PUBLOK, NO NULT NULTROBLE OBACRE, NOBAGE PROXY, NODE OBSEK PROXY, NOBEKS PROXY, NOBEKS PROXY, NOBEK PUBLOK, NODE OBSEK, NOBE OBSEK PROXY, NODE OBSEK, NOBE OBSEK PROXY OBBOKS, NOBE OBSEK, NODE OBSIT, {String methodName = method.getName (); if ("Saveperson" .Equals (MethodName) || "Deleteperson" .Equals (MethodName) || "UpdatePerson" .Equals (MethodName)) {this.transaction.begintransaction (); // Aktifkan Metode Transaksi.invoke (Target); // panggil metode target this.transaction.commit (); // kirim transaksi} else {Method.invoke (target); } return null; }}tes
/** * Test jdk dynamic proxy* @author qjc */public class TestJDKProxy { @Test public void testSave(){ /** * 1. Create a target object* 2. Create a transaction* 3. Create an interceptor* 4. Dynamically generate a proxy object*/ Object target = new PersonDaoImpl(); Transaksi transaksi = transaksi baru (); Interceptor Interceptor = New Interceptor (Target, Transaction); /*** Parameter 1: Setel class loader yang digunakan oleh kode, yang umumnya menggunakan class loader yang sama dengan kelas target* parameter 2: Setel antarmuka yang diimplementasikan oleh kelas proxy, dan gunakan antarmuka yang sama seperti kelas target* parameter 3: atur objek callback. Ketika metode objek proxy dipanggil, metode Invoke dari objek yang ditentukan akan disebut*/ persondao persondao = (persondao) proxy.newproxyinstance (target.getClass (). GetClassLoader (), target.getClass (). GetInterfaces (), interceptor); persondao.saveperson (); }}Ringkas :
1. Karena kelas proxy yang dihasilkan oleh JDKProxy mengimplementasikan antarmuka, semua metode di kelas target termasuk dalam kelas proxy.
2. Semua metode kelas proxy yang dihasilkan mencegat semua metode kelas target. Isi metode Invoke di Interceptor adalah komposisi dari setiap metode kelas proxy.
3. Antarmuka harus ada saat menggunakan JDKProxy.
4. Tiga parameter dalam metode Invoke dapat mengakses API dari metode yang dipanggil, parameter dari metode yang dipanggil, dan jenis pengembalian dari metode yang dipanggil dari kelas target.
kekurangan:
1. Di Interceptor, kecuali untuk memanggil metode target objek target, fungsi relatif tunggal. Dalam contoh ini, hanya transaksi yang dapat diproses.
2. Pernyataan Jawaban IF dari Metode Invoke di Interceptor tidak dapat diandalkan dalam lingkungan pengembangan nyata, karena begitu ada banyak pernyataan IF, itu perlu ditulis.
1.3 Proxy Dinamis CGlib
Gunakan kelas persondaoImpl dan kelas transaksi dalam contoh sebelumnya (tidak ada antarmuka)
Tulis kelas pencegat
import net.sf.cglib.proxy.Enhancer;import net.sf.cglib.proxy.MethodInterceptor;import net.sf.cglib.proxy.MethodProxy;/** * CGLIB proxy interceptor* @author qjc */public class Interceptor implements MethodInterceptor { private Object target; // Kelas target proxy transaksi transaksi pribadi; Interceptor publik (target objek, transaksi transaksi) {this.target = target; this.transaction = transaksi; } / ** * Buat objek proxy dari objek target * * @return * / public objek createProxy () {// code Enhancement Enhancer Enhancer = new Enhancer (); // Kelas ini digunakan untuk menghasilkan penambah objek proxy.setCallback (ini); // Parameternya adalah penambah interceptor.setsuperclass (target.getClass ()); // Atur penambah pengembalian kelas induk. Create (); // Buat objek proxy}/ *** @param obj instance dari kelas proxy objek target* @param Metode metode metode yang memanggil metode kelas induk pada instance proxy* @param array objek yang disahkan ke dalam metode parameter Metode, Obyprow* Obyprows* Obyprow* Obyprow Objek* Obycepte* Obyprow Objek* Obycepte* Obyprow Obyprow* Obyprowse* Obycepte Publicpoxy Menggunakannya untuk memanggil metode dari Metode Kelas Induk* @RetUnto @RoTJ* @puxy* args, methodproxy methodproxy) melempar lempar {this.transaction.begintransaction (); method.invoke (target); this.transaction.commit (); kembali nol; }}tes
/*** Uji proxy dinamis CGLIB* Objek proksi yang dihasilkan melalui CGLIB, kelas proxy adalah subkelas dari kelas target* @author qjc*/kelas publik testcglibproxy {@test public void testSave () {objek target = new persondaoImpl (); Transaksi transaksi = transaksi baru (); Interceptor Interceptor = New Interceptor (Target, Transaction); PersondaoImpl persondaoImpl = (persondaoImpl) interceptor.createProxy (); persondaoimpl.saveperson (); }}Meringkaskan:
1. CGLIB adalah perpustakaan kelas generasi kode berkualitas tinggi yang kuat, berkinerja tinggi, dan berkualitas tinggi. Ini dapat memperluas kelas Java dan mengimplementasikan antarmuka Java selama runtime.
2. Gunakan CGLIB untuk menghasilkan kelas proxy sebagai subkelas dari kelas target.
3. Tidak diperlukan antarmuka untuk menghasilkan kelas proxy menggunakan CGLIB
4. Kelas proxy yang dihasilkan oleh CGLIB mengesampingkan metode kelas induk.
5. Konten metode intersep di interseptor adalah perbedaan antara metode metode CGLIB dan proxy dinamis JDK di kelas proxy:
JDK:
Kelas target dan kelas proxy mengimplementasikan antarmuka umum
Interceptor harus mengimplementasikan antarmuka InvocationHandler, dan konten dari Badan Metode Invoke di antarmuka ini adalah konten dari badan metode objek proxy.
CGLIB:
Kelas target adalah kelas induk dari kelas proxy
Interceptor harus mengimplementasikan antarmuka MethodInterceptor, dan metode intersep dalam antarmuka adalah badan metode kelas proxy, dan mekanisme peningkatan bytecode digunakan untuk membuat objek proxy.
2. Pemrograman berorientasi berorientasi
OOP (pemrograman berorientasi objek): enkapsulasi, pewarisan, polimorfisme, abstraksi
Enkapsulasi, manajemen kode dasar dan modular. Setiap kelas mungkin memiliki fungsinya sendiri. Jika terjadi kesalahan, cari seseorang untuk membahas masalah ini. Dari perspektif modifikasi, mungkin berisiko untuk memodifikasi kode secara langsung. Ini bukan solusi jangka panjang. Hal yang paling alami adalah berubah dari enkapsulasi jenis. Namun, bagaimana mengintegrasikan jenis baru dan sistem lama, sehingga perlu untuk membangun hubungan darah antar kelas. Maka ini adalah persyaratan warisan. Melalui warisan, Anda dapat menemukan bahwa kelas-kelas ini terkait dan ada hubungan ayah-anak di antara mereka. Kemudian, berdasarkan warisan, polimorfisme memiliki karakteristik yang menentukan. Oleh karena itu, umumnya diyakini bahwa fitur inti yang paling berorientasi pada objek sebenarnya adalah polimorfisme. Beberapa pertama semuanya meletakkan dasar. Polimorfisme adalah fitur intinya. Metode penulisan ulang dalam subclass mewakili ekstensi level ini, dan dapat diintegrasikan ke dalam sistem lama dan dapat bekerja secara normal. Ini adalah penggunaan kembali level ini, metode baru, sistem lama, ekstensi dan penggunaan kembali.
AOP (pemrograman berorientasi bagian):
Pemrograman Essential adalah teknologi yang secara dinamis menambahkan fungsi ke program tanpa memodifikasi kode sumber melalui proxy dinamis runtime yang sudah dikompilasi.
Perbedaan antara OOP dan AOP:
OOP: Entrak enkapsulasi dilakukan pada entitas dan sifat serta perilaku proses pemrosesan bisnis untuk mendapatkan pembagian unit logis yang lebih jelas.
AOP: Mengekstrak logika silang dalam proses bisnis. Ini menghadapi langkah atau tahap tertentu dalam proses untuk mendapatkan efek isolasi kopling rendah antara bagian -bagian dari proses logika. Dua ide desain ini memiliki perbedaan penting dalam tujuan. AOP telah mencapai penggunaan kembali blok kode.
Mekanisme Proxy AOP Musim Semi:
1. Jika objek target mengimplementasikan beberapa antarmuka, Spring menggunakan java.lang.reflect.proxy kelas proxy JDK.
Keuntungan: Karena ada antarmuka, sistem lebih longgar digabungkan
Kekurangan: Buat antarmuka untuk setiap kelas target
2. Jika objek target tidak mengimplementasikan antarmuka apa pun, Spring menggunakan pustaka CGLIB untuk menghasilkan subclass dari objek target.
Keuntungan: Karena kelas proxy dan kelas target diwarisi, tidak perlu antarmuka ada.
Kerugian: Karena tidak ada antarmuka yang digunakan, kopling sistem tidak sebagus proxy dinamis menggunakan JDK.
Menggunakan antarmuka persondao, kelas persondaoImpl, dan kelas transaksi
Tulis Konfigurasi Musim Semi
<bean id = "persondao"> </ bean> <bean id = "transaction"> </ bean> <aop: config> <!-pointcut ekspresi menentukan kelas target-> <aop: pointcut ekspresi = "eksekusi (* cn.qjc.aop.xml.persondaoImpl." <AOP: aspek ref = "transaction"> <aop: sebelum metode = "beginTransaction" pointcut-ref = "lakukan"/> <aop: metode setelah kembali = "komit" pointcut-ref = "lakukan"/> </aop: aspek> </aop: config> </boy>
tes
/*** Test Spring Dynamic Proxy* @Author qjc*/Public Class TransactionTest {@test public void testSave () {applicationContext context = new ClassPathXMLApplicationContext ("cn/qjc/aop/xml/applicationContext.xml"); Persondao persondao = (persondao) context.getbean ("persondao"); persondao.saveperson (); }}Prinsip AOP Musim Semi
1. Ketika wadah pegas dimulai, dua kacang dimuat dan dipakai.
2. Ketika Container Spring mem-parsing file konfigurasi ke <aop: config>, parse ekspresi titik-potong dan cocokkan kacang konten kontainer pegas sesuai dengan ekspresi titik-potong.
3. Jika pertandingan berhasil, buat objek proxy untuk kacang
4. Ketika klien menggunakan Context.getBean untuk mendapatkan objek, jika objek memiliki objek proxy, ia mengembalikan objek proxy. Jika tidak ada objek proxy, ia mengembalikan objek itu sendiri.
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.