Membandingkan Spring AOP dan AspectJ

1. Pengenalan

Terdapat banyak perpustakaan AOP yang ada hari ini, dan ini perlu dapat menjawab sejumlah soalan:

  • Adakah ia sesuai dengan aplikasi saya yang sedia ada atau baru?
  • Di mana saya boleh melaksanakan AOP?
  • Seberapa cepat ia akan disatukan dengan aplikasi saya?
  • Berapakah prestasi overhed?

Dalam artikel ini, kita akan melihat pada menjawab soalan-soalan ini dan memperkenalkan Spring AOP dan AspectJ - dua kerangka kerja AOP paling popular untuk Java.

2. Konsep AOP

Sebelum kita mulakan, mari buat tinjauan terma dan konsep teras peringkat tinggi yang cepat:

  • Aspek - kod / ciri standard yang tersebar di pelbagai tempat dalam aplikasi dan biasanya berbeza daripada Logik Perniagaan sebenar (misalnya, pengurusan Transaksi). Setiap aspek menumpukan pada fungsi rentas tertentu
  • Joinpoint - ini adalah titik tertentu semasa pelaksanaan program seperti pelaksanaan kaedah, panggilan konstruktor, atau tugas lapangan
  • Nasihat - tindakan yang diambil oleh aspek dalam titik bergabung tertentu
  • Titik titik - ungkapan biasa yang sepadan dengan titik bergabung. Setiap kali mana-mana titik gandingan sepadan dengan titik titik, nasihat tertentu yang berkaitan dengan titik itu dilaksanakan
  • Tenunan - proses menghubungkan aspek dengan objek yang disasarkan untuk membuat objek yang disarankan

3. Spring AOP dan AspectJ

Sekarang, mari kita bincangkan Spring AOP dan AspectJ di sebilangan paksi - seperti keupayaan, tujuan, tenunan, struktur dalaman, titik bergabung, dan kesederhanaan.

3.1. Keupayaan dan Matlamat

Ringkasnya, Spring AOP dan AspectJ mempunyai tujuan yang berbeza.

Spring AOP bertujuan untuk menyediakan pelaksanaan AOP sederhana di Spring IoC untuk menyelesaikan masalah yang paling biasa yang dihadapi oleh pengaturcara. Ia tidak bertujuan sebagai penyelesaian AOP yang lengkap - hanya boleh digunakan pada kacang yang diuruskan oleh bekas Spring.

Sebaliknya, AspectJ adalah teknologi AOP yang asli yang bertujuan untuk memberikan penyelesaian AOP yang lengkap. Ia lebih mantap tetapi juga lebih rumit daripada Spring AOP. Perlu juga diperhatikan bahawa AspectJ dapat digunakan di semua objek domain.

3.2. Tenunan

Kedua-dua AspectJ dan Spring AOP menggunakan pelbagai jenis tenunan yang mempengaruhi tingkah laku mereka mengenai prestasi dan kemudahan penggunaan.

AspectJ menggunakan tiga jenis tenunan:

  1. Tenunan masa kompilasi: Penyusun AspectJ mengambil input kod sumber dari aspek kami dan aplikasi kami dan menghasilkan fail kelas tenunan sebagai output
  2. Tenunan pasca kompilasi : Ini juga dikenali sebagai tenunan binari. Ia digunakan untuk menenun fail kelas dan fail JAR yang ada dengan aspek kami
  3. Tenunan masa muat : Ini persis seperti tenunan binari sebelumnya, dengan perbezaan bahawa tenunan ditangguhkan sehingga pemuat kelas memuat fail kelas ke JVM

Untuk maklumat lebih mendalam mengenai AspectJ itu sendiri, baca artikel ini.

Oleh kerana AspectJ menggunakan masa kompilasi dan tenunan waktu kelas, Spring AOP menggunakan tenunan runtime .

Dengan tenunan runtime, aspeknya ditenun semasa pelaksanaan aplikasi menggunakan proksi dari objek yang disasarkan - menggunakan proksi dinamik JDK atau proksi CGLIB (yang akan dibincangkan pada titik seterusnya):

3.3. Struktur dan Aplikasi Dalaman

Spring AOP adalah rangka kerja AOP berasaskan proksi. Ini bermaksud bahawa untuk melaksanakan aspek ke objek sasaran, ia akan membuat proksi objek tersebut. Ini dicapai dengan menggunakan salah satu daripada dua cara:

  1. Proksi dinamik JDK - kaedah pilihan untuk Spring AOP. Setiap kali objek yang disasarkan menerapkan satu antara muka, maka proksi dinamik JDK akan digunakan
  2. Proksi CGLIB - jika objek sasaran tidak melaksanakan antara muka, maka proksi CGLIB dapat digunakan

Kami boleh mengetahui lebih lanjut mengenai mekanisme proksi Spring AOP dari dokumen rasmi.

AspectJ, sebaliknya, tidak melakukan apa-apa pada waktu runtime kerana kelas disusun secara langsung dengan aspek.

Dan tidak seperti Spring AOP, ia tidak memerlukan corak reka bentuk. Untuk menyusun aspek pada kod, ia memperkenalkan penyusunnya yang dikenali sebagai AspectJ compiler (ajc), di mana kita menyusun program kita dan kemudian menjalankannya dengan menyediakan perpustakaan runtime kecil (<100K).

3.4. Titik bergabung

Pada bahagian 3.3, kami menunjukkan bahawa Spring AOP didasarkan pada corak proksi. Oleh kerana itu, ia perlu mengklasifikasikan kelas Java yang disasarkan dan menerapkan permasalahan silang yang sesuai.

Tetapi ia hadir dengan had. Kami tidak dapat menerapkan keprihatinan rentas (atau aspek) di kelas yang "final" kerana mereka tidak dapat ditimpa dan oleh itu ia akan menyebabkan pengecualian runtime.

Perkara yang sama berlaku untuk kaedah statik dan akhir. Aspek musim bunga tidak dapat diterapkan pada mereka kerana tidak dapat ditimpa. Oleh itu Spring AOP kerana batasan ini, hanya menyokong kaedah penyatuan pelaksanaan titik.

Walau bagaimanapun, AspectJ menyusun masalah silang langsung ke dalam kod sebenar sebelum waktu operasi. Tidak seperti Spring AOP, ia tidak memerlukan subkelas objek yang disasarkan dan dengan itu menyokong banyak titik bergabung yang lain juga. Berikut adalah ringkasan titik bergabung yang disokong:

Titik gabung Spring AOP Disokong AspectJ Disokong
Panggilan Kaedah Tidak Ya
Kaedah Pelaksanaan Ya Ya
Panggilan Pembina Tidak Ya
Pelaksanaan Konstruktor Tidak Ya
Pelaksanaan pemula statik Tidak Ya
Permulaan objek Tidak Ya
Rujukan lapangan Tidak Ya
Tugasan lapangan Tidak Ya
Pelaksanaan pengendali Tidak Ya
Pelaksanaan nasihat Tidak Ya

Perlu diingat bahawa dalam Spring AOP, aspek tidak diterapkan pada kaedah yang disebut dalam kelas yang sama.

Itu jelas kerana apabila kita memanggil kaedah dalam kelas yang sama, maka kita tidak memanggil kaedah proksi yang dibekalkan oleh Spring AOP. Sekiranya kita memerlukan fungsi ini, maka kita mesti menentukan kaedah yang terpisah dalam kacang yang berbeza, atau menggunakan AspectJ.

3.5. Kesederhanaan

Spring AOP jelas lebih mudah kerana tidak memperkenalkan penyusun atau penenun tambahan antara proses pembuatan kami. Ia menggunakan tenunan runtime, dan oleh itu ia menyatu dengan proses pembinaan biasa kita. Walaupun kelihatan sederhana, ia hanya berfungsi dengan kacang yang diuruskan oleh Spring.

Namun, untuk menggunakan AspectJ, kami diminta untuk memperkenalkan pengkompil AspectJ (ajc) dan mengemas semula semua perpustakaan kami (kecuali jika kami beralih ke tenunan pasca-kompilasi atau waktu muat).

Ini tentu saja lebih rumit daripada yang sebelumnya - kerana ia memperkenalkan AspectJ Java Tools (yang merangkumi penyusun (ajc), penyahpepijat (ajdb), penjana dokumentasi (ajdoc), penyemak imbas struktur program (ajbrowser)) yang kami perlu disatukan dengan IDE kami atau alat bina.

3.6. Persembahan

Sejauh prestasi, tenunan waktu kompilasi jauh lebih cepat daripada tenunan runtime . Spring AOP adalah kerangka berasaskan proksi, jadi terdapat penciptaan proksi pada saat permulaan aplikasi. Juga, terdapat beberapa kaedah lain untuk setiap aspek, yang mempengaruhi prestasi secara negatif.

Sebaliknya, AspectJ menyusun aspek ke dalam kod utama sebelum aplikasi dijalankan dan dengan itu tidak ada overhead jangka masa tambahan, tidak seperti Spring AOP.

Atas sebab-sebab ini, tanda aras menunjukkan bahawa AspectJ hampir sekitar 8 hingga 35 kali lebih cepat daripada Spring AOP.

4. Ringkasan

Jadual ringkas ini merangkum perbezaan utama antara Spring AOP dan AspectJ:

Musim bunga AOP AspekJ
Dilaksanakan di Jawa tulen Dilaksanakan menggunakan peluasan bahasa pengaturcaraan Java
Tidak perlu proses penyusunan yang berasingan Memerlukan penyusun AspectJ (ajc) melainkan LTW disediakan
Hanya tenunan runtime yang ada Tenunan runtime tidak tersedia. Menyokong tenunan masa kompilasi, pasca kompilasi, dan masa muat
Kurang Kuat - hanya menyokong tenunan tahap kaedah Lebih Kuat - boleh menenun bidang, kaedah, pembina, pemula statik, kelas / kaedah akhir, dll ...
Hanya boleh dilaksanakan pada kacang yang diuruskan oleh bekas Spring Boleh dilaksanakan pada semua objek domain
Menyokong titik jalan pelaksanaan kaedah sahaja Sokong semua potongan titik
Proksi dibuat dari objek yang disasarkan, dan aspek diterapkan pada proksi ini Aspek ditenun secara langsung ke dalam kod sebelum aplikasi dijalankan (sebelum waktu berjalan)
Jauh lebih perlahan daripada AspectJ Prestasi Lebih Baik
Mudah dipelajari dan diaplikasikan Secara relatifnya lebih rumit daripada Spring AOP

5. Memilih Kerangka yang Betul

Sekiranya kita menganalisis semua argumen yang dibuat dalam bahagian ini, kita akan mula memahami bahawa tidak sama sekali satu kerangka kerja lebih baik daripada yang lain.

Ringkasnya, pilihan sangat bergantung pada keperluan kami:

  • Kerangka kerja: Jika aplikasi tidak menggunakan rangka kerja Spring, maka kami tidak punya pilihan selain menjatuhkan idea menggunakan Spring AOP kerana tidak dapat menguruskan apa pun yang berada di luar jangkauan wadah spring. Tetapi, jika aplikasi kita dibuat sepenuhnya menggunakan Spring framework, maka kita dapat menggunakan Spring AOP kerana mudah untuk belajar dan menerapkannya
  • Fleksibiliti: Memandangkan sokongan gabungan yang terhad, Spring AOP bukanlah penyelesaian AOP yang lengkap, tetapi menyelesaikan masalah paling biasa yang dihadapi oleh pengaturcara. Walaupun jika kita ingin menggali lebih dalam dan memanfaatkan AOP dengan kemampuan maksimumnya dan menginginkan sokongan dari pelbagai titik gabungan yang tersedia, maka AspectJ adalah pilihan
  • Prestasi: Sekiranya kita menggunakan aspek yang terhad, maka terdapat perbezaan prestasi yang remeh. Tetapi kadang-kadang ada kes apabila aplikasi mempunyai lebih dari puluhan ribu aspek. Kami tidak mahu menggunakan tenunan runtime dalam kes seperti itu, lebih baik memilih AspectJ. AspectJ diketahui 8 hingga 35 kali lebih cepat daripada Spring AOP
  • Terbaik dari Kedua-duanya: Kedua-dua kerangka ini sepenuhnya serasi antara satu sama lain. Kami sentiasa dapat memanfaatkan Spring AOP seboleh-bolehnya dan masih menggunakan AspectJ untuk mendapatkan sokongan titik bergabung yang tidak didukung

6. Kesimpulannya

Dalam artikel ini, kami menganalisis Spring AOP dan AspectJ, di beberapa bidang utama.

Kami membandingkan dua pendekatan untuk AOP baik fleksibiliti dan juga seberapa mudah mereka sesuai dengan aplikasi kami.