Apa itu AOP
AOP (pemrograman berorientasi aspek, pemrograman berorientasi aspek) dapat dikatakan sebagai suplemen dan peningkatan OOP (pemrograman berorientasi objek). OOP memperkenalkan konsep -konsep seperti enkapsulasi, warisan, dan polimorfisme untuk membangun hierarki objek untuk mensimulasikan kumpulan perilaku publik. Ketika kita perlu memperkenalkan perilaku publik ke benda -benda yang tersebar, OOP tampaknya tidak berdaya. Artinya, OOP memungkinkan Anda untuk mendefinisikan hubungan dari atas ke bawah, tetapi tidak cocok untuk mendefinisikan hubungan dari kiri ke kanan. Misalnya, fungsi logging. Kode log sering tersebar secara horizontal di semua level objek tanpa hubungan dengan fungsi inti dari objek yang tersebar. Hal yang sama berlaku untuk jenis kode lainnya, seperti keamanan, penanganan pengecualian, dan transparansi. Kode yang tidak relevan semacam ini tersebar di mana-mana disebut kode lintas-potong. Dalam desain OOP, itu menyebabkan banyak duplikasi kode, yang tidak kondusif untuk penggunaan kembali setiap modul.
Perkenalan
Pola desain java yang saya tulis beberapa waktu lalu - pola proxy. Baru -baru ini, ketika saya melihat Spring AOP, saya merasa bahwa harus ada koneksi dekat dalam pola proxy, jadi saya memutuskan untuk memahami prinsip implementasi Spring AOP.
Berbicara tentang AOP, kita harus berbicara tentang OOP. Konsep enkapsulasi, warisan dan polimorfisme diperkenalkan dalam OOP untuk membangun hierarki objek untuk mensimulasikan kumpulan perilaku publik. Namun, jika kita perlu memperkenalkan bagian -bagian umum untuk beberapa objek, OOP akan memperkenalkan banyak kode duplikat. Misalnya: Fungsi logging.
Teknologi AOP menggunakan teknik yang disebut "crosscutting" untuk membedah bagian dalam objek yang dienkapsulasi dan merangkum perilaku umum yang mempengaruhi beberapa kelas menjadi modul yang dapat digunakan kembali, yang dapat mengurangi duplikasi kode sistem, mengurangi kopling antara modul, dan memfasilitasi operasi dan pemeliharaan di masa depan. AOP membagi sistem perangkat lunak menjadi dua bagian: perhatian inti dan perhatian silang. Proses utama pemrosesan bisnis adalah fokus inti, dan bagian yang tidak ada hubungannya dengan itu adalah fokus cross-sectional. Salah satu karakteristik kekhawatiran lintas sekelompok adalah bahwa mereka sering terjadi dalam berbagai masalah inti, dan pada dasarnya serupa di mana-mana. Misalnya, otentikasi izin, pencatatan, dan pemrosesan transaksi.
Prinsip Implementasi
Ketika saya mempelajari mode proxy, saya belajar bahwa mode proxy dibagi menjadi proxy dinamis dan proxy statis. Sekarang kami pertama -tama akan menerapkan kerangka kerja AOP kami sendiri berdasarkan model proxy, dan kemudian mempelajari prinsip -prinsip implementasi AOP Spring.
Pertama, ini diimplementasikan dengan proxy statis. Kunci proxy statis adalah menerapkan antarmuka umum antara objek proxy dan objek target, dan objek proxy memegang referensi ke objek target.
Kode Antarmuka Publik:
Antarmuka Publik Ihello {/*** Metode Bisnis*@param str*/void sayhello (string str);} target class code: kelas publik hello mengimplementasikan Ihello {@Overridepublic void sayhello (string str) {System.out.println ("hello"+str);}} Untuk kode kelas proxy, kami menambahkan fungsi logging ke dalamnya, dan menjalankan metode tertentu sebelum dan sesudah metode dimulai. Bukankah ini mirip dengan AOP?
Proxyhello kelas publik mengimplementasikan Ihello {private ihello hello; proxyhello publik (ihello halo) {super (); this.hello = hello;}@overridepublic void wayshello (string str) {logger.start (); // tambahkan metode tertentu hello.sayhello (str); logger.end ();}} Kode kelas log:
Logger kelas publik {public static void start () {System.out.println (tanggal baru ()+ "Say Hello Start ...");} public static void end () {System.out.println (Tanggal baru ()+ "Say Hello End");}} Kode Uji:
tes kelas publik {public static void main (string [] args) {ihello hello = new proxyhello (new hello ()); // jika kita membutuhkan fungsi logging, gunakan kelas proxy // ihello hello = new hello (); // jika kita tidak memerlukan fungsi logging, gunakan kelas target hello.sayhello ("besok"); }}Dengan cara ini, kami menerapkan AOP paling sederhana, tetapi akan ada masalah: jika kami memiliki banyak kelas seperti halo, maka haruskah kami menulis banyak kelas seperti HelloProxy? Bahkan, itu juga merupakan hal yang sangat merepotkan. Setelah JDK1.3, JDK memberi kami kelas API Java.lang.Reflect.InvocationHandler. Kelas ini memungkinkan kita untuk secara dinamis melakukan sesuatu untuk beberapa metode ketika JVM memanggil metode kelas tertentu. Mari kita terapkan implementasi proxy dinamis.
Implementasi proksi dinamis terutama mengimplementasikan InvocationHandler, dan menyuntikkan objek target ke dalam objek proxy, menggunakan mekanisme refleksi untuk menjalankan metode objek target.
Implementasi antarmuka sama dengan proxy statis, kode kelas proxy:
Kelas Publik Dynaproxyhello mengimplementasikan InvocationHandler {private objek target; // objek target/*** instantiate objek target melalui refleksi* @param objek* @return*/bind objek publik (objek objek) {this.target = objek; get proxy.newproxyinstance (this.target.getClass (). this.target.getClass (). getInterfaces (), this);}@overridepublic objek Invoke (proxy objek, metode metode, objek [] args) melempar lemparan {objek hasil = null; logger.start (); // tambahkan metode tambahan // metode untuk menjalankan objek target melalui mekanisme refleksi hasil mekanisme refleksi = Method.invoke () (ini. Kode kelas tes:
public class DynaTest {public static void main(String[] args) {IHello hello = (IHello) new DynaProxyHello().bind(new Hello());//If we need logging function, use proxy class //IHello hello = new Hello();//If we do not need logging function, use target class hello.sayHello("tomorrow");}} Setelah membaca kode di atas, mungkin ada masalah dibandingkan dengan Spring AOP. Kelas log hanya dapat dicetak sebelum dan sesudah metode, tetapi AOP harus dapat mengeksekusi ketika kondisinya dipenuhi. Bisakah semua objek Dynapoxyhello dan objek operasi log (logger) dipisahkan?
Melihat implementasi kode berikut, itu akan memisahkan objek Dynapoxyhello dan objek operasi log (logger):
Kita perlu menambahkan kode operasi log (atau kode operasi lainnya) sebelum atau setelah metode objek proxy. Kemudian, kita dapat mengabstraksi antarmuka, yang hanya memiliki dua metode: satu adalah metode yang dieksekusi sebelum objek proxy ingin menjalankan metode. Kami menamainya mulai, dan metode kedua adalah metode yang dieksekusi setelah objek proxy mengeksekusi metode, dan kami menamakannya berakhir.
Antarmuka Logger:
antarmuka publik ilogger {void start (metode metode); void end (metode metode);} Implementasi Antarmuka Logger:
Kelas publik Dlogger mengimplementasikan Ilogger {@Overridepublic void start (metode metode) {System.out.println (tanggal baru () + method.getName () + "Say Hello Start ...");}@overridepublic end end (metode metode) {System.out.println (date new date () + Method.get.get.get (Metode) {System.out.println (new Date () + Method.get.get.get. Kelas proxy dinamis:
Dynaproxyhello kelas publik mengimplementasikan InvocationHandler {// panggilan objek objek proxy objek pribadi; // target objek objek objek target; bind objek publik (target objek, objek proxy) {this.target = target; this.proxy = proxy; return proxy.newproxyinstance (this.target.gets (). this.target.getClass (). getInterfaces (), this);}@overridepublic Object Invoke (proxy objek, metode metode, objek [] args) melempar lemparan {objek hasil = null; // refleksi mula operator clazz = this.proxy.getClas Class [] {method.class}); // Refleksi mengeksekusi metode start start.invoke (this.proxy, objek baru [] {this.proxy.getClass ()}); // mengeksekusi metode asli untuk memproses metode end.invoke (this.target, args); // Refleksi memperoleh metode akhir operator. Class [] {method.class}); // Refleksi menjalankan metode akhir end.invoke (this.proxy, objek baru [] {Method}); hasil return;}} Kode Uji:
public class DynaTest {public static void main(String[] args) {IHello hello = (IHello) new DynaProxyHello().bind(new Hello(), new DLogger());//If we need logging function, use proxy class //IHello hello = new Hello();//If we do not need logging function, use target class hello.sayhello ("besok");}} Melalui contoh di atas, kita dapat menemukan bahwa melalui proksi dinamis dan teknologi transmisi, fungsi AOP pada dasarnya telah diimplementasikan. Jika kita hanya perlu mencetak log sebelum metode dieksekusi, kita tidak dapat mengimplementasikan metode akhir (), sehingga kita dapat mengontrol waktu pencetakan. Jika kita ingin metode yang ditentukan untuk mencetak log, kita hanya perlu menambahkan penilaian pada nama metode ke metode Invoke (). Nama metode dapat ditulis dalam file XML, sehingga kami dapat memisahkannya dengan file konfigurasi, sehingga kami menerapkan kerangka kerja AOP musim semi sederhana.
Konten di atas adalah prinsip implementasi pegas AOP yang diperkenalkan kepada Anda oleh editor. Saya harap ini akan membantu Anda!