Referensi sederhana untuk menggunakan Spring-IOC:
Analisis instance sederhana IOC musim semi dan atribut lingkup kacang
1. Suntikkan tipe data yang berbeda melalui metode yang ditetapkan
Kode kelas uji (properti yang disuntikkan dalam metode set harus ditambahkan dengan metode set)
/** Contoh Injeksi Melalui Metode Set*/Kelas Publik IOC_BY_SET {/** Parameter Jenis Integer Integer*/Private Integer ID;/** Suntikan Parameter Jenis String*/Nama String Pribadi;/** Suntikan Entity Bean*/Private User; atur;/** Suntikan peta pasang nilai kunci-kunci*/peta pribadi <objek, objek> peta;/** Jenis properti injeksi*/properti privat Properties;/** Suntikan string kosong*/string pribadi kosongvalue;/** Injeksi nilai null*/private string nullValue = "";/** Deteksi apakah semua properti null yang disuntikkan = nullvalue = "";/*deteksi apakah semua properti null yang disuntikkan = nullvalue = "";/deteksi apakah semua properti null yang disuntikkan publikasi false;} else {system.out.println ("id:" + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- array) {System.out.println(object.toString());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println ("Set:"); untuk (objek objek: set) {System.out.println (Object.toString ());}} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- {System.out.println (entry.getKey () + "|" + entry.getValue());}}System.out.println("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- entri.getValue ());}} System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- setName(String name) {this.name = name;}public void setUser(User user) {this.user = user;}public void setArray(Object[] array) {this.array = array;}public void setList(List<Object> list) {this.list = list;}public void setSet(Set<Object> set) {this.set = set;}public void setMap (peta <object, object> peta) {this.map = peta;} public void setProperties (properti properti) {this.properties = properties;} public void setemptyValue (String emplemAlvalue) {this.emptyValue = emplemuale;} public void publvalue (string norlvalue ({{{} publvalue {{{{{{{{{{{nolvalue {{{{{nolvalue {{{nol {{nol {{nol {{{nol {{{nol {{{nol {{{nol {{{public noluch. nullvalue;}}Konfigurasi ApplicationContext.xml
<!-Setel injeksi-> <bean id = "ioc_by_set"> <!-atribut ID injeksi-> <name properti = "id" value = "1"/> <!-menggunakan <!-menangani karakter khusus XML dengan <!-menggunakan <! [Cdata []]> Tag ---> <nama properti = "nama"> <!-Anda dapat menggunakan p & g & g &-> <Properti Nama = "Nama"> <!-Anda dapat menggunakan p & g & g & G-> <Property Name = "Name"> <!-Anda dapat menggunakan P & <value> <! [cdata [p & g]]> </ value> </propt> <!-mendefinisikan injeksi kacang internal-> <nama properti = "user"> <bean> <name properti = "id" value = "1"/> <name properti =-"name" value = "nean" </</</<property name = "name" value "233" 233 " name="array"> <array> <!-- Define array elements--> <value>array01</value> <value>array02</value> <value>array03</value> </array> </property> <!-- Inject List type--> <property name="list"> <list> <!-- Define elements in list--> <value>list01</value> <value>list02</value> <value> list03 </ value> </list> </propt> <!-inject set type-> <property> <Property --- Tentukan elemen dalam daftar-> <value> list02 </ value> <value> list03 </value> </list> </prope> <!-type set-suntikan-> <nama properti = "set"> </list> </properti> <! <value>set02</value> <value>set03</value> </set> </property> <!-- Inject Map type--> <property name="map"> <map> <!-- Define key-value pairs in map --> <entry> <key> <value>mapKey01</value> </key> <value>mapValue01</value> </entry> <entry> <key> <value> mapKey02 </value> </yyy> <value> mapValue02 </ value> </dert> </peta> </propert> <!-Suntikan tipe properti-> <nama properti = "properti"> <props> <!-mendefinisikan pasangan key-props = "propsy =" propkey = "propkey1> propvale1 </propval2 </" propsy = "Propkey =" Propkey = "Propkey =" Propkey1 </propvy = "Propkey =" Propkey = "Propkey1 </propvy =" Propkey = "Propkey =" Propkey1 </"Propsy =" propve- "propval =" Propkey = "Propkey1 </" propve- props = "Propkey1> Propkey1> Propvale1 </propvale </" Propky1> </sops> </propt> <!-Suntikkan string kosong-> <name properti = "emplemuale"> <value> </value> </property> <!-menyuntikkan nilai null-> <name properti = "nullvalue"> <null/> </propert> </bean>
Kode uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext new classpathxmlApplicationContext ("iocontext.xml");}@uji public void Settest () {iocontext.xml ");}@public void public void () {iocontext.set.xml");}@public void public void () {iocontext.sete ");}@public void public void () {IOContext.set ctx.getBean ("ioc_by_set"); ioc.checkattr ();}}Hasil konsol:
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 3 ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Lai Lai
2. Suntikkan berbagai jenis atribut melalui metode konstruksi
CATATAN: Saat menggunakan versi JDK1.8, silakan tingkatkan paket JAR terkait Spring ke versi 4.x atau di atas, jika tidak, konstruktor yang tidak kompatibel akan disuntikkan.
Kode kelas uji
/** Contoh injeksi melalui konstruktor*/kelas publik IOC_by_constructor {private integer ID; nama string pribadi; pengguna privat pengguna; daftar pribadi <Peject> Daftar; ioc_by_constructor () {} public ioc_by_constructor (integer ID, nama string, pengguna, daftar <Object> {this. Daftar;}/** Periksa apakah injeksi berhasil*/public boolean checkattr () {if (id == null) {return false;} else {system.out.println ("id:" + + + id);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- + "|" user.getPassword ());} System.out.println ("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- BENAR;}}Konfigurasi ApplicationContext.xml
<!-Nilai konstruktor-arg = "p & g"/> <!-objek injeksi-> <bean id = "ioc_by_constructor"> <!-objek injeksi-> <bean> <konstruktor-arg value = "1" type = "java.Lang.Integer"/<!-string injeksi-> "nilai------p &" GOP "<! <Constructor-Arg> <!-Objek built-in-> <bean> <konstruktor-arg value = "1"/> <konstruktor-arg value = "konstruksi kacang internal"/> <konstruktor-arg value = "666"/</value> </value> </value </list.> <! <value> list03 </ value> </cist> </constructor-arg> </tean>
Kode Uji:
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext new classpathxmlApplicationContext ("iocontext.xml");}@uji public void publicortest () {iocontext.xml "); ctx.getBean ("IOC_BY_CONSTRUCT"); ioc.checkattr ();}}Hasil konsol:
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Lai Lai
3. Injeksi Otomatis (Perakitan Otomatis)
Meskipun perakitan otomatis dapat menyimpan beberapa kode, tidak disarankan untuk menggunakannya
Kode kelas tes:
/** Injeksi perakitan otomatis*/kelas publik IOC_BY_AUTO {pengguna privat pengguna;/** Periksa apakah injeksi berhasil*/public boolean checkattr () {if (user == null) {return false;} else {System.out.println ("user:" + user.getid () + " +" + User.out.out.println ("User:" + User.getid () + " +" + User. user.getPassword ());} System.out.println ("Benar !!!"); return true;}/** Atribut perakitan otomatis memerlukan pengaturan metode set*/public void setuser (pengguna pengguna) {this.user = user;}}Konfigurasi ApplicationContext.xml
<!-- Beans obtained by automatic assembly --> <bean id="user"> <property name="id" value="1"/> <property name="userName" value="auto-assembly"/> <property name="passWord" value="233"/> </bean> <!-- Bean autowire:byName Autowire:byName According to the property name of the class, find the only bean of matching type according to the property jenis kelas. Jika beberapa kacang cocok, lempar konstruktor pengecualian cocok dengan kacang yang sesuai sesuai dengan jenis parameter konstruktor kelas. No. Default, berarti bahwa Default Assembly Otomatis tidak digunakan: ditentukan oleh properti Autowire default dari label atas <Baci>-> <bean id = "ioc_by_auto" autowire = "byname"> </ bean>
Kode uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext new classpathxmlApplicationContext ("iocontext.xml");}@uji public void autotest () {iocontext.xml ");}@public void autotest () {iocontext.xml"); ctx.getBean ("IOC_BY_AUTO"); ioc.checkattr ();}}Hasil konsol
Pengguna: 1 | Perakitan Otomatis | 233 benar! Lai Lai
Di atas menggunakan mode byname. Kode konfigurasi mode lain telah ditunjukkan dan tidak ada pengujian yang dilakukan.
4. Suntikan atribut menggunakan p namespace
Kode kelas uji
/** Injeksi menggunakan p namespace*/kelas publik ioc_by_p {private integer id; nama string pribadi; pengguna pengguna pribadi;/** Periksa apakah injeksi berhasil*/public boolean checkAttr () {if (id == null) {return false;} else {system.out.println ("id:" + + id);}System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nama string) {this.name = name;} public void setUser (pengguna pengguna) {this.user = user;}}Konfigurasi ApplicationContext.xml
<!-- Inject various types of properties using the P namespace--> <bean id="user2"> <property name="id" value="1"/> <property name="userName" value="P"/> <property name="passWord" value="233"/> </bean> <bean id="ioC_By_P" p:id="1" p:name="namespace" P: User-Ref = "user2"> </bean>
Kode uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext baru (ioc_by_pl ");@@@@publiclication void ptest () {iocontext.xml");}@public void ptest () {iocontext.xml ");}@public void ptest () {iocontext.xml");}@public void ptest () {iocontext.xml "); ctx.getBean ("ioc_by_p"); ioc.checkattr ();}}Hasil konsol
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Lai Lai
5. Suntikkan Menggunakan Metode Anotasi
Spring telah memberikan injeksi berbasis anotasi setelah 3.0.
1.@Autowired-anotasi variabel anggota, metode dan konstruktor untuk menyelesaikan pekerjaan perakitan otomatis. Tidak disarankan untuk menggunakannya.
2. @Qualifier-Combined dengan @Autowired untuk menyelesaikan perakitan beberapa kacang dari jenis yang sama
3. @Resource-JSR-250 Anotasi Standar, Fungsinya setara dengan @Autowired, tetapi @Autowired secara otomatis disuntikkan sesuai dengan bytype, sedangkan @Resource secara otomatis disuntikkan sesuai nama byne secara default.
4. @PostConstruct - Tambahkan anotasi @postconstruct ke metode ini, dan metode ini akan dieksekusi oleh wadah musim semi setelah kacang diinisialisasi.
5. @Predestroy-Add Annotation @predestroy pada metode ini, metode ini akan dieksekusi oleh wadah musim semi setelah kacang diinisialisasi.
6. @Komponen saja Tambahkan anotasi @Component ke kelas yang sesuai, kelas didefinisikan sebagai kacang. Tidak disarankan untuk menggunakannya. Disarankan untuk menggunakan tiga jenis yang lebih halus: @Repository, @Service, @Controller
@Repository Storage Layer Bean
@Service Business Layer Bean
@Controller Display Layer Bean
7.@SCOPE Tentukan ruang lingkup kacang
Pertama kali konfigurasi applicationContext.xml untuk mengaktifkan anotasi
<!-Pindai kelas beranotasi dalam paket-> <Context: Component-Scan Base-package = "com.bc.ioc.demo05"/>
Anotasi entitas kacang
@RepositoryPublic Class pengguna {private integer id = 1; private string username = "annotation injection"; private string password = "233"; User publik () {super ();} pengguna publik (ID integer, string username, string kata sandi) {super (); this.id = id; this.username = Username; ini. id;} string publik getUserName () {return username;} public string getPassword () {return kata sandi;} public void setId (integer id) {this.id = id;} public void setusername (string userName) {this.userName = username;} public void setPassword (string string) {this.userName = username;} public void setPassword (string string) {this.userName = username;} public void setPassword (string string) {this.userName = username;} public void setPassword (string string stundAnotasi Kode Kelas Uji
/** Suntikan atribut menggunakan anotasi*/@service ("ioc_by_annotation") kelas publik ioc_by_annotation {@resource pengguna privat pengguna; public void setuser (pengguna pengguna) {this.user = user;}/** Periksa apakah injeksi tidak berhasil*/public boolean checkattr () {if {ifor = {System.out.println ("user:" + user.getId () + "|" + user.getUserName () + "|" + user.getPassword ());} System.out.println ("Benar !!!"); return true;}}Kode uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext new classpathxmlApplicationContext ("iocontext.xml");}@uji public annotationTest () {iocontext.xml ");}@public void public annotationTest () {iocontext.xml"); ctx.getBean ("ioc_by_annotation"); ioc.checkattr ();}}Output konsol
Setelah pengujian, menggunakan injeksi anotasi. Jika ApplicationContext.xml dikonfigurasi dengan metode injeksi lainnya, kesalahan akan dilaporkan, yang juga akan menyebabkan metode injeksi lainnya abnormal.
Pengguna: 1 | Injeksi Anotasi | 233 benar! Lai Lai
6. Injeksi kacang dengan mengonfigurasi metode pabrik statis
Kode pabrik statis
/** Pabrik Statis*/Kelas Publik StaticFactory {public static integer getId () {return 1;} public static string getName () {return "static factory";} pengguna statis public getUser () {return baru pengguna (1, "pengguna pabrik", "666");}}Kode kelas uji
/** Injeksi melalui pabrik statis*/kelas publik IOC_BY_STATICFACTORY {private integer ID; nama string pribadi; pengguna pengguna pribadi;/** Periksa apakah injeksi berhasil*/public boolean checkAttr () {if (id == null) {return false;} else {System.out.println ("id:" id);}System.out.println("---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nama string) {this.name = name;} public void setUser (pengguna pengguna) {this.user = user;}}Konfigurasi ApplicationContext.xml
<!-Mengkonfigurasi Metode Pabrik Statis Bean sebenarnya mengkonfigurasi nilai yang dikembalikan dengan metode pabrik sebagai kacang-> <bean id = "factory_id" factory-method = "getid"/> <bean id = "factory_name" factory-method = "getName"/<bean id = "factory_user" factory-method = "getname"/<bean id = "factory_user" factory-method = "getname"/<bean id = "factory_user" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory" factory "factory id = "ioc_by_staticfactory"> <name properti = "id" ref = "factory_id"/> <name properti = "name" ref = "factory_name"/> <nama properti = "pengguna" ref = "factory_user"/> </bean>
Kode uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext@iContexty ()@IOCOCORY ()@IOCOCORY () {staticfactory () {IOCOCORY () {IOCOCORY)@ ctx.getBean ("IOC_BY_STATICFACTORY"); ioc.checkattr ();}}Hasil output konsol
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Lai Lai
7. Injeksi melalui contoh metode pabrik
Perbedaan dari pabrik statis adalah bahwa pabrik instan tidak statis. Anda harus pertama -tama objek pabrik baru sebelum Anda dapat mengonfigurasi metodenya. Objek baru juga dikelola oleh Spring.
Kode pabrik
/** Factory Instan*/Public Class Factory {Public Integer getId () {return 1;} public String getName () {return "instance factory";} pengguna publik getUser () {return baru pengguna (1, "instance factory user", "233");}}Kode kelas uji
/** Instance Factory Injection*/kelas publik IOC_BY_FACTORY {private integer ID; nama string pribadi; pengguna pengguna privat;/** Periksa apakah injeksi berhasil*/public boolean checkAttr () {if (id == null) {return false;} else {system.out.println ("id:" + id);}System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- name);} System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- id) {this.id = id;} public void setName (nama string) {this.name = name;} public void setUser (pengguna pengguna) {this.user = user;}}Konfigurasi ApplicationContext.xml
<!-Mengkonfigurasi instance factory bean-> <bean id = "factory"/> <!-Mengkonfigurasi metode instance Metode Bean-> <bean id = "f_id" factory-bean = "factory" factory-method = "getid"/<bean id = "f_name" factory-bean = "factory" factory "factory" factory "factory" factory "factory" factory " Factory-bean = "pabrik"-metod = "getUser"/> <!-menyuntikkan metode instance Metode Factory yang sesuai-> <bean id = "IOC_BY_FACTORY"> <nama properti = "id" ref = "f_id"/> <name property = "f_name"/> <nama properti = "REG =" F_NAME "/<" REG = "F_NAME"/<"REG"/AMERE "/F_NAME"
Kode kelas uji
kelas publik IOC_TEST {private applicationContext ctx; @Before public void load () {// baca applicationContext.xml file konfigurasi ctx = classpathxmlApplicationContext baru@iCocory (iocoCory_facory (ICoCory@ICOCORY () {IOOC_FACORY ") ctx.getbean ("ioc_by_factory"); ioc.checkattr ();}}Output konsol
ID: 1 --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- Lai Lai
Meringkaskan
Di atas adalah semua tentang artikel ini yang membahas metode injeksi IOC musim semi dan menyuntikkan tipe data yang berbeda. Saya harap ini akan membantu semua orang. Teman yang tertarik dapat terus merujuk ke topik terkait lainnya di situs ini. Jika ada kekurangan, silakan tinggalkan pesan untuk menunjukkannya. Terima kasih teman atas dukungan Anda untuk situs ini!