คำอธิบายโดยละเอียดของถั่วประกอบฤดูใบไม้ผลิในภาชนะ IOC

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) การเปรียบเทียบวิธีกระบวนการชีวิต

ความแตกต่าง: คำอธิบายประกอบสามารถกำหนดหลายวิธีในชั้นเรียนและวิธีการจะดำเนินการตามลำดับ

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 วิธีการกำหนดค่า

สรุป

ข้างต้นเป็นคำอธิบายโดยละเอียดทั้งหมดของถั่วประกอบฤดูใบไม้ผลิในภาชนะ IOC ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงเว็บไซต์นี้ต่อไปได้:

คำอธิบายโดยละเอียดเกี่ยวกับวิธีการกำหนดค่าถั่วทั้งสามในฤดูใบไม้ผลิ 3.x

การอภิปรายสั้น ๆ เกี่ยวกับความแตกต่างระหว่างรูปแบบ Spring Singleton Bean และ Singleton

คำอธิบายโดยละเอียดเกี่ยวกับวงจรชีวิตของการใช้การกำหนดค่าฤดูใบไม้ผลิ

หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!