1 fitur musim semi dasar
Spring adalah kerangka kerja open source yang sangat aktif; Ini adalah kerangka kerja yang membangun sistem Javaee multi-lapisan berdasarkan Core, dan tujuan utamanya adalah untuk menyederhanakan pengembangan perusahaan.
Musim semi mengelola kode Anda dengan cara yang tidak invasif. Spring menganjurkan "intrusi minimum", yang berarti Anda dapat menginstal atau menghapus pegas pada waktu yang tepat, dan musim semi membuat Java cerah. (Prinsip terbuka dan penutupan), berikut adalah prinsip penutupan.
2. Alat yang diperlukan untuk mengembangkan musim semi
(Di sini kami pertama memilih Spring 2.5 dan kemudian 3.0)
2.1 Paket Jar Musim Semi
Unduh Spring di http://www.springsource.org/download, lalu decompress, temukan file jar berikut di direktori dekompresi, dan salin ke classpath
―Pust Core Class Spring adalah Dist/Spring.jar di bawah Dist in Spring Document
"Perpustakaan pihak ketiga yang diperkenalkan adalah semua dokumen musim semi di bawah lib, lib/jakarta-commons/commons-logging.jar
―Jika Pemrograman Aspek (AOP) digunakan, file JAR berikut lib/aspekj/aspekjweaver.jar dan aspekjrt.jarlib/cglib/cglib-nodep-2.1_3.jar juga diperlukan
―Jika Anda menggunakan anotasi di JSR-250, seperti@Resource/@PostConstruct/@Predestroy, file JAR berikut lib/j2ee/common-annotations.jar juga diperlukan
Catatan: JSR (Permintaan Spesifikasi Java) mengacu pada permintaan formal untuk menambahkan spesifikasi teknis standar ke JCP (proses komunitas Java). Siapa pun dapat mengirimkan JSR (permintaan spesifikasi Java) untuk menambahkan API dan layanan baru ke platform Java. JSR telah menjadi standar penting di dunia Java
2.2 File Konfigurasi Musim Semi
Secara default itu adalah file applicationContext.xml. Banyak file XML dapat dibuat, dan ini umumnya dikonfigurasi dalam proyek. (Dibuat di direktori src)
3 Penjelasan terperinci tentang fungsi dasar musim semi
3.1 Springioc
Inversi Kontrol Musim Semi: Serahkan pembuatan, inisialisasi, penghancuran, dan tugas -tugas objek lainnya ke wadah pegas. Mengontrol siklus hidup suatu objek oleh wadah musim semi.
melangkah:
•A. Mulailah Wadah Musim Semi
1. Temukan file konfigurasi di classpath untuk instantiate wadah
Salinan kode adalah sebagai berikut: ApplicationContext ctx = new ClassPathXMLapPlicationContext (string baru [] {"applicationContext.xml"});
Anda dapat mencari file XML di seluruh ClassPath
* Muat dengan cara ini. Anda perlu meletakkan file konfigurasi pegas di bawah jalur ClassPath dari proyek saat ini
* Jalur ClassPath mengacu pada direktori SRC dari proyek saat ini, yang merupakan lokasi penyimpanan file sumber Java.
2. Temukan file konfigurasi di jalur sistem file untuk membuat instantiate wadah
File konfigurasi Spring dapat menentukan beberapa file konfigurasi dan dapat diteruskan melalui array string.
Catatan: Gunakan metode pertama untuk memulai wadah sering
•B. Ekstrak objek dari wadah musim semi
Struktur Kontainer Musim Semi:
3.2 alias
<Baci> <alias name = "orang" alias = "p" /// alias adalah alias, Anda bisa mendapatkan orang yang melaluinya hal. <name bean = "orang"/> </taci>
Dengan konfigurasi seperti itu, efek penamaan di satu tempat dan menggunakan nama yang berbeda di banyak tempat dapat dicapai.
3.3 Objek Internal Container Musim Semi
1 Cara membuat objek
1.1 Tidak ada konstruktor parameter
<bean id = "helloWorld"> </tac>
1.2 Metode Pabrik Statis
<bean id = "helloworld2"
Factory-Method = "GetInstance"> </tac>
1.3 Contoh Metode Pabrik
<bean id = "helloWorldfactory"> </tac>
<bean id = "helloWorld3" factory-bean = "helloWorldfactory" factory-method = "getInstance"> </ bean>
Ingat saja konsepnya. Metode pertama adalah yang paling banyak digunakan, tetapi ketika berintegrasi dengan alat lain, model pabrik instan digunakan.
Contoh :
Konfigurasikan ApplicationContext.xml
<? XML Versi = "1.0" encoding = "utf-8"?> <beans xmlns = "http://www.springframework.org/schema/beans" xmlns: xsi = "http://www.w3.org/2001/xmls xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"> <!-- Put a class into a spring container, the class is called a bean --> <!-- Bean describes a class id The unique full name of the class class -> <bean id = "helloWorld"> </t bean> <! ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Method pabrik = "getInstance" > </bean> <! -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Buat Kelas Entitas HelloWorld
Paket com.itheima10.spring.createObject; kelas publik HelloWorld {public void hello () {System.out.println ("Hello"); }}Membangun pabrik statis helloworldfactory
paket com.itheima10.spring.createObject.method; kelas publik helloWorldfactory {public static helloWorld getInstance () {System.out.println ("Metode statis"); return new HelloWorld (); }}Membangun pabrik fisik helloworldfactory2
Paket com.itheima10.spring.createObject.method; kelas publik HelloWorldFactory2 { / *** Objek pabrik harus dibuat sebelum metode ini dapat disebut* @return* / public helloworld getInstance () {return new HelloWorld (); }}Tulis metode tes createObjectMethodTest
Paket com.itheima10.spring.createObject.method; impor org.junit.test; impor org.springframework.context.applicationContext; Impor org.springframework.context.support.classpathxMlapplicationContext; Ini OK ** * CreateObjectMethodTest { / *** Secara default, Container Spring memanggil konstruktor default kelas untuk membuat objek* / @test public void testCreateObject_default () {applicationContext context = classpathxmlappleCicationContext ("applicationContext.xml"); HelloWorld HelloWorld = (HelloWorld) Context.getBean ("HelloWorld"); helloworld.hello (); } /** * Create an object using a static factory* <bean id="helloWorld2" factory-method="getInstance" ></bean> What the spring container does: The getInstance method is called using the HelloWorldFactory class*/ @Test public void testCreateObject_StaticFactory(){ ApplicationContext context = new ClasspathxmlapplicationContext ("applicationContext.xml"); HelloWorld HelloWorld = (HelloWorld) Context.getBean ("HelloWorld2"); helloworld.hello (); }/** * Metode pabrik instan membuat objek * <bean id = "helloWorldfactory" *> </bean> * <bean id = "helloworld3"-factory-bean = "helloWorldfactory" factory-method = "getInstance"> </bean> Apa yang harus dilakukan di dalam petunjuk musim semi: 1. Objek HelloWorld*/ @test void public testCreateObject_instanceFactory () {applicationContext context = new ClassPathXMLapPlicationContext ("ApplicationContext.xml"); HelloWorld HelloWorld = (HelloWorld) Context.getBean ("HelloWorld3"); helloworld.hello (); }}2 ruang lingkup objek
Lingkup suatu objek memiliki dua properti: singleton dan prototipe. Singleton berarti singleton
2.1 singleton (nilai default)
Di setiap wadah IOC musim semi, hanya ada satu instance objek (dibagikan).
2.2 Prototipe
Memungkinkan kacang dipakai beberapa kali (membuat satu contoh sekali digunakan). Musim semi tidak dapat bertanggung jawab atas seluruh siklus hidup kacang prototipe. Ini berarti itu adalah tanggung jawab klien untuk lebih jelas tentang objek prototipe yang dilingkupi dan untuk membebaskan sumber daya mahal yang dipegang oleh kacang prototipe apa pun.
<bean id = "helloWorld" scope = "singleton"> </ bean>
<bean id = "helloWorld" scope = "prototipe"> </ bean>
Buat kelas HelloWorld
kelas publik helloWorld {daftar publik <string> daftar = arraylist baru <string> (); public helloWorld () {System.out.println ("Instance baru"); } public void hello () {System.out.println ("Hello"); }}Buat kelas uji Scopetest
Paket com.itheima10.spring.scope; impor org.junit.test; impor org.springframework.context.applicationContext; impor org.springframework.context.support.support* letakkan a clading a classmlication contextcontext; scopetest public { /** cluyspathx ke clading a ke clading a clayon ploping a clacing nofault; scopetest { /** classif a claser ** toing a claser fouldAnpLication Dalam wadah musim semi dan kelas ini adalah singleton, maka properti di kelas akan menjadi dibagikan*/ @test public void testCreateObject_scope_default () {applicationContext context = classpathxmlapplicationContext baru ("applicationContext.xml"); HelloWorld hello1 = (helloWorld) context.getBean ("helloWorld"); hello1.lists.add ("aaaa"); hello2 = (helloWorld) context.getBean ("helloWorld"); hello2.lists.add ("bbbb"); System.out.println (HelloWorld.lists.size ()); //2, and only output new instance } /** * If spring's configuration file is as follows: * <bean id="helloWorld" scope="prototype"></bean> Then the spring container will create multiple objects for */ @Test public void testCreateObject_Scope_Prototype(){ ApplicationContext context = new ClasspathxmlapplicationContext ("applicationContext.xml"); HelloWorld hello1 = (helloWorld) context.getBean ("helloWorld"); hello1.lists.add ("aaaa"); hello2 = (helloWorld) context.getBean ("helloWorld"); hello2.lists.add ("bbbb"); System.out.println (helloWorld.lists.size ()); // 1, dan hanya output instance baru}}3 waktu inisialisasi
Lazy Loading - Secara default, kacang akan diinisialisasi ketika wadah dimulai, tetapi kita dapat menentukan malas -init = "true" dari node kacang untuk menunda inisialisasi kacang. Pada saat ini, kacang akan diinisialisasi hanya jika kacang diambil untuk pertama kalinya. menyukai:
<bean id = "xxx" malas-init = "true"/>
Jika Anda ingin menerapkan inisialisasi tertunda untuk semua kacang, Anda dapat mengatur default-lazy-init = "true" di root bean, sebagai berikut:
<beans default-lazy-init = "true" ...>
Spring Instantiates semua kacang singleton terlebih dahulu saat startup secara default. Instantiasi awal berarti bahwa sebagai bagian dari inisialisasi, ApplicationContext secara otomatis membuat dan mengkonfigurasi semua kacang singleton. Ini biasanya hal yang baik. Karena dengan cara ini setiap kesalahan dalam konfigurasi dapat segera ditemukan.
Malas-init salah, Spring Container akan melaporkan kesalahan saat dimulai (cara yang lebih baik)
Malas-init itu benar, dan wadah musim semi akan membuat kesalahan saat memanggil kelas.
Konfigurasikan ApplicationContext.xml
<bean id = "helloWorld" scope = "prototipe"> </ bean> </tagel>
Buat kelas uji createObjectwhentest
Paket com.itheima10.spring.createObject.when; import org.junit.test; impor org.springframework.context.applicationContext; Impor org.springframework.context.support.classpathxMlapplicationContext; coughramework. Objek HelloWorld* 3. Metode Panggilan Objek** <bean id = "HelloWorld"> </tact> <bean id = "helloWorld2"> </tac> Karena dua kacang dinyatakan dalam wadah musim semi, kontainer musim semi perlu membuat dua objek: jika struts2, hibernate, dan kontainer musim semi akan diintegrasikan, jika sebuah kesalahan terjadi, jika ada kesalahan, hibernate, dan kontainer musim semi akan diintegrasikan, jika ada kesalahan, jika ada kesalahan. dan kesalahan akan ditampilkan sangat awal. Jika kacang menyimpan sejumlah besar data, metode ini tidak baik, dan data mungkin macet dalam memori terlalu dini. Jika kacang bukan singleton, tidak peduli bagaimana itu dikonfigurasi, objek harus dibuat ketika itu adalah context.getBean*/ @test public void testCreateObject_when_default () {applicationContext context = new classpathxmlappLicationContext ("applicationContext.xml"); Context.getBean ("HelloWorld"); } /*** <bean id = "helloWorld" malas-init = "true"> </ bean>* memesan* 1. Mulai wadah musim semi* 2. Context.getbean* 3. Hubungi fungsi konstruktor untuk membuat objek* Deskripsi: jika struts2, hibernate, wadah pegas diintegrasikan, jika kesalahan terjadi dalam file konfigurasi musim semi, sebuah konfigurasi musim semi, sebuah wadah wlar. Jika kacang menyimpan sejumlah besar data, perlu untuk memuat data saat diperlukan*/ @test public void testCreateObject_when_lazy () {applicationContext context = new ClassPathXMLapPlicationContext ("ApplicationContext.xml"); Context.getBean ("HelloWorld"); }}4 init, hancurkan metode
Saat musim semi menginisialisasi kacang atau menghancurkan kacang, beberapa pemrosesan kadang -kadang diperlukan, sehingga musim semi dapat memanggil dua metode siklus hidup kacang saat membuat dan membongkar kacang. Anda dapat menentukan metode untuk beroperasi.
<bean id = "foo" class = "... foo" init-method = "setup" dekorasi-metod = "robek"/>
Panggil metode init-metode saat FOO dimuat ke dalam wadah pegas. Metode Penyebaran Panggilan Saat Foo dihapus dari wadah (SCOPE = Singleton valid)
Menulis HelloWorld
kelas publik helloWorld {public helloWorld () {System.out.println ("new instance"); } public void init () {System.out.println ("init"); } public void dashar () {System.out.println ("Destroy"); } public void hello () {System.out.println ("Hello"); }}Tulis kelas tes initdestroytest
Paket com.itheima10.spring.ioc.initdestroy; impor org.junit.test; impor org.springframework.context.applicationContext; impor org.springframework.context.support.classpathxMlapplicationContext; 1. Mulai Kontainer Musim Semi* 2. Buat Objek HelloWorld* 3. Eksekusi Metode Init* Eksekusi Otomatis dalam Kontainer Musim Semi* 4. Metode Panggilan Objek* 5. Metode Destroy hanya dapat dieksekusi ketika Wadah Musim Semi ditutup: Kacang adalah singleton* Metode ini juga disebut secara internal oleh Container Spring Container* Deskripsi:* jika a bean bukan singlet, * Dalam wadah musim semi, hanya jika satu kacang adalah singleton, wadah musim semi bertanggung jawab atas pembuatan, inisialisasi, dan penghancuran objek* jika kacang bukan singleton, wadah musim semi hanya bertanggung jawab atas pembuatan dan inisialisasi* @test void public testinitDestroy () {ApplicationContext Context = classpathx publicmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmmml BAPPAXLAXEXT () {Applicationcontext Context = classpathx. HelloWorld HelloWorld = (HelloWorld) Context.getBean ("HelloWorld"); helloworld.hello (); ClassPathXMLapPLicationContext ApplicationContext = (ClassPathXMLapPLicationContext) konteks; applicationContext.close (); }} Diagram Urutan Eksekusi:
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.