Artikel ini terutama menganalisis konsep desain arsitektur tulang dari kerangka kerja musim semi dari kerangka kerja musim semi. Mengapa komponen ini membutuhkan komponen ini? Bagaimana mereka menggabungkan bersama untuk membentuk arsitektur kerangka Spring? Bagaimana fitur AOP Spring menggunakan arsitektur kerangka dasar ini untuk bekerja? Jenis model desain apa yang digunakan di musim semi untuk menyelesaikan desain ini? Apa inspirasi konsep desain ini untuk desain perangkat lunak masa depan kita? Artikel ini akan menjawab pertanyaan ini secara rinci.
Arsitektur kerangka musim semi
Ada lebih dari selusin komponen di musim semi, tetapi hanya ada beberapa komponen inti nyata.
Gambar 1. Diagram arsitektur keseluruhan kerangka kerja ini
Dapat dilihat dari gambar di atas bahwa hanya ada tiga komponen inti dalam kerangka kerja musim semi: inti, konteks, dan kacang. Mereka membangun seluruh arsitektur kerangka pegas. Tanpa mereka, tidak mungkin memiliki karakteristik lapisan atas seperti AOP dan Web. Di bawah ini juga akan menganalisis pegas terutama dari ketiga komponen ini.
Konsep Desain Musim Semi
Seperti yang disebutkan sebelumnya, tiga komponen inti musim semi diperkenalkan. Bean adalah protagonis nyata di musim semi.
Peran Bean di Spring adalah seperti makna Object untuk OOP. Sama seperti tahap kinerja, tetapi tidak ada aktor. Mengapa Peran Bean atau Mengapa Sangat Penting di Musim Semi? mengelola file konfigurasi, yang merupakan mekanisme injeksi ketergantungannya. Dan hubungan injeksi ini dikelola dalam wadah IOC, lalu apa objek wadah IOC dibungkus oleh kacang. Musim semi adalah tujuan mengelola objek ini dan beberapa operasi tambahan dengan mengemas objek dalam kacang.
Strategi desainnya benar -benar mirip dengan konsep desain Java untuk mengimplementasikan OOP. lingkungan ini di lingkungan ini sesuai dengan aturan tertentu. Memikirkannya, pikirkan tentang kerangka kerja lain yang kami gunakan dalam konsep desain yang sama besar.
Cara bekerja sama dengan komponen inti
Seperti yang disebutkan sebelumnya, Bean adalah faktor kunci dalam musim semi. Jika Anda seorang aktor dalam suatu kinerja, konteks adalah latar belakang panggung dari kinerja ini, dan inti harus menjadi alat peraga kinerja. Hanya ketika mereka bersama, mereka dapat memiliki kondisi paling mendasar yang dapat melakukan pertunjukan yang baik. Tentu saja, kondisi yang paling mendasar tidak dapat membuat kinerja ini menonjol, dan pertunjukan yang ia lakukan cukup menarik.
Kami tahu bahwa kacang dikemas adalah objek, dan objek harus memiliki data. mereka dan untuk mempertahankan hubungan ini. Jadi konteks adalah kumpulan hubungan kacang. Jadi apa gunanya komponen inti? Faktanya, inti adalah beberapa kolom yang diperlukan untuk hubungan antara setiap kacang untuk menemukan, membangun, dan mempertahankan hubungan antara setiap kacang.
Mereka dapat diwakili oleh gambar di bawah ini:
Gambar 2. Tiga hubungan komponen
Penjelasan terperinci tentang komponen inti
Di sini kami akan memperkenalkan hubungan hierarkis dari masing -masing komponen secara rinci, serta urutan pesanan saat runtime. Kita harus memperhatikan penggunaan musim semi.
Komponen kacang
Pentingnya komponen kacang untuk musim semi telah dijelaskan sebelumnya. Komponen kacang dikemas di bawah org.springframework.beans Spring. Semua kategori di bawah paket ini menyelesaikan tiga hal: definisi Bean, kreasi Bean, dan analisis kacang. Untuk pengguna musim semi, satu -satunya hal yang perlu dipedulikan adalah penciptaan kacang.
Model pabrik khas Springbean dibuat.
Gambar 4. Hubungan warisan pabrik TheBean
BeanFactory memiliki tiga subclass: ListableBeanFactory, HierarchicalBeanFactory, dan AutoWire Campable Bean Factory. Tetapi dari gambar di atas, kita dapat menemukan bahwa kelas implementasi default akhir adalah defaultListableBeanFactory, dan dia mengimplementasikan semua antarmuka. Jadi mengapa mendefinisikan begitu banyak tingkat antarmuka? Lihatlah kode sumber dan instruksi antarmuka ini. Ditemukan bahwa setiap antarmuka memiliki kesempatan yang ia gunakan. proses operasi. Misalnya, antarmuka ListableAnfactory menunjukkan bahwa kacang ini adalah daftar, dan HierarkisbeanFactory berarti bahwa kacang ini memiliki hubungan warisan, yaitu, masing -masing kacang mungkin memiliki kacang ayah. AutoWireCapableBeanFactory Interface mendefinisikan aturan perakitan otomatis Bean. Keempat antarmuka ini bersama -sama mendefinisikan koleksi kacang, hubungan antara kacang, dan perilaku kacang.
Definisi Bean terutama termasuk deskripsi beandefinition.
Gambar 5. Diagram Hubungan Hirarki Kelas yang Didefinisikan oleh Bybean
Definisi kacang adalah deskripsi lengkap dari semua informasi dalam node yang Anda tentukan dalam file konfigurasi pegas, termasuk berbagai sub -node. Ketika Spring berhasil menganalisis simpul yang Anda tetapkan, ia diubah menjadi objek beandefinition dalam musim semi. Semua operasi akan dilakukan untuk objek ini di masa depan.
Proses analisis Bean sangat rumit, dan fungsinya dibagi menjadi lebih detail, karena ada banyak tempat yang harus diperpanjang di sini, dan mereka harus memastikan fleksibilitas yang cukup untuk mengatasi kemungkinan perubahan. Analisis Bean terutama untuk menganalisis file konfigurasi pegas. Proses analisis ini terutama diselesaikan melalui kelas pada gambar di bawah ini:
Gambar 6. Kelas analitik Bean
Tentu saja, ada juga analisis tag khusus.
Komponen konteks
Konteks dikemas di bawah org.springframework.context. Mari kita lihat bagaimana lingkungan ini dibangun.
ApplicationContext adalah kelas induk teratas konteks. Di bawah ini adalah diagram struktur konteks:
Gambar 7. Diagram Struktur Kelas Terkait Kelas
Dapat dilihat dari gambar di atas bahwa ApplicationsContext mewarisi beanfactory, yang juga menunjukkan bahwa objek utama dari wadah musim semi adalah kacang.
Subkelas ApplicationContext terutama mencakup dua aspek:
ConfigurableAppLicationContext menunjukkan bahwa konteksnya dimodifikasi, yaitu pengguna dapat secara dinamis menambahkan atau memodifikasi informasi konfigurasi yang ada dalam konteks.
WebApplicationContext adalah nama dari nama, yang merupakan konteks yang disiapkan untuk web.
Kemudian sub -down adalah untuk membangun jenis konteks, diikuti dengan cara untuk mengakses konteks. Level tingkat pertama seperti itu merupakan tingkat tingkat konteks yang lengkap.
Secara umum, ApplicationContext harus menyelesaikan yang berikut:
◆ Buat lingkungan aplikasi
◆ Gunakan beanfactory untuk membuat objek kacang
◆ Simpan tabel hubungan objek
◆ Dapat menangkap berbagai acara
Sebagai wadah IOC musim semi, konteks pada dasarnya mengintegrasikan sebagian besar fitur musim semi, atau merupakan dasar dari sebagian besar fitur.
Komponen inti
Komponen inti, sebagai komponen inti dari Spring, berisi banyak kategori utama. Cara ini untuk mengabstraksikan semua sumber daya ke dalam antarmuka layak dipelajari dalam desain di masa depan. Mari kita lihat peran bagian ini di musim semi.
Gambar di bawah ini adalah diagram struktural yang terkait dengan sumber daya yang terkait:
Gambar 8.Rsource diagram struktur kelas terkait
Dapat dilihat dari gambar di atas bahwa antarmuka sumber daya merangkum berbagai jenis sumber daya yang mungkin, yaitu, perbedaan jenis file diblokir untuk pengguna. Untuk Penyedia Sumber Daya, cara mengemas sumber daya kepada orang lain untuk menggunakannya juga merupakan masalah. Dengan cara ini, semua sumber daya dapat diperoleh melalui kelas InputStream, sehingga penyedia sumber daya juga terlindung. Masalah lain adalah bahwa masalah sumber daya pemuatan, yaitu, pemuat sumber daya harus disatukan.
Mari kita lihat bagaimana konteks dan sumber daya telah menjalin hubungan? Pertama -tama lihat diagram hubungan mereka:
Gambar 9. Diagram Hubungan Konteks dan Sumber Daya
Seperti yang dapat dilihat dari gambar di atas, konteks mempercayakan pekerjaan pemuatan, analisis, dan deskripsi sumber daya ke kelas ResourcePatternResolver untuk diselesaikan. Ada banyak cara serupa dengan komponen inti.
Cara bekerja di wadah IOC
Seperti yang disebutkan sebelumnya, struktur dan saling ketergantungan komponen inti, komponen kacang dan komponen konteks.
Cara membuat pabrik beanfactory
Seperti yang dijelaskan dalam Gambar 2, wadah IOC sebenarnya adalah jaringan hubungan kacang yang dikombinasikan dengan dua komponen lainnya. Pintu masuk yang dibangun adalah dalam metode penyegaran kelas AbstractApplicationContext. Kode metode ini adalah sebagai berikut:
Daftar 1.abstractApplicationContext.refresh
Public Void Refresh () melempar BeansException, IllegalStateException {disinkronkan (this.startupshutdownmonitor) {// Siapkan konteks ini untuk menyegarkan. Konteks. Daftar Kacang Kacang Thatpt Creening. Subkelas. Catch (BeansException EX) {// Destroyan Singleton Dibuat untuk Menghindari Sumber Daya ();Metode ini adalah membangun kode lengkap untuk seluruh proses wadah IOC, dan memahami bahwa setiap baris kode di dalam pada dasarnya memahami prinsip dan fungsi sebagian besar musim semi.
Kode ini terutama berisi langkah -langkah seperti itu:
◆ Bangun beanfactory secara berurutan
◆ Acara mungkin tertarik untuk pendaftaran
◆ Buat objek instance kacang
◆ Memicu acara mendengarkan
Di bawah ini dikombinasikan dengan analisis kode dari proses ini.
Kalimat kedua dan ketiga adalah membuat dan mengonfigurasi beanFactory. Ini adalah refresh, yaitu refresh konfigurasi. Berikut ini adalah kode metode untuk memperbarui beanFactory:
Daftar 2. AbstractrefreshableApplicationContext
Final Void RefreshbeanFactory () melempar BeansException {if (hasbeanfactory ()) {DestroyBeans () ;Metode ini mewujudkan metode abstrak AbstractApplicationContext RefreshBeanFactory. Perhatikan bahwa jenis objek beanfactory memiliki berbagai jenis objek. Objek asli BeanFactory adalah DefaultListableBeanFactory.
Gambar 10.DefaultListableBeanFactory Class Oblitance Diagram
Selain kelas terkait beanfactory, ditemukan bahwa itu juga terkait dengan daftar kacang. Dalam metode RefreshbeanFactory, ada garis loadbeandefinitions (BeanFactory) yang akan menemukan jawabannya. wadah.
Proses ini dapat dijelaskan di peta berurutan berikut:
Gambar 11. Buat Kata Pengantar Waktu Beanfactory
Analisis dan proses pendaftaran Bean adalah sebagai berikut:
Ara
Setelah membuat BeanFactory, tambahkan beberapa kelas alat yang dibutuhkan oleh Spring sendiri.
Tiga kode lini berikutnya dalam AbstractApplicationContext memainkan peran penting dalam perluasan fungsi Spring. Dua baris pertama terutama diizinkan untuk memodifikasi konfigurasi beanfactory yang dibangun sekarang. Jadi mereka semua memperluas fungsi pegas, jadi kita harus belajar menggunakan bagian ini dari menggunakan pegas.
Di antara mereka, dalam metode InvokeBeanFactoryPostProcessors, terutama untuk mendapatkan subkelas untuk mengimplementasikan antarmuka BeanFactoryPostProcessor. Dan menjalankan metode postprocessbeanfactory -nya, pernyataan metode ini adalah sebagai berikut:
Listing 3. BeanFactoryPostProcessor.PostProcessBeanFactory
Void postprocessBeanFactory (configurableListableBeanFactory beanfactory) melempar beansexception;
Parameternya adalah beanfactory, menunjukkan bahwa itu dapat dimodifikasi oleh beanfactory. Data.
Metode RegisterBeanPostProcessors juga dapat memperoleh subkelas definisi pengguna antarmuka beanpostprocessor dan menjalankannya ke variabel beanpostprocessors dalam objek beanfactory. Kedua metode ini dinyatakan dalam processor beanpost: postprocessbeforeinitialisasi dan postprocessafterinilisasi digunakan untuk mengeksekusi selama inisialisasi objek kacang. Dapat melakukan operasi yang ditentukan pengguna.
Kode baris terakhir adalah pendaftaran dari inisialisasi peristiwa pemantauan dan pendengar sistem lainnya.
Cara membuat instance kacang dan membangun jaringan hubungan kacang
Berikut ini adalah Kode Bean Instantiated, yang dimulai dengan metode finishbeanFactoryInitity.
Listing 4.abstracTapplicationContext.FinishBeanFactoryInization
Void finishbeanfactoryInisialisasi (configurawlistableBeanfactory beanfactory) {// Berhenti menggunakan Tempossloader untuk pencocokan tipe. malas-init) singleton.Dapat ditemukan bahwa contoh kacang dapat ditemukan di beanfactory. Metode Kode Preinstanticingingletons adalah sebagai berikut:
Daftar 5.DefaultListableBeanFactory.preinstantialsingletons
Public Void PreINSTANTIATESINGLETONS () Throws Beansexception {if (this.logger.isinfoenabled ()) {this.logger.info ("Pre-Instantiating Singletons in"; } Synchronized (this.beandefinitionMap) {for (string beanname: this: this . beandefinitionNames) {rootBeandefinition BD = getMergedLocalbeandefinition (Beanname); if (! Bd.isabstract () &&ISSINGLEON () &&! ()) {if (IsfactoryBean (Beanname)) {Final FactoryBean Factory = (FactoryBean) GetBean (Factory_bean_prefix+ Beanname); Boolean ISEAGERINIT; if (System.getSecurityManager ()! = Null &&; Factoryof SmartFactoryBean) {Isea GERINIT = AccessController.doprivileged (& NB SP; New PrivilegedAction <Boolean> () {& nb sp; ) {RETURN ((SmartFactoryBean) factor) IiseAgerInit (); ;}}}}}}}}Ada kacang yang sangat penting di sini -Factorybean. Ini dapat menentukan metode menghasilkan objek instan selama metode GetObject -nya diimplementasikan. Namun, objek instance dari kacang di dalam musim semi adalah pabrik. Objek Pabrik Perolehan Musim Semi itu sendiri selesai dengan & untuk menyelesaikannya.
Cara membuat objek instan kacang dan cara membangun kunci inti dalam hubungan yang terkait antara objek instance kacang, berikut ini adalah diagram alur dari proses ini.
Gambar 13. Bagan Aliran Pembuatan Instance
Jika itu adalah kacang biasa, ia menciptakan contohnya secara langsung, dengan memanggil metode Getbean. Berikut ini adalah peta waktu -sekuensial membuat instance kacang:
Gambar 14. Bagan sekuensial pembuatan instance
Bagian lain yang sangat penting adalah membangun hubungan antara instance objek kacang.
Gambar 15. Pembentukan Hubungan Objek Terbaik
Titik ekspansi wadah IOC
Masalah lain adalah bagaimana membuat benda kacang ini memiliki ekstensibilitas tertentu, yaitu, beberapa operasi dapat ditambahkan. Jadi apa saja ekstensi? Bagaimana musim semi menyebut ekstensi ini?
Untuk wadah IOC Spring, ada begitu banyak. BeanFactoryPostProcessor, BeanpostProcessor. Mereka dipanggil saat membangun beanfactory dan membangun benda kacang. Ada inisialisasi dan sekali pakai. Pengguna dapat mengimplementasikan metode yang ditentukan dalam antarmuka ini, dan Spring akan menghubungi mereka pada waktu yang tepat. Lainnya adalah pabrik.
Poin -poin ekspansi ini biasanya di mana kami menggunakan Spring untuk menyelesaikan tugas spesifik kami. . Anda dapat menggunakan metafora berikut untuk menjelaskan.
Kami membandingkan wadah IOC dengan satu kotak. Maka hubungan mereka yang sesuai adalah beanfactory adalah model pembuatan mesin, mode bola adalah kacang, dan bola mode bola adalah contoh kacang. Di mana ekstensi disebutkan sebelumnya? BeanFactoryPostProcessor sesuai dengan penciptaan model bola, dan Anda akan memiliki kesempatan untuk membuat koreksi darinya, yaitu, ia dapat membantu Anda memodifikasi mode bola. InitializingBean dan DisposableBean berada di awal dan akhir model bola, dan Anda dapat menyelesaikan beberapa persiapan dan pekerjaan tailing. BeanPostProcessor memungkinkan Anda untuk membuat koreksi yang sesuai untuk mode bola. Akhirnya, ada pabrik, yang merupakan model bola ajaib. Mode bola ini tidak ada di muka, tetapi Anda akan menentukan bentuknya untuknya. Bola yang Anda inginkan
Cara menggunakan wadah IOC untuk saya
Pengenalan proses konstruksi wadah musim semi sebelumnya, apa yang bisa dilakukan Spring untuk kita, dan apa yang bisa dilakukan wadah IOC Spring? Pertama -tama kita harus membangun wadah IOC menggunakan Spring.
IOC sebenarnya membangun kubus Rubik untuk Anda. Jadi bagaimana kita berpartisipasi? Inilah yang saya katakan sebelumnya untuk memahami beberapa ekstensi di musim semi, dan kami mengubah perilaku umum musim semi dengan mencapai titik -titik yang diperluas itu. Adapun bagaimana mencapai titik ekspansi untuk mendapatkan hasil kepribadian yang kita inginkan, ada banyak contoh di musim semi. digunakan untuk referensi.
Penjelasan terperinci tentang fitur AOP di musim semi
Prinsip implementasi proxy dinamis
Untuk memahami AOP Spring, prinsip agensi dinamis harus dipahami terlebih dahulu, karena AOP diimplementasikan berdasarkan proxy dinamis. Agen dinamis harus mulai dengan JDK itu sendiri.
Ada kelas proxy di bawah paket Java.lang JDK, yang merupakan pintu masuk ke kelas agensi. Struktur kelas ini:
Gambar 16. Struktur Struktur Proksi
Dari gambar di atas, keempatnya adalah metode publik. Metode terakhir newProxyInstance adalah metode membuat objek proxy. Kode sumber metode ini adalah sebagai berikut:
Daftar 6.proxy.NewProxyInstance
Objek statis public newProxyInstance (classloader loader, class> [] antarmuka, InvocatchHandler h) melempar IllegalagumentException {if (h == null) {baris baru nullPointerException ();} class cl = getProxyclass (loader, antarmuka); = cl.getConstructor (constructorparams); );} Catch (InstantiationException e) {lempar internet baru (e.toString ());} Tangkap internet baru (e.toString ());}}Metode ini membutuhkan tiga parameter: ClassLoader, yang digunakan untuk memuat kelas loader kelas proksi. Antarmuka adalah antarmuka yang akan diwakili. InvocationHandler, ini digunakan untuk menjalankan operasi pengguna yang disesuaikan oleh pengguna selain metode dalam antarmuka proxy. Pengguna memanggil metode target diwakili oleh metode unik yang ditentukan dalam InvacationHandler Class Invoke. Ini akan dijelaskan secara rinci nanti.
Mari kita lihat bagaimana proxy menghasilkan kelas proxy. Terungkap di bawah ini.
Gambar 17. Buat objek proxy
Faktanya, dapat ditemukan dari gambar di atas bahwa kelas agen dalam metode generateproxyclass proxygenerator. Kelas Proxygientor dibungkus di bawah Sun.misc.
Jika ada antarmuka seperti itu, sebagai berikut:
Daftar 7. Kelas Sederhana
antarmuka publik SimpleProxy {public void Sizemethod1 ();Struktur kelas yang dihasilkan oleh agen adalah sebagai berikut:
Daftar 8. $ Kelas Proxy2
Kelas publik Proxy2 memperluas java.lang.rang.reflect.proxy mengimplementasikan SimpleProxy {java.lang.reflect.method M0; Metode M3;Metode dalam kelas ini akan memanggil metode Invoke dari InvocationHandler, dan setiap metode akan sesuai dengan variabel properti. Beginilah seluruh agen diwujudkan.
Bagaimana mencapai spring
Dari prinsip agen sebelumnya, kita tahu bahwa tujuan proxy adalah bahwa ketika metode target dipanggil, kita dapat menjalankan metode Invoke dari kelas InvocationHandler, jadi bagaimana membuat artikel tentang InvocationHandler adalah kunci untuk mengimplementasikan AOP .
Implementasi AOP Spring adalah perjanjian untuk mematuhi AOP Alliance. Pada saat yang sama, Spring telah memperluasnya, menambahkan beberapa antarmuka seperti Pointcut dan penasihat untuk membuatnya lebih fleksibel.
Di bawah ini adalah diagram kelas dari proxy dinamis JDK:
Gambar 18.JDK Diagram Kelas Proksi Dinamis
Gambar di atas dengan jelas menunjukkan antarmuka yang ditentukan oleh definisi AOP Alliance. Jangan membahas bagaimana Spring memperluas AOP Alliance.
Daftar 9. Konfigurasikan Proxy Bean
<bean id = "testbeansingleton"> <name properti = "proxyInterfaces"> <value> org.springframework.ap.framework.prototypetTests $ testbean value> p roperty> <nama properti = "target"> <ref local = "testbeantarget" > Ref> Properti> <nama properti = "singleton"> <value> truevalue> properti> <name properti = "interceptors"> <list> <value> testInterceptorValue> <val ue> testInterceptor2Value> Daftar> Properti> Bean>
Dalam konfigurasi, lihat bahwa antarmuka agen diatur, kelas implementasi antarmuka adalah kelas target, dan pencegat dipanggil sebelum menjalankan metode target. Esensi
Mari kita lihat bagaimana Spring melengkapi agen dan cara memanggil Interceptor.
Seperti yang disebutkan sebelumnya, Spring AOP juga mencapai titik ekspansi sendiri untuk menyelesaikan fitur ini. Tentu saja, objek proxy harus dihasilkan secara dinamis melalui kelas proxy.
Berikut ini adalah bagan waktu objek proxy yang dibuat oleh Spring:
Gambar 19. Munculnya objek objek
Setelah Spring membuat objek proxy, ketika Anda memanggil metode pada objek target, Anda akan diwakili dalam metode Invoke dari kelas InvocationHandler, yang telah dijelaskan sebelumnya. Di sini kelas JDKDYNAMICAOPPROXY mengimplementasikan antarmuka InvocationHandler.
Mari kita lihat bagaimana Spring Calls the Interceptor.
Gambar 20.Pring memanggil interseptor
Di atas adalah agen dinamis JDK.
Analisis Mode Desain di Musim Semi
Ada juga banyak pola desain yang digunakan di musim semi, seperti mode pabrik, mode lajang, mode templat, dll., Dalam "Arsitektur Sistem dan Model Desain Kerangka Webx", "Arsitektur Sistem Tomcat dan Analisis Desain Mode", itu adalah sudah diperkenalkan. Di sini kami terutama memperkenalkan mode agensi dan mode strategi.
Mode proxy
Prinsip Mode Proksi
Mode proxy adalah membuat objek proxy untuk objek tertentu, dan objek proxy mengontrol referensi ke objek asli, dan pembuatan objek proxy ini dapat menambahkan beberapa operasi tambahan ke objek asli. Di bawah ini adalah struktur mode proxy:
Gambar 21. Struktur mode proxy
Subjek: Tema abstrak, ini adalah antarmuka untuk mewujudkan objek nyata dari objek agen.
ProxySubject: Selain antarmuka definisi tema abstrak, kelas proxy juga harus memegang referensi objek agen
RealSubject: Kelas agen adalah objek target.
Cara mengimplementasikan mode proxy di musim semi
Agen dinamis JDK di Spring AOP dicapai dengan menggunakan teknologi mode agensi. Selain antarmuka objek proxy di musim semi, juga akan ada org.springframework.aop.springproxy dan org.springframework.apork.advise. Konstruktor menggunakan mode proxy di musim semi adalah sebagai berikut:
Gambar 22. Diagram struktural mode proxy digunakan dalam kabel
$ Proxy adalah objek proxy yang dibuat, dan subjek adalah tema abstrak, dan objek proxy adalah untuk memegang referensi ke objek target melalui InvocationHandler.
Struktur objek proxy nyata di musim semi adalah sebagai berikut:
Daftar 10 Objek Proxy $ Proxy4
Kelas Publik $ Proxy4 Memperluas Java.lang.Reflect.Proxy mengimplementasikan org.springframework.ap.framework.prototypettss $ testbean work.aop.springproxy org.springframework.aop.framework.advned {java.reflth. Reflect.Method M9; .Method M26; java.lang.reflect.Method M6; java.lang.reflect.method m28; java.lang.reflethod m14; java.lang. Reflect.method m12; java . Lang.reflet.Method M27; java.lang .reflect.method m11; java.lang.reflect.method m22; java.lang.reflect.Method m3; java.lang.reflect.Method java.lang.reflect. Method m4; java.lang.reflet.method m19; java .lang.reflect.Method M7; java.lang.reflet.method m15; java.lang.reflet.method m20; left.Method M10; java. LANG.Reflect.Method M1; java.lang.reflect.Method M17; java .lang.reflect.Method M21; java.lang.reflect.Method m0; ava.lang.reflet.method m24; int HashCode (); int indexof (org.SpringFramework.aop.advisor); int interxof (org.aopalliance. aip.advice); ject); java.lang.string tostring (); void sayhello (); void dosomething (); void dosometHing2 (); java.lang.class getProxiedIndIndIndIndIndIndIRFACES (); ProxytargetClass (); Org.SpringFramework.aop .advisor; getadvisors (); void addvisor (int, org.springframework.aip.advisor) Throws org.SpringFramework.aP.framework.aPConfigeXception; void addadvisor (ORG.Sprin gframework.aop.advisor) Throws org.SpringFramework.aop. framework.aPConfigeXception; void SetTargetsource (ORG .springframework.aop.targetsource); ORG.SpringFramework.aop.Targetsource GetTARGETSource (); d (); Boolean IsinterfaceProxied (java.lang.class); Boolean Removeadvisor (org.SpringFramework.aP. advisor );; Boolean SOR, ORG.SpringFramework.aP.Advisor) Throws org.SpringFramework.aop.framework.aPConfigeXception; void addAdvice (ORG.AOPALLIANCE.AOP.ADVICE) Throws org.SpringFramework.aP.framework.aPConfigexception; void addvice (int, org.aopalliance.aop.advic e) Throws org.Springframework.aP.framework.aPConfigeXception; .aop.advice); java.lang.string toproxyconfigstring (); Boolean isfrozen (); void setexposeProxy (Boolean);策略模式
策略模式原理
The strategy model, as the name suggests, is a strategy to do something. This usually means that there may be multiple methods to complete a certain operation in programming. These methods may have different occasions and may have different adaptation. However, these methods may digunakan.各一个操作方法都当作一个实现策略，使用者可能根据需要选择合适的策略。
下面是策略模式的结构：
图23.策略模式的结构
Context：使用不同策略的环境，它可以根据自身的条件选择不同的策略实现类来完成所要的操作。它持有一个策略实例的引用。创建具体策略对象的方法也可以由他完成。
◆Strategy：抽象策略，定义每个策略都要实现的策略方法
◆ConcreteStrategy：具体策略实现类，实现抽象策略中定义的策略方法
◆Spring中策略模式的实现
◆Spring中策略模式使用有多个地方，如Bean定义对象的创建以及代理对象的创建等。这里主要看一下代理对象创建的策略模式的实现。
前面已经了解Spring的代理方式有两个Jdk动态代理和CGLIB代理。这两个代理方式的使用正是使用了策略模式。它的结构图如下所示：
图24.Spring中策略模式结构图
在上面结构图中与标准的策略模式结构稍微有点不同，这里抽象策略是AopProxy接口，Cglib2AopProxy和JdkDynamicAopProxy分别代表两种策略的实现方式，ProxyFactoryBean就是代表Context角色，它根据条件选择使用Jdk代理方式还是CGLIB方式，而另外三个类主要是来负责创建具体策略对象，ProxyFactoryBean是通过依赖的方法来关联具体策略对象的，它是通过调用策略对象的getProxy (ClassLoaderclassLoader)方法来完成操作。
Meringkaskan
本文通过从Spring的几个核心组件入手，试图找出构建Spring框架的骨骼架构，进而分析Spring在设计的一些设计理念，是否从中找出一些好的设计思想，对我们以后程序设计能提供一些思路。接着再详细分析了Spring中是如何实现这些理念的，以及在设计模式上是如何使用的。