เมื่อเร็ว ๆ นี้ฉันซื้อหนังสือเบื้องต้นในฤดูใบไม้ผลินี้: Springinaction ฉันเรียกดูคร่าวๆและรู้สึกดีทีเดียว เพียงเล็กน้อยในการเริ่มต้น หนังสือของแมนนิ่งยังคงดี แม้ว่าฉันจะไม่ได้มุ่งเน้นไปที่แมนนิ่งเหมือนคนที่อ่านหนังสือแมนนิ่ง แต่ฉันก็อ่านมันด้วยความเคารพและความหลงใหล อีกครั้งฉันยอมรับแนวคิดหลักของฤดูใบไม้ผลิเช่น IOC, DI และ AOP ให้ฉันพูดถึงความคิดเห็นของฉันเกี่ยวกับ IOC และ DI ก่อน
IOC (DI): อันที่จริงแนวคิดของสถาปัตยกรรมสปริงหลักนั้นไม่ซับซ้อนและไม่คลุมเครือเท่าที่อธิบายไว้ในหนังสือบางเล่ม โปรแกรมเมอร์ Java ทุกคนรู้ว่าตรรกะทางธุรกิจแต่ละรายการในโปรแกรม Java ต้องการวัตถุอย่างน้อยสองชิ้นขึ้นไปเพื่อทำงานร่วมกัน โดยทั่วไปเมื่อแต่ละวัตถุใช้วัตถุพันธมิตรจะต้องใช้ไวยากรณ์เช่น newObject () เพื่อให้แอปพลิเคชันงานของวัตถุพันธมิตรเสร็จสมบูรณ์ คุณจะพบว่าการมีเพศสัมพันธ์ระหว่างวัตถุนั้นสูง ความคิดของ IOC คือ: ภาชนะฤดูใบไม้ผลิเพื่อตระหนักถึงการสร้างและการประสานงานของวัตถุที่พึ่งพาซึ่งกันและกันเหล่านี้ วัตถุต้องมีตรรกะทางธุรกิจความสัมพันธ์เท่านั้น ในเรื่องนี้ความรับผิดชอบในการที่วัตถุได้รับวัตถุความร่วมมือของเขากลับด้าน (IOC, DI)
นี่คือประสบการณ์ของฉันเกี่ยวกับ IOC ของฤดูใบไม้ผลิ DI เป็นอีกวิธีหนึ่งในการพูด IOC DI ได้รับการเสนอครั้งแรกโดย Martin Fowler ในกระดาษในต้นปี 2004 เขาสรุปว่า: การควบคุมกลับด้านคืออะไร? นั่นคือ: วิธีการรับวัตถุที่ขึ้นอยู่กับการย้อนกลับ
หากคุณยังไม่เข้าใจแนวคิดหลักนี้: ที่นี่เราอ้างคำตอบที่เรียบง่ายและเข้าใจง่ายในบล็อกชื่อ Bromon:
IOC และ DI
ก่อนอื่นฉันต้องการพูดคุยเกี่ยวกับ IOC (InversionofControl, ควบคุมการผกผัน) นี่คือแกนกลางของฤดูใบไม้ผลิตลอด สำหรับกรอบฤดูใบไม้ผลิฤดูใบไม้ผลิมีหน้าที่ควบคุมวงจรชีวิตของวัตถุและความสัมพันธ์ระหว่างวัตถุ สิ่งนี้หมายความว่าอย่างไร? เพื่อให้ตัวอย่างง่ายๆเราจะหาแฟนได้อย่างไร? สถานการณ์ทั่วไปคือเราไปทุกที่เพื่อดูว่าเรามีผู้หญิงที่สวยงามและดูดีและสอบถามเกี่ยวกับความสนใจหมายเลข QQ หมายเลขโทรศัพท์หมายเลข IP หมายเลขไอคิว ... หาวิธีทำความรู้จักพวกเขาให้พวกเขาในสิ่งที่พวกเขาชอบแล้วฮิฮิ ... กระบวนการนี้ซับซ้อนและลึกซึ้ง เช่นเดียวกับการพัฒนาโปรแกรมแบบดั้งเดิม ในวัตถุหากคุณต้องการใช้วัตถุอื่นคุณต้องได้รับมัน (ใหม่ด้วยตัวเองหรือสอบถามจาก JNDI) หลังการใช้งานวัตถุจะต้องถูกทำลาย (เช่นการเชื่อมต่อ ฯลฯ ) และวัตถุจะถูกรวมเข้ากับอินเทอร์เฟซหรือคลาสอื่น ๆ เสมอ
แล้ว IOC ทำได้อย่างไร? มันเหมือนกับการหาแฟนผ่านเอเจนซี่การแต่งงานและแนะนำบุคคลที่สามระหว่างฉันกับแฟนของฉัน: เอเจนซี่การแต่งงาน หน่วยงานแต่งงานจัดการข้อมูลจำนวนมากเกี่ยวกับชายและหญิง ฉันสามารถจัดทำรายการให้กับหน่วยงานแต่งงานและบอกได้ว่าแฟนแบบไหนที่ฉันต้องการค้นหาเช่นดูเหมือนมิเชลเรสมีร่างอย่างหลินไซลีร้องเพลงเหมือนเจย์ชูมีความเร็วเหมือนคาร์ลอสและมีเทคโนโลยีอย่างซีดาน จากนั้นหน่วยงานแต่งงานจะให้ MM ตามข้อกำหนดของเรา เราแค่ต้องตกหลุมรักและแต่งงาน มันง่ายและชัดเจน หากผู้สมัครที่ได้รับมอบให้เราไม่เป็นไปตามข้อกำหนดเราจะทำการยกเว้น กระบวนการทั้งหมดไม่ได้ถูกควบคุมโดยฉันอีกต่อไป แต่ถูกควบคุมโดยสถาบันที่มีลักษณะคล้ายคอนเทนเนอร์เช่นหน่วยงานแต่งงาน นี่คือวิธีการพัฒนาที่สนับสนุนโดยฤดูใบไม้ผลิ ชั้นเรียนทั้งหมดจะลงทะเบียนในภาชนะฤดูใบไม้ผลิเพื่อบอกสปริงว่าคุณคืออะไรและสิ่งที่คุณต้องการ จากนั้นฤดูใบไม้ผลิจะให้สิ่งที่คุณต้องการเมื่อระบบทำงานอยู่ในระดับที่เหมาะสมและในเวลาเดียวกันก็มอบสิ่งอื่น ๆ ที่คุณต้องการ คลาสทั้งหมดถูกสร้างและทำลายโดยฤดูใบไม้ผลิซึ่งหมายความว่าวัตถุที่ควบคุมวงจรชีวิตของวัตถุนั้นไม่ได้เป็นวัตถุที่อ้างอิงอีกต่อไป แต่ฤดูใบไม้ผลิ สำหรับวัตถุเฉพาะมันใช้ในการควบคุมวัตถุอื่น ๆ แต่ตอนนี้วัตถุทั้งหมดถูกควบคุมโดยสปริงดังนั้นสิ่งนี้เรียกว่าการผกผันควบคุม
หนึ่งในประเด็นสำคัญของ IOC คือการจัดหาวัตถุกับวัตถุอื่น ๆ ที่ต้องการในระหว่างการทำงานของระบบ นี่คือความสำเร็จผ่าน DI (การพึ่งพา) ตัวอย่างเช่นวัตถุ A จำเป็นต้องใช้ฐานข้อมูล ในอดีตเรามักจะเขียนโค้ดใน A เพื่อรับวัตถุการเชื่อมต่อ ด้วยฤดูใบไม้ผลิเราต้องบอกสปริงว่าจำเป็นต้องมีการเชื่อมต่อใน A สำหรับวิธีการสร้างการเชื่อมต่อนี้และเมื่อใดที่จะสร้างมันไม่จำเป็นต้องรู้ เมื่อระบบทำงานสปริงจะสร้างการเชื่อมต่อในเวลาที่เหมาะสมจากนั้นฉีดเข้าไปในการฉีดเช่นเดียวกับการควบคุมความสัมพันธ์ระหว่างแต่ละวัตถุ ความต้องการที่จะพึ่งพาการเชื่อมต่อเพื่อทำงานตามปกติและการเชื่อมต่อนี้จะถูกฉีดเข้าไปในฤดูใบไม้ผลิและชื่อของการฉีดพึ่งพามาจากสิ่งนี้ แล้ว DI ถูกนำไปใช้อย่างไร? คุณสมบัติที่สำคัญหลังจาก Java 1.3 คือการสะท้อนกลับซึ่งช่วยให้โปรแกรมสามารถสร้างวัตถุแบบไดนามิกดำเนินการวิธีการวัตถุและเปลี่ยนคุณสมบัติของวัตถุเมื่อทำงาน ฤดูใบไม้ผลิถูกฉีดผ่านการสะท้อน สำหรับข้อมูลที่เกี่ยวข้องเกี่ยวกับการไตร่ตรองโปรดดู Javadoc
หลังจากทำความเข้าใจแนวคิดของ IOC และ DI ทุกอย่างจะเรียบง่ายและชัดเจนและงานที่เหลือก็เป็นเพียงการวางบล็อกในกรอบของฤดูใบไม้ผลิ
มาเรียนรู้ว่าฤดูใบไม้ผลิทำงานอย่างไร
โมฆะคงที่สาธารณะหลัก (สตริง [] args) {applicationcontext context = ใหม่ filesystemxmlapplicationContext ("applicationcontext.xml"); สัตว์สัตว์ = (สัตว์) บริบท getBean ("สัตว์"); Animal.Say (); -คุณต้องคุ้นเคยกับรหัสนี้ แต่มาวิเคราะห์กันเถอะ ก่อนอื่น ApplicationContext.xml
<Bean ID = "Animal"> <property name = "name" value = "Kitty" /> </ebean>
เขามีคลาส phz.springframework.test.cat
Public Class Cat ใช้สัตว์ {ชื่อสตริงส่วนตัว; โมฆะสาธารณะบอกว่า () {system.out.println ("ฉัน" + ชื่อ + "!");} โมฆะสาธารณะ setName (ชื่อสตริง) {this.name = name;}}}ใช้งาน phz.springframework.test.animal อินเตอร์เฟส
สัตว์อินเทอร์เฟซสาธารณะ {โมฆะสาธารณะกล่าวว่า (); -เห็นได้ชัดว่ารหัสข้างต้นเอาต์พุต IAMKITTY!
แล้วฤดูใบไม้ผลิทำได้อย่างไร?
ต่อไปให้เขียนฤดูใบไม้ผลิด้วยตนเองเพื่อดูว่าฤดูใบไม้ผลิทำงานอย่างไร!
ก่อนอื่นเรากำหนดคลาสถั่วซึ่งใช้ในการจัดเก็บคุณสมบัติของถั่วที่เป็นเจ้าของ
/ * ถั่ว ID */ รหัสสตริงส่วนตัว; / * คลาสถั่ว */ ประเภทสตริงส่วนตัว; / * คุณสมบัติถั่ว */ แผนที่ส่วนตัว <String, Object> คุณสมบัติ = ใหม่ HashMap <String, Object> ();
ถั่วรวมถึง ID ประเภทและคุณสมบัติ
ฤดูใบไม้ผลิถัดไปเริ่มโหลดไฟล์การกำหนดค่าของเราและบันทึกข้อมูลการกำหนดค่าใน HASHMAP กุญแจสำคัญของ HashMap คือ ID ของถั่วและค่าของ Hasmap คือถั่ว ด้วยวิธีนี้เราจะได้รับชั้นเรียนสัตว์ผ่านบริบท getBean ("สัตว์") เราทุกคนรู้ว่า Spirng สามารถฉีดประเภทพื้นฐานและสามารถฉีดประเภทเช่นรายการและแผนที่ ถัดไปลองใช้แผนที่เป็นตัวอย่างเพื่อดูว่าจะบันทึกฤดูใบไม้ผลิอย่างไร
การกำหนดค่าแผนที่อาจเป็นเช่นนี้
<bean id = "test"> <property name = "testmap"> <map> <entry key = "a"> <value> 1 </value> </entry> <entry key = "b"> <alde> 2 </alue>
สปริงบันทึกการกำหนดค่าข้างต้นอย่างไร รหัสมีดังนี้:
if (beanProperty.element ("map")! = null) {map <string, object> propertiesmap = new hashmap <string, object> (); คุณสมบัติ ElementiesListMap = (องค์ประกอบ) BeanProperty.Elements (). รับ (0); Iterator <?> propertientiterator = propertieslistmap.elements (). iterator (); ในขณะที่ (propertiesiterator.hasnext ()) {องค์ประกอบ vet = (องค์ประกอบ) propertientiterator.next (); if (vet.getName (). เท่ากับ ("รายการ")) {คีย์สตริง = vet.attributeValue ("คีย์"); iterator <?> valueIterator = vet.elements (). iterator (); ในขณะที่ (valueIterator.hasnext ()) {ค่าองค์ประกอบ = (องค์ประกอบ) valueItreiter.next (); if (value.getName (). เท่ากับ ("value")) {propertiesMap.put (key, value.getText ()); } if (value.getName (). Equals ("Ref")) {propertiesMap.put (คีย์, สตริงใหม่ [] {value.attributeValue ("Bean")}); }}}} bean.getProperties (). ใส่ (ชื่อ, คุณสมบัติ map); -ถัดไปไปที่ส่วนหลักกันเถอะ มาดูกันว่าการฉีดพึ่งพาสปริงเป็นอย่างไร ในความเป็นจริงความคิดของการฉีดพึ่งพานั้นง่ายมาก มันถูกนำไปใช้ผ่านกลไกการสะท้อน เมื่ออินสแตนซ์คลาสมันจะฉีดแอตทริบิวต์คลาสที่เก็บไว้ใน HASHMAP ลงในคลาสโดยสะท้อนวิธีการตั้งค่าในชั้นเรียน มาดูกันว่ามันทำอย่างไร
อินสแตนซ์ครั้งแรกในชั้นเรียนเช่นนี้
วัตถุคงที่สาธารณะ newInstance (String className) {class <?> cls = null; object obj = null; ลอง {cls = class.forname (classname); obj = cls.newinstance ();} catch (classnotfoundexception e) (unlendalAccessException e) {โยน runtimeException ใหม่ (e);} return obj;}จากนั้นมันจะฉีดการพึ่งพาของชั้นเรียนนี้เข้าไปเช่นนี้
โมฆะคงที่สาธารณะ setProperty (Object OBJ, ชื่อสตริง, ค่าสตริง) {คลาส <? ขยายวัตถุ> clazz = obj.getClass (); ลอง {String methodName = returnSetMthodname (ชื่อ); วิธี [] ms = clazz.getMethods (); สำหรับ (วิธี m: ms) {ถ้า (m.getName () {classAmpes (m.getName M.GetParameterTypes () [0]; setfieldValue (clazzparametertype.getName (), ค่า, m, obj); break;}}}}} catch (SecurityException e) {โยน runtimeException ใหม่ (e); ใหม่ runtimeException (e);}}ในที่สุดมันจะส่งคืนอินสแตนซ์ของคลาสนี้ให้เราและเราสามารถใช้มันได้ มาดูแผนที่เป็นตัวอย่างเพื่อดูว่ามันทำอย่างไร รหัสที่ฉันเขียนคือการสร้าง hashmap และฉีด hashmap ลงในคลาสที่ต้องฉีดเช่นนี้
ถ้า (ค่าอินสแตนซ์ของแผนที่) {iterator <?> entryInerator = ((แผนที่ <?,?>) ค่า). entrySet (). iterator (); แผนที่ <string, Object> map = new hashmap <string, object> (); ในขณะที่ (entryiterator.hasnext ()) {entry <?,?> entrymap = (รายการ <?,?>) entryInerator.next (); if (entrymap.getValue () string ของสตริง []) {map.put ((สตริง) entrymap.getKey (), getBean (((String []) entryMap.getValue ()) [0]); }} BeanProcesser.SetProperty (OBJ, คุณสมบัติ, แผนที่); -ตกลงดังนั้นเราสามารถใช้สปริงเพื่อสร้างคลาสให้เรา มันไม่ยากเหรอ? แน่นอนฤดูใบไม้ผลิสามารถทำได้มากกว่านี้ โปรแกรมตัวอย่างนี้เป็นส่วนหนึ่งของฟังก์ชั่นการฉีดพึ่งพาหลักมากที่สุดของฤดูใบไม้ผลิ
บทความนี้ได้อ้างอิงบทความจำนวนมากและไม่สามารถขอบคุณทีละบทความได้ ขอบคุณที่นี่ด้วยกัน ฉันขอโทษสำหรับการละเมิดลิขสิทธิ์ของคุณ ฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน!
สรุป
ข้างต้นเป็นเนื้อหาทั้งหมดของบทความนี้เกี่ยวกับคำอธิบายโดยละเอียดของหลักการ IOC ฤดูใบไม้ผลิและฉันหวังว่ามันจะเป็นประโยชน์กับทุกคน เพื่อนที่สนใจสามารถอ้างถึงเว็บไซต์นี้ต่อไปได้:
ความเข้าใจสั้น ๆ เกี่ยวกับตัวอย่าง IOC, AOP และรหัสของฤดูใบไม้ผลิ
การแนะนำอย่างละเอียดเกี่ยวกับการใช้งานการจำลอง IOC ของฤดูใบไม้ผลิ
หากมีข้อบกพร่องใด ๆ โปรดฝากข้อความไว้เพื่อชี้ให้เห็น ขอบคุณเพื่อนที่ให้การสนับสนุนเว็บไซต์นี้!