1. ภาพรวมการกำหนดค่าสปริง
1.1. ภาพรวม
สปริงคอนเทนเนอร์อ่านข้อมูลการกำหนดค่าถั่วจากการกำหนดค่า XML, คำอธิบายประกอบ Java และคำอธิบายประกอบสปริงเพื่อสร้างรีจิสทรีนิยามถั่ว
กำหนดรีจิสทรีเพื่อสร้างอินสแตนซ์ถั่วตามถั่ว;
ใส่อินสแตนซ์ถั่วลงในสระแคชถั่ว
แอปพลิเคชันใช้ถั่ว
1.2. การกำหนดค่าที่ใช้ XML
(1) ภาพรวมของไฟล์ XML
XMLNS ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
XMLNS: XSI ------------ เนมสเปซมาตรฐานใช้เพื่อระบุไฟล์สคีมาของเนมสเปซแบบกำหนดเอง
xmlns: xxx = "aaaaa" ------------ custom namespace, xxx เป็นนามแฝงและค่าต่อไปนี้ AAAA เป็นชื่อเต็ม
XSI: Schemalocation -------- ระบุไฟล์สคีมาเฉพาะสำหรับแต่ละเนมสเปซรูปแบบ: ที่อยู่ไฟล์ชื่อเต็มเนมสเปซ - - แยกออกจากกัน
2. การกำหนดค่าถั่วขั้นพื้นฐาน
2.1. การตั้งชื่อถั่ว
(1) ทั้ง ID และชื่อสามารถระบุชื่อหลายชื่อและชื่อจะถูกคั่นด้วยเครื่องหมายจุลภาคเครื่องหมายอัฒภาคหรือช่องว่าง
<beanname = "#car, 123, $ car" class = "xxxxxxxxxx">
ผู้ใช้สามารถใช้ GetBean ("#Car"), GetBean ("123"), GetBean ("$ Car") เพื่อ GetBean
(2) หากไม่มีการระบุรหัสและชื่อสปริงจะใช้ชื่อที่ผ่านการรับรองโดยอัตโนมัติของคลาสเป็นชื่อของถั่วโดยอัตโนมัติ
(3) หากมีถั่วที่ไม่ระบุชื่อหลายตัวนั่นคือไม่มี <ถั่ว/> ที่มี ID และชื่อที่ระบุโดยสมมติว่าชื่อที่ผ่านการรับรองของคลาสคือ xxx
จากนั้นรับถั่วตัวแรกโดยใช้ getBean ("xxx") รับถั่วตัวที่สองโดยใช้ getBean ("xxx#1") รับถั่วตัวที่สามโดยใช้ getBean ("xxx#2")
3. การฉีดพึ่งพา
3.1. การฉีดแอตทริบิวต์
(1) การฉีดแอตทริบิวต์ต้องใช้ถั่วเพื่อให้ตัวสร้างเริ่มต้นและให้วิธีการตั้งค่าสำหรับแอตทริบิวต์ที่ต้องฉีด สปริงเรียกตัวสร้างเริ่มต้นเพื่อสร้างอินสแตนซ์วัตถุถั่วจากนั้นเรียกใช้เมธอด Setter เพื่อฉีดค่าคุณสมบัติผ่านการสะท้อนกลับ
(2) สปริงจะตรวจสอบว่ามีวิธีการตั้งค่าที่สอดคล้องกันในถั่วหรือไม่และจะไม่มีข้อกำหนดใด ๆ ที่จะทำว่ามีตัวแปรแอตทริบิวต์ที่สอดคล้องกันในถั่วหรือไม่
(3) ข้อกำหนดพิเศษของ Javabean สำหรับการตั้งชื่อแอตทริบิวต์: ตัวอักษร 2 ตัวแรกของตัวแปรเป็นตัวพิมพ์ใหญ่ทั้งหมดหรือตัวพิมพ์เล็กทั้งหมด
3.2. การฉีด
(1) ลำดับการกำหนดค่าของพารามิเตอร์ตัวสร้างจะไม่ส่งผลกระทบต่อผลลัพธ์การกำหนดค่า ไฟล์การกำหนดค่าของสปริงใช้นโยบายที่ไม่เกี่ยวข้องกับลำดับของป้ายกำกับ กลยุทธ์นี้สามารถมั่นใจได้ถึงความแน่นอนของข้อมูลการกำหนดค่าในระดับหนึ่ง
(2) การจับคู่พารามิเตอร์โดยดัชนี
หากประเภทพารามิเตอร์รายการของตัวสร้างนั้นเหมือนกันคุณจะต้องระบุดัชนีตามลำดับของพารามิเตอร์มิฉะนั้นจะไม่สามารถกำหนดความสัมพันธ์ที่สอดคล้องกันได้ ชอบ:
<constructor-argindex = "0" value = "xxxxxx"> <constructor-argindex = "1" value = "xxxxxx">
ดัชนีเริ่มต้นที่ 0
(3) ปัญหาการพึ่งพาเป็นวงกลม
หากการกำหนดค่าตัวสร้างของ 2 ถั่วขึ้นอยู่กับอีกฝ่ายปัญหาการหยุดชะงักของเธรดจะเกิดขึ้น
วิธีแก้ปัญหาคือการเปลี่ยนการฉีดคอนสตรัคเตอร์เป็นการฉีดแอตทริบิวต์
3.3. วิธีการฉีดยาจากโรงงาน
(1) วิธีการไม่คงที่จากโรงงาน
เนื่องจากวิธีการโรงงานไม่คงที่คุณต้องสร้างถั่วอินสแตนซ์ของคลาสโรงงานและใช้ถั่วโรงงานเพื่ออ้างอิง
<beanid = "carfactory" class = "คลาสโรงงาน"/> <beanid = "car5" โรงงานถั่ว = "carfactory" โรงงาน-วิธี = "createCar"/>>>
(2) วิธีโรงงานคงที่
<beanid = "car5" class = "คลาสโรงงาน" โรงงาน-วิธี = "createCar"/>>>>>>>>
3.4. คำอธิบายโดยละเอียดของพารามิเตอร์การฉีด
(1) 5 อักขระพิเศษใน XML
| สัญลักษณ์พิเศษ | ลำดับหลบหนี | สัญลักษณ์พิเศษ | ลำดับหลบหนี |
| - | - | - | |
| - | - | - | - |
| - | - |
(2) <! [cdata []]>
จุดประสงค์ของ <! [cdata []]> คือการปล่อยให้ตัวแยกวิเคราะห์ XML ปฏิบัติต่อสตริงในแท็กเป็นข้อความปกติ
(3) ฉีดค่าว่างโดยใช้แท็ก <null/>
(4) คุณลักษณะการเรียงซ้อน
<beanid = "parent" class = "xxxxxxx"> <propertyName = "child.xxx" value = "ค่าคุณสมบัติของวัตถุการพึ่งพา"/> </ebean>
ก่อน Spring3.0 เด็กวัตถุที่พึ่งพาจะต้องได้รับการสร้างอินสแตนซ์ก่อนมิฉะนั้นจะมีข้อยกเว้นจะถูกโยนลงไป หลังจาก Spring3.0 ไม่จำเป็นต้องแสดงอินสแตนซ์ คอนเทนเนอร์สปริงจะยกตัวอย่างวัตถุการพึ่งพาโดยอัตโนมัติ
(5) การรวมคอลเลกชัน
<setMerge = "true"/>
ใช้กันทั่วไปในคลาสย่อยเพื่อรวมองค์ประกอบการรวบรวมของคลาสแม่
(6) กำหนดค่าถั่วประเภทคอลเลกชันผ่านทางเนมสเปซ UTIL
หากคุณต้องการกำหนดค่าถั่วประเภทคอลเลกชันแทนคุณสมบัติประเภทคอลเลกชันคุณสามารถกำหนดค่าผ่านทางเนมสเปซ UTIL
3.5. แอสเซมบลีอัตโนมัติ
(1) องค์ประกอบ <bean/> ให้คุณลักษณะที่ระบุประเภท AutoWire
3.6. วิธีการฉีด
หากเราฉีดถั่วต้นแบบลงในถั่วโหมดซิงเกิลและหวังว่าจะคืนถั่วใหม่ทุกครั้งที่เราเรียกมันว่ามันจะเป็นไปไม่ได้ที่จะใช้วิธีการฉีดแบบดั้งเดิมเนื่องจากการกระทำของถั่วโหมดซิงเกิลที่ฉีดถั่วที่เกี่ยวข้องเกิดขึ้นเพียงครั้งเดียว
(1) โซลูชันเสริมคือการเปิดใช้งาน Host Bean เพื่อใช้งานอินเตอร์เฟส BeanFactoryAware เพื่อให้โฮสต์ถั่วสามารถเข้าถึงการอ้างอิงของคอนเทนเนอร์เพื่อให้สามารถแก้ไขวิธี GET และคอนเทนเนอร์ได้
วิธีการเป็น Factory.getBean ("ถั่วที่ขึ้นอยู่กับ") คุณสามารถรับถั่วล่าสุดได้ทุกครั้ง
(2) วิธีการข้างต้นเป็นคู่รหัสและสปริงของเราซึ่งเป็นวิธีที่เลวร้ายที่สุดในการทำและเราสามารถแยกผ่านวิธีการฉีด
เราจำเป็นต้องกำหนดอินเทอร์เฟซและกำหนดวิธีนามธรรมเพื่อให้ได้ถั่วขึ้นอยู่กับอินเตอร์เฟส การกำหนดค่าสปริงมีดังนี้:
<beanid = "car" class = "ถั่วที่ขึ้นอยู่กับ"/> <beanid = "โฮสต์" class = "อินเตอร์เฟสถั่ว"> <lookup-methodname = "getCar" bean = "car"/> </epean>
แท็กองค์ประกอบการค้นหาวิธีการให้การใช้งานแบบไดนามิกสำหรับ getCar () ของถั่วอินเตอร์เฟส การใช้วิธีการฉีดส่วนใหญ่ขึ้นอยู่กับการทำงานแบบไดนามิกเทคโนโลยีไบต์ของแพ็คเกจ CGLIB
3.7. การเปลี่ยนวิธีการ
ใช้ bean2 เพื่อแทนที่วิธี GetCar ของ Bean1 โดยที่ Bean2 ต้องใช้อินเตอร์เฟส MethodReplacer และการกำหนดค่ามีดังนี้:
<beanid = "bean1" class = "aaaaaaaaa"> <แทนที่-methodname = "getCar" replacer = "bean2"/> </ebean>
4. ความสัมพันธ์ระหว่าง <ebean>
4.1. มรดก
การกำหนดค่าของถั่วแม่สามารถสืบทอดได้โดยคลาสย่อยเพื่อหลีกเลี่ยงคำจำกัดความซ้ำ ๆ การกำหนดค่ามีดังนี้:
<beanid = "Bean Bean" class = "aaaaa" Abstract = "true"/> <beanid = "child bean" class = "bbbbbb">>> <beanid = "child bean"
คลาสย่อยสามารถแทนที่การกำหนดค่าของคลาสแม่ หากไม่ได้ระบุ abstract = "true" ของคลาสแม่แม่ถั่วแม่จะถูกสร้างอินสแตนซ์
4.2. การพึ่งพาอาศัยกัน
ถั่วบางตัวขึ้นอยู่กับถั่วอื่น ๆ และถั่วอื่น ๆ จะต้องได้รับการยกตัวอย่างก่อนที่พวกเขาจะสามารถสร้างอินสแตนซ์ถั่วโฮสต์ ฤดูใบไม้ผลิให้คุณลักษณะขึ้นอยู่กับและระบุว่าถั่วพึ่งพาเป็นอินสแตนซ์ก่อนเช่น:
<beanid = "host" class = "aaaaaa" ขึ้นอยู่กับ = "b1"/> <beanid = "b1" class = "bbbbbbbbbbbbbbbbbb
หากมีถั่วพึ่งพาอาศัยกันหลายครั้งคุณสามารถสร้างชื่อของถั่วโดยเครื่องหมายจุลภาคช่องว่างหรือเครื่องหมายอัฒภาค
4.3. ขอบเขตถั่ว
(1) คอนเทนเนอร์สปริงจะยกตัวอย่างถั่วทั้งหมดเมื่อเริ่มต้น หากคุณไม่ต้องการสร้างอินสแตนซ์ล่วงหน้าคุณสมบัติ Lazy-init = "true" ของ <ถั่ว/> สามารถควบคุมการสร้างอินสแตนซ์ล่าช้าได้ แต่ถ้าถั่วถูกอ้างอิงโดยถั่วอื่น ๆ ที่ต้องมีการสร้างอินสแตนซ์ล่วงหน้าสปริงก็จะเพิกเฉยต่อการตั้งค่าอินสแตนซ์ล่าช้า
(2) ขอบเขตที่เกี่ยวข้องกับเว็บแอปพลิเคชัน
หากผู้ใช้ใช้ขอบเขตการร้องขอเซสชันและ Globalsession ต้องทำการกำหนดค่าเพิ่มเติมในเว็บคอนเทนเนอร์ก่อน:
ในคอนเทนเนอร์เว็บเวอร์ชันที่ต่ำกว่า (ก่อน Servlet 2.3) คุณสามารถใช้การกำหนดค่าตัวกรองคำขอ HTTP:
<silter> <filter-Name> requestContextFilter </filter-Name> <filter-Class> org.springframework.web.filter.requestContextFilter </filter-class> </filter> <filter-mapping>
ในคอนเทนเนอร์เว็บเวอร์ชันที่สูงขึ้นคุณสามารถใช้ตัวฟังคำขอ HTTP เพื่อกำหนดค่า:
<Sistener> <Sistener-Lass> org.springframework.web.context.request.requestcontextListener </listener-class> </listener>
(3) ปัญหาการพึ่งพาขอบเขต
เมื่อฉีดถั่วบนเว็บลงในถั่วหรือต้นแบบให้ใช้ AOP ตัวอย่างเช่น:
<bean id = "web1" scope = "คำขอ"> <aop: scoped-proxy/> </ebean> <bean id = "singleton1"> <property name = "z1" ref = "web1"/> </epean>
4.4. โรงงาน
โดยทั่วไปแล้วสปริงใช้แอตทริบิวต์คลาสของ <ถั่ว/> เพื่อระบุถั่วอินสแตนซ์คลาสการใช้งานผ่านกลไกการสะท้อนกลับ แต่ในบางกรณีกระบวนการของการสร้างอินสแตนซ์ถั่วนั้นซับซ้อนกว่า หากในแบบดั้งเดิมจำเป็นต้องมีข้อมูลการกำหนดค่าจำนวนมากใน <ถั่ว> ความยืดหยุ่นของวิธีการกำหนดค่ามี จำกัด และอาจได้รับการแก้ปัญหาอย่างง่ายโดยใช้วิธีการเข้ารหัส
ฤดูใบไม้ผลิให้บริการ org.springframework.beans.factory.factorybean อินเตอร์เฟสคลาสโรงงานสำหรับสิ่งนี้และผู้ใช้สามารถปรับแต่งตรรกะของถั่วอินสแตนซ์โดยใช้อินเทอร์เฟซนี้
เมื่อคลาสการใช้งานที่กำหนดค่าโดยแอตทริบิวต์คลาสของ <ถั่ว/> คือโรงงานและคลาสย่อยของมันการกลับมาของวิธีการเป็นโรงงาน () ไม่ได้ส่งคืนโรงงานเบียนและคลาสย่อยของตัวเอง
หากคุณต้องการได้รับวัตถุของโรงงานเบียนและคลาสย่อยของตัวเองให้นำหน้า beanname ด้วยคำนำหน้า "&" เช่น Getbean ("& Car5") เมื่อวิธี Getbean (Beanname)
5. การกำหนดค่าตามคำอธิบายประกอบ
5.1. ประเภทคำอธิบายประกอบ
@component ----- คำอธิบายประกอบดั้งเดิม
คำอธิบายประกอบอนุพันธ์:
@Repository: Annotate Dao
@Service: บริการฉลาก
@Controller: คอนโทรลเลอร์คำอธิบายประกอบ
5.2. ใช้ข้อมูลการกำหนดค่าคำอธิบายประกอบเพื่อเริ่มคอนเทนเนอร์สปริง
(1) หลังจากฤดูใบไม้ผลิ 2.5 มีการแนะนำเนมสเปซบริบทซึ่งให้การประยุกต์ใช้คำอธิบายประกอบเพื่อกำหนดถั่วโดยการสแกนแพ็คเกจชั้นเรียน:
<บริบท: Component-Scan base-package = "XXXXXXXXXX" Resource-Pattern = "xxxx/*. class">>
แอตทริบิวต์รูปแบบทรัพยากรใช้เพื่อระบุคลาสภายใต้แพ็คเกจเฉพาะที่ต้องสแกนในแพ็คเกจพื้นฐาน
(2) มีป้ายย่อยตัวกรองที่ทรงพลังกว่า
<บริบท: Component-Scan base-package = "xxxxxxxxxx"> <บริบท: include-filter type = "xxxx" expression = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxX
ในทุกประเภทความสามารถในการกรองของ AspectJ นั้นทรงพลังที่สุด
5.3. การประกอบถั่วอัตโนมัติ
(1) @autowired
@autowired จับคู่ตามพิมพ์ตามค่าเริ่มต้น หากไม่มีถั่วจับคู่ในคอนเทนเนอร์ข้อยกเว้นจะถูกโยนลงเมื่อคอนเทนเนอร์สปริงเริ่ม คุณสามารถใช้ @autowired (จำเป็น = false) สำหรับคำอธิบายประกอบและจะไม่มีข้อยกเว้นใด ๆ
ใช้ @autowired เพื่อใส่คำอธิบายประกอบพารามิเตอร์วิธีการโดยตรง หากวิธีการมีพารามิเตอร์หลายตัวโดยค่าเริ่มต้นสปริงจะเลือกถั่วโดยอัตโนมัติที่ตรงกับประเภทพารามิเตอร์สำหรับการฉีด
การใช้คำอธิบายประกอบ @autowired ของตัวแปรคอลเลกชันคุณสามารถฉีดถั่วทั้งหมดที่ตรงกับประเภทองค์ประกอบของคอลเลกชันซึ่งมีประสิทธิภาพมาก
การใช้คุณสมบัติ @Autowired Assembler ไม่มีวิธีการตั้งค่า
(2) @qualifiler
หากมีถั่วที่ตรงกันมากกว่าหนึ่งตัวในคอนเทนเนอร์ชื่อของถั่วสามารถผ่านการรับรองโดยคำอธิบายประกอบ @qualifiler
(3) การสนับสนุนการทำเครื่องหมายและคำอธิบายประกอบ
ฤดูใบไม้ผลิยังรองรับ @Resource ที่กำหนดโดย JSR-250 และ @Inject Annotations ที่กำหนดโดย JSR-330
@Resource ต้องการให้มีการจัดหาแอตทริบิวต์ของถั่ว หากแอตทริบิวต์ว่างเปล่าชื่อตัวแปรหรือชื่อวิธีจะถูกใช้โดยอัตโนมัติเป็นชื่อของถั่ว
(4) ประเด็นสำคัญ:
หากคุณใช้ @autowired เท่านั้นเรายังต้องกำหนดโหนด <ถั่ว/> ใน XML อย่างชัดเจน คอนเทนเนอร์สปริงปิดการใช้งานแอสเซมบลีคำอธิบายประกอบโดยค่าเริ่มต้น วิธีการเปิดใช้งานคือการกำหนดค่า <บริบท: องค์ประกอบคำอธิบายประกอบ/>>>> ใน XML
แต่ฤดูใบไม้ผลิก็มีเคล็ดลับอีกอย่าง การใช้องค์ประกอบ <context: Component-Scan/> Container สปริงจะตรวจจับถั่วโดยอัตโนมัติโดยไม่ต้องกำหนดโหนด <ถั่ว/> อย่างชัดเจน
สปริงหมายเหตุประกอบคลาสคำอธิบายประกอบผ่าน @Component, @Repository, @Service และ @Controller ดังนั้น <บริบท: Component-Scan/> รู้ว่าคลาสใดที่ต้องลงทะเบียนเป็น SpringBean
หากคุณใช้แพ็คเกจ JAR ของบุคคลที่สามและคุณต้องการฉีดคลาสโดยอัตโนมัติในแพ็คเกจ JAR ของบุคคลที่สามแม้ว่าแพ็คเกจ JAR ของบุคคลที่สามจะไม่ใส่คำอธิบายประกอบด้วยคำอธิบายประกอบองค์ประกอบตัวกรอง <บริบท: รวมตัวกรอง> สามารถแทนที่นโยบายการสแกนนิพจน์ที่ใช้คำอธิบายประกอบ
5.4. ขอบเขตของการกระทำและวิธีการใช้ชีวิตของถั่ว
(1) @Scope ("xxxx")
ช่วงเริ่มต้นของถั่วที่กำหนดค่าโดยคำอธิบายประกอบคือซิงเกิลตัน
ฤดูใบไม้ผลิมีคำอธิบายประกอบ @Scope เมื่อพูดถึงคลาสพารามิเตอร์คำอธิบายประกอบจะเหมือนกับค่าของแอตทริบิวต์ขอบเขตใน XML
(2) การเปรียบเทียบวิธีกระบวนการชีวิต
| <ถั่ว> | คำอธิบายประกอบ |
| ผู้เริ่มต้น | @PostConstruct |
| วิธีการชะลอตัว | @Predestroy |
ความแตกต่าง: คำอธิบายประกอบสามารถกำหนดหลายวิธีในชั้นเรียนและวิธีการจะดำเนินการตามลำดับ
6. การกำหนดค่าที่ใช้ Java
6.1. ใช้คลาส Java เพื่อให้ข้อมูลนิยามถั่ว
(1) Pojo ธรรมดาสามารถให้ข้อมูลคำจำกัดความถั่วสำหรับคอนเทนเนอร์ฤดูใบไม้ผลิตราบใดที่มีการทำเครื่องหมายคำอธิบายประกอบ @configuration แต่ละวิธีที่ทำเครื่องหมายด้วย @bean นั้นเทียบเท่ากับการให้ข้อมูลนิยามถั่ว
(2) @bean
ประเภทของถั่วถูกกำหนดโดยประเภทค่าส่งคืนของวิธีการที่มีคำอธิบายประกอบโดย @bean
ชื่อเริ่มต้นของถั่วนั้นเหมือนกับชื่อเมธอดและสามารถระบุได้อย่างชัดเจนโดย @bean (name = "xxx")
คุณสามารถใช้ @scope ที่ @bean เพื่อระบุขอบเขตของการใช้ถั่ว
(3) @configuration
เนื่องจากคลาส @Configuration Annotation ของตัวเองถูกทำเครื่องหมายด้วยคำอธิบายประกอบ @component คลาสใด ๆ ที่ทำเครื่องหมายด้วย @Configurstion สามารถรวมตัวกันโดยอัตโนมัติในคลาสอื่น ๆ โดยใช้ @autowired
6.2. เริ่มต้นคอนเทนเนอร์สปริงโดยใช้ข้อมูลการกำหนดค่าตามคลาส Java
(1) ฤดูใบไม้ผลิให้คลาส AnnotationConfigapplicationContect ซึ่งสามารถเริ่มต้นคอนเทนเนอร์สปริงโดยตรงผ่านคำอธิบายประกอบของคลาส @Configuration
(2) เมื่อมีคลาสการกำหนดค่าหลายคลาส
คุณสามารถลงทะเบียนทีละหนึ่งผ่านวิธีการลงทะเบียนของคำอธิบายประกอบการกำหนดการใช้งานและจากนั้นเรียกใช้วิธีการรีเฟรชเพื่อรีเฟรชคอนเทนเนอร์เพื่อใช้คลาสการกำหนดค่าที่ลงทะเบียนเหล่านี้
นอกจากนี้คุณยังสามารถใช้คำอธิบายประกอบ @IMPORT (XXX.CLASS) เพื่อแนะนำคลาสการกำหนดค่าอื่น ๆ ทั้งหมดในคลาสการกำหนดค่าเดียวเพื่อให้คุณต้องลงทะเบียนคลาสการกำหนดค่าเดียวเท่านั้น
(3) อ้างถึงการกำหนดค่า @Configuration ผ่านคลาสการกำหนดค่า XML
<บริบท: Component-ScanBase-Package = "... " Resource-Pattern = "ชื่อคลาสการกำหนดค่า">
(4) ข้อมูลการกำหนดค่า XML อ้างอิงในคลาสการกำหนดค่า
ใช้ @importresource ("classpath: ............ ") ที่ @configuration เพื่อนำเข้าไฟล์การกำหนดค่า XML
6.3. การเปรียบเทียบ 3 วิธีการกำหนดค่า
| XML | คำอธิบายประกอบ | คลาส Java |
| ระดับการใช้งานของถั่วคือการพัฒนาโครงการปัจจุบัน | ควบคุมตรรกะโดยรวมของการเริ่มต้นถั่วผ่านรหัสเหมาะสำหรับสถานการณ์ที่การสร้างอินสแตนซ์ของถั่วมีความซับซ้อนมากขึ้น |
สรุป
ข้างต้นเป็นคำอธิบายโดยละเอียดทั้งหมดของถั่วประกอบฤดูใบไม้ผลิในภาชนะ IOC ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงเว็บไซต์นี้ต่อไปได้:
คำอธิบายโดยละเอียดเกี่ยวกับวิธีการกำหนดค่าถั่วทั้งสามในฤดูใบไม้ผลิ 3.x
การอภิปรายสั้น ๆ เกี่ยวกับความแตกต่างระหว่างรูปแบบ Spring Singleton Bean และ Singleton
คำอธิบายโดยละเอียดเกี่ยวกับวงจรชีวิตของการใช้การกำหนดค่าฤดูใบไม้ผลิ
หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!