-
Hibernate ทำงานอย่างไร และเหตุใดคุณจึงควรใช้มัน
หลักการ:
1. อ่านและแยกไฟล์การกำหนดค่า
2. อ่านและแยกวิเคราะห์ข้อมูลการแมปและสร้าง SessionFactory
3.เปิดเซสชัน
4. สร้างธุรกรรมธุรกรรม
5. การดำเนินงานที่คงอยู่
6. ส่งรายการ
7.ปิดเซสชัน
8. ปิด SessionFactory
ทำไมต้องใช้:
1. รหัสสำหรับการเข้าถึงฐานข้อมูล JDBC นั้นถูกห่อหุ้มไว้ ซึ่งช่วยลดความซับซ้อนของรหัสที่ซ้ำซากและซ้ำซากในชั้นการเข้าถึงข้อมูล
2. Hibernate เป็นเฟรมเวิร์กการคงอยู่ของกระแสหลักโดยอิงจาก JDBC และการใช้งาน ORM ที่ยอดเยี่ยม ช่วยให้งานเขียนโค้ดของเลเยอร์ DAO ง่ายขึ้นอย่างมาก
3. ไฮเบอร์เนตใช้กลไกการสะท้อน Java แทนโปรแกรมเพิ่มประสิทธิภาพ bytecode เพื่อให้เกิดความโปร่งใส
4. ประสิทธิภาพของไฮเบอร์เนตดีมากเพราะเป็นเฟรมเวิร์กที่มีน้ำหนักเบา ความยืดหยุ่นในการทำแผนที่มีความโดดเด่น รองรับฐานข้อมูลเชิงสัมพันธ์ที่หลากหลาย ตั้งแต่ความสัมพันธ์ที่ซับซ้อนแบบหนึ่งต่อหนึ่งไปจนถึงหลายกลุ่มต่อกลุ่ม
2. Hibernate Lazy Load เป็นอย่างไร
1. การใช้งานการโหลดแบบขี้เกียจของ Hibernate2: a) วัตถุเอนทิตี b) การรวบรวม (คอลเลกชัน)
2. Hibernate3 มีฟังก์ชันการโหลดคุณสมบัติแบบ Lazy Loading
เมื่อไฮเบอร์เนตสอบถามข้อมูล ข้อมูลนั้นจะไม่มีอยู่ในหน่วยความจำ เมื่อโปรแกรมทำงานกับข้อมูลจริง ๆ ก็จะมีอ็อบเจ็กต์อยู่ในหน่วยความจำ จึงทำให้เกิดการโหลดแบบ Lazy Loading . ผลงาน.
3. จะทราบความสัมพันธ์ระหว่างคลาสใน Hibernate ได้อย่างไร (เช่น: ความสัมพันธ์แบบหนึ่งต่อกลุ่ม, หลายต่อกลุ่ม)
ความสัมพันธ์ระหว่างคลาสส่วนใหญ่สะท้อนให้เห็นในการดำเนินการของความสัมพันธ์ระหว่างตาราง ทั้งหมดทำงานบนออบเจ็กต์ ตารางและคลาสทั้งหมดถูกแมปเข้าด้วยกันในโปรแกรมของเรา และพวกมันจะถูกแมปเข้าด้วยกันผ่านหลาย ๆ ถึงในไฟล์คอนฟิกูเรชัน หนึ่งต่อกลุ่ม, หลายต่อหลาย,
4. เรามาพูดถึงกลไกการแคชของ Hibernate กันดีกว่า
1. แคชภายในมีอยู่ใน Hibernate หรือที่เรียกว่าแคชระดับแรก ซึ่งเป็นของแคชระดับธุรกรรมของแอปพลิเคชัน
2. แคชระดับที่สอง:
ก) แอปพลิเคชันและแคช
b) เงื่อนไขแคชแบบกระจาย: ข้อมูลจะไม่ได้รับการแก้ไขโดยบุคคลที่สาม, ขนาดข้อมูลอยู่ภายในช่วงที่ยอมรับได้, ความถี่ในการอัปเดตข้อมูลต่ำ, ข้อมูลเดียวกันนี้ถูกใช้บ่อยครั้งโดยระบบ, ข้อมูลที่ไม่สำคัญ
c) การใช้งานแคชของบุคคลที่สาม
5. วิธีการสืบค้นแบบไฮเบอร์เนต
SQL, Criteria, การจัดวางอ็อบเจ็กต์
สำนักงานใหญ่：
1. แบบสอบถามคุณสมบัติ
2. แบบสอบถามพารามิเตอร์ ชื่อแบบสอบถามพารามิเตอร์
3. คำถามที่เกี่ยวข้อง
4. แบบสอบถามเพจจิ้ง
5. ฟังก์ชันทางสถิติ
6. จะเพิ่มประสิทธิภาพไฮเบอร์เนตได้อย่างไร?
1. ใช้การเชื่อมโยงแบบหนึ่งต่อกลุ่มแบบสองทางแทนการเชื่อมโยงแบบหนึ่งต่อกลุ่มแบบทางเดียว
2. การใช้การเชื่อมโยงแบบหนึ่งต่อกลุ่มแบบทางเดียวอย่างยืดหยุ่น
3. แทนที่จะใช้แบบหนึ่งต่อหนึ่ง ให้ใช้หลายต่อหนึ่งแทน
4. กำหนดค่าแคชวัตถุและอย่าใช้แคชคอลเลกชัน
5. ใช้กระเป๋าสำหรับคอลเลกชันแบบหนึ่งต่อกลุ่ม และตั้งค่าสำหรับคอลเลกชันแบบหลายต่อหลายรายการ
6. ใช้ความหลากหลายที่ชัดเจนในคลาสที่สืบทอดมา
7. ควรมีเขตข้อมูลตารางน้อยลง อย่ากลัวการเชื่อมโยงตารางมากเกินไป และรองรับแคชระดับที่สอง
7. สตรัททำงานอย่างไร? ทำไมต้องใช้สตรัท?
กลไกการทำงาน:
เวิร์กโฟลว์ Struts:
เมื่อเว็บแอปพลิเคชันเริ่มทำงาน การเริ่มต้น ActionServlet จะถูกโหลด
อ่านข้อมูลคอนฟิกูเรชันจากไฟล์ struts-config.xml และจัดเก็บไว้ในอ็อบเจ็กต์คอนฟิกูเรชันต่างๆ เมื่อ ActionServlet ได้รับคำขอจากลูกค้า ระบบจะดำเนินการกระบวนการต่อไปนี้
-(1) ดึงข้อมูลอินสแตนซ์ ActionMapping ที่ตรงกับคำขอของผู้ใช้ หากไม่มี ให้ส่งคืนข้อมูลเส้นทางคำขอที่ไม่ถูกต้อง
-(2) หากไม่มีอินสแตนซ์ ActionForm ให้สร้างออบเจ็กต์ ActionForm และบันทึกข้อมูลแบบฟอร์มที่ลูกค้าส่งมาไว้ในออบเจ็กต์ ActionForm
- (3) ตรวจสอบว่าจำเป็นต้องมีการตรวจสอบแบบฟอร์มตามข้อมูลการกำหนดค่าหรือไม่ หากจำเป็นต้องมีการตรวจสอบ ให้เรียกเมธอด validate() ของ ActionForm
-(4) ถ้าเมธอด validate() ของ ActionForm ส่งคืนค่า null หรือส่งคืนอ็อบเจ็กต์ ActuibErrors ที่ไม่มี ActionMessage แสดงว่าการตรวจสอบแบบฟอร์มสำเร็จ
-(5) ActionServlet ตัดสินใจว่า Action ใดที่จะส่งต่อคำขอไปโดยอิงตามข้อมูลการแมปที่มีอยู่ใน ActionMapping หากไม่มีอินสแตนซ์ Action ที่เกี่ยวข้อง ให้สร้างอินสแตนซ์นี้ก่อน จากนั้นจึงเรียกใช้เมธอด Action's Execution()
- (6) วิธีการดำเนินการ () ของ Action ส่งคืนวัตถุ ActionForward และ ActionServlet ส่งต่อคำขอของลูกค้าไปยังองค์ประกอบ JSP ที่วัตถุ ActionForward ชี้ไป
-(7) ออบเจ็กต์ ActionForward ชี้ไปที่ส่วนประกอบ JSP เพื่อสร้างเว็บเพจแบบไดนามิกและส่งคืนให้กับลูกค้า
ทำไมต้องใช้:
การเกิดขึ้นของเทคโนโลยี JSP, Servlet และ JavaBean ทำให้เราสามารถสร้างระบบแอปพลิเคชันระดับองค์กรที่มีประสิทธิภาพได้ แต่ระบบที่สร้างขึ้นด้วยเทคโนโลยีเหล่านี้มีความซับซ้อนมาก ดังนั้น เรายังต้องมีกฎ กฎเกณฑ์ในการจัดระเบียบเทคโนโลยีเหล่านี้ และนี่คือกรอบการทำงาน และ Struts ก็เกิดขึ้น
แอปพลิเคชันที่พัฒนาบน Struts ประกอบด้วยส่วนประกอบสามประเภท: ส่วนประกอบตัวควบคุม ส่วนประกอบโมเดล และส่วนประกอบมุมมอง
8. กรอบการตรวจสอบความถูกต้องของ Struts ตรวจสอบได้อย่างไร
กำหนดค่าพร้อมท์ข้อผิดพลาดเฉพาะในไฟล์การกำหนดค่า struts จากนั้นเรียกเมธอด validate() ใน FormBean โดยเฉพาะ
9. เรามาพูดถึงรูปแบบการออกแบบของ Struts กันดีกว่า
โหมด MVC: ActionServler ถูกโหลดและเริ่มต้นเมื่อเว็บแอปพลิเคชันเริ่มทำงาน เมื่อผู้ใช้ส่งแบบฟอร์ม ออบเจ็กต์ ActionForm ที่กำหนดค่าจะถูกสร้างขึ้นและกรอกข้อมูลที่เกี่ยวข้องของแบบฟอร์ม ActionServler จะกำหนดว่าจำเป็นต้องมีการตรวจสอบความถูกต้องของแบบฟอร์มตามการตั้งค่าที่กำหนดค่าไว้ในไฟล์ Struts-config.xml หรือไม่ หากจำเป็น ตรวจสอบ () ของ ActionForm หลังจากตรวจสอบแล้ว ให้เลือก Action ที่จะส่งคำขอไป หากไม่มี ActionServlet จะสร้างออบเจ็กต์นี้ก่อน จากนั้นจึงเรียกใช้เมธอด Action ของ Action Execute() รับข้อมูลจากออบเจ็กต์ ActionForm กรอกตรรกะทางธุรกิจ และส่งกลับออบเจ็กต์ ActionForward จากนั้นส่งต่อคำขอของลูกค้าไปยังองค์ประกอบ jsp ที่ระบุโดยออบเจ็กต์ ActionForward จะสร้างเว็บเพจแบบไดนามิกและ ส่งคืนให้กับลูกค้า
10. สปริงทำงานอย่างไร และเหตุใดจึงควรใช้?
1. Spring MVC ขอให้ส่งคำขอทั้งหมดไปยัง DispatcherServlet ซึ่งจะมอบหมายให้โมดูลอื่นๆ ของระบบแอปพลิเคชันเป็นผู้รับผิดชอบในการประมวลผลคำขอจริง
2.DispatcherServlet สอบถาม HandlerMapping หนึ่งรายการขึ้นไปเพื่อค้นหาตัวควบคุมที่จัดการคำขอ
3.DispatcherServlet โปรดส่งคำขอไปยังตัวควบคุมเป้าหมาย
4. หลังจากที่คอนโทรลเลอร์ดำเนินการประมวลผลตรรกะทางธุรกิจแล้ว จะส่งคืน ModelAndView
5.Dispathcher สอบถาม parsers มุมมอง ViewResolver หนึ่งรายการขึ้นไปเพื่อค้นหาวัตถุมุมมองที่ระบุโดยวัตถุ ModelAndView
6. วัตถุมุมมองมีหน้าที่รับผิดชอบในการเรนเดอร์และส่งคืนให้กับลูกค้า
ทำไมต้องใช้:
{AOP ช่วยให้นักพัฒนาสามารถสร้างข้อกังวลที่ไม่เกี่ยวกับพฤติกรรม ซึ่งเรียกว่าข้อกังวลแบบตัดขวาง และแทรกลงในโค้ดของแอปพลิเคชัน หลังจากใช้ AOP บริการสาธารณะ (เช่น การบันทึก การคงอยู่ ธุรกรรม ฯลฯ) สามารถแบ่งออกเป็นลักษณะต่างๆ และนำไปใช้กับออบเจ็กต์โดเมนโดยไม่เพิ่มความซับซ้อนของโมเดลออบเจ็กต์ของออบเจ็กต์โดเมน
IOC อนุญาตให้สร้างสภาพแวดล้อมแอปพลิเคชันที่สามารถสร้างวัตถุแล้วส่งผ่านวัตถุเหล่านี้วัตถุที่ทำงานร่วมกัน ดังที่คำว่าผกผันบ่งชี้ IOC ก็เหมือนกับ JNDI ในสิ่งที่ตรงกันข้าม แทนที่จะใช้โรงงานเชิงนามธรรม ตัวระบุตำแหน่งบริการ ซิงเกิลตัน และการก่อสร้างทางตรงจำนวนมาก วัตถุทุกชิ้นถูกสร้างขึ้นจากวัตถุที่ทำงานร่วมกัน ดังนั้นคอนเทนเนอร์จึงจัดการออบเจ็กต์การทำงานร่วมกัน (ผู้ทำงานร่วมกัน)
แม้ว่า Spring จะเป็นเฟรมเวิร์ก AOP แต่ก็เป็นคอนเทนเนอร์ IOC เช่นกัน สิ่งที่ดีที่สุดเกี่ยวกับ Spring คือมันช่วยให้คุณแทนที่วัตถุได้ ด้วย Spring เพียงเพิ่มการพึ่งพา (วัตถุที่ทำงานร่วมกัน) โดยใช้คุณสมบัติ JavaBean และไฟล์การกำหนดค่า จากนั้นจึงเป็นเรื่องง่ายที่จะแทนที่ออบเจ็กต์ที่ทำงานร่วมกันด้วยอินเทอร์เฟซที่คล้ายกันเมื่อจำเป็น -
Spring Framework เป็นสถาปัตยกรรมแบบเลเยอร์ที่ประกอบด้วย 7 โมดูลที่มีการกำหนดไว้อย่างดี โมดูล Spring ถูกสร้างขึ้นบนคอนเทนเนอร์หลัก ซึ่งกำหนดวิธีสร้าง กำหนดค่า และจัดการ bean ดังแสดงในรูปที่ 1
แต่ละโมดูล (หรือส่วนประกอบ) ที่ประกอบขึ้นเป็น Spring Framework สามารถมีอยู่ได้เพียงลำพังหรือใช้ร่วมกับโมดูลอื่นตั้งแต่หนึ่งโมดูลขึ้นไป ฟังก์ชั่นของแต่ละโมดูลมีดังนี้:
☆ Core Container: Core Container มีฟังก์ชันพื้นฐานของ Spring Framework ส่วนประกอบหลักของคอนเทนเนอร์หลักคือ BeanFactory ซึ่งเป็นการนำรูปแบบโรงงานไปใช้ BeanFactory ใช้รูปแบบ Inversion of Control (IOC) เพื่อแยกการกำหนดค่าแอปพลิเคชันและข้อกำหนดการพึ่งพาออกจากรหัสแอปพลิเคชันจริง
☆ Spring context: Spring context เป็นไฟล์คอนฟิกูเรชันที่ให้ข้อมูลบริบทแก่ Spring framework บริบทของ Spring รวมถึงบริการระดับองค์กร เช่น JNDI, EJB, อีเมล, ความเป็นสากล, การตรวจสอบความถูกต้อง และฟังก์ชันการจัดส่ง
☆ Spring AOP: ด้วยคุณสมบัติการจัดการการกำหนดค่า โมดูล Spring AOP จะรวมฟังก์ชันการเขียนโปรแกรมเชิงแง่มุมเข้ากับเฟรมเวิร์ก Spring โดยตรง ดังนั้นจึงเป็นเรื่องง่ายที่จะทำให้ออบเจ็กต์ใด ๆ ที่ได้รับการจัดการโดย Spring Framework รองรับ AOP โมดูล Spring AOP ให้บริการการจัดการธุรกรรมสำหรับอ็อบเจ็กต์ในแอปพลิเคชันที่ใช้ Spring ด้วยการใช้ Spring AOP คุณสามารถรวมการจัดการธุรกรรมที่เปิดเผยเข้ากับแอปพลิเคชันของคุณได้โดยไม่ต้องอาศัยส่วนประกอบ EJB
☆ Spring DAO: เลเยอร์นามธรรม JDBC DAO จัดเตรียมลำดับชั้นข้อยกเว้นที่มีความหมาย ซึ่งสามารถใช้เพื่อจัดการการจัดการข้อยกเว้นและข้อความแสดงข้อผิดพลาดที่ส่งโดยผู้จำหน่ายฐานข้อมูลที่แตกต่างกัน ลำดับชั้นข้อยกเว้นช่วยลดความยุ่งยากในการจัดการข้อผิดพลาด และลดจำนวนรหัสข้อยกเว้นที่ต้องเขียนลงอย่างมาก (เช่น การเปิดและปิดการเชื่อมต่อ) ข้อยกเว้นที่มุ่งเน้น JDBC ของ Spring DAO เป็นไปตามลำดับชั้นข้อยกเว้น DAO ทั่วไป
☆ Spring ORM: เฟรมเวิร์ก Spring แทรกเฟรมเวิร์ก ORM หลายเฟรมเพื่อจัดเตรียมเครื่องมือเชิงวัตถุสัมพันธ์ของ ORM รวมถึง JDO, Hibernate และ iBatis SQL Map ทั้งหมดนี้สอดคล้องกับธุรกรรมทั่วไปของ Spring และลำดับชั้นข้อยกเว้นของ DAO
☆ โมดูล Spring Web: โมดูลบริบทของเว็บสร้างขึ้นจากโมดูลบริบทของแอปพลิเคชัน และจัดเตรียมบริบทสำหรับแอปพลิเคชันบนเว็บ ดังนั้น Spring Framework จึงรองรับการทำงานร่วมกับ Jakarta Struts เว็บโมดูลยังช่วยลดความยุ่งยากในการจัดการคำขอแบบหลายส่วนและพารามิเตอร์คำขอที่เชื่อมโยงกับออบเจ็กต์โดเมน
☆ Spring MVC framework: MVC framework เป็นการใช้งาน MVC ที่มีคุณสมบัติครบถ้วนสำหรับการสร้างเว็บแอปพลิเคชัน ผ่านอินเทอร์เฟซกลยุทธ์ กรอบงาน MVC จะสามารถกำหนดค่าได้สูงและ MVC รองรับเทคโนโลยีมุมมองจำนวนมาก รวมถึง JSP, Velocity, Tiles, iText และ POI
คุณสมบัติ Spring Framework สามารถใช้ในเซิร์ฟเวอร์ J2EE ใดก็ได้ และคุณสมบัติส่วนใหญ่ยังเหมาะสำหรับสภาพแวดล้อมที่ไม่มีการจัดการอีกด้วย ประเด็นหลักของ Spring คือการสนับสนุนออบเจ็กต์การเข้าถึงข้อมูลและธุรกิจที่นำกลับมาใช้ใหม่ได้ ซึ่งไม่ได้เชื่อมโยงกับบริการ J2EE ที่เฉพาะเจาะจง ไม่ต้องสงสัยเลยว่าออบเจ็กต์ดังกล่าวสามารถนำกลับมาใช้ใหม่ได้ระหว่างสภาพแวดล้อม J2EE ที่แตกต่างกัน (เว็บหรือ EJB) แอปพลิเคชันแบบสแตนด์อโลน และสภาพแวดล้อมการทดสอบ
ไอโอซีและเอโอพี
แนวคิดพื้นฐานของรูปแบบ Inversion of Control (หรือที่เรียกว่าการแทรกแซงการพึ่งพา) คือคุณไม่ได้สร้างอ็อบเจ็กต์ แต่คุณอธิบายวิธีการสร้างอ็อบเจ็กต์เหล่านั้น มันไม่ได้เชื่อมต่อโดยตรงกับออบเจ็กต์และบริการในโค้ด แต่ส่วนประกอบใดที่ต้องการบริการใดที่อธิบายไว้ในไฟล์การกำหนดค่า คอนเทนเนอร์ (ใน Spring Framework คือคอนเทนเนอร์ IOC) มีหน้าที่เชื่อมโยงสิ่งเหล่านี้เข้าด้วยกัน
ในสถานการณ์สมมติ IOC ทั่วไป คอนเทนเนอร์จะสร้างออบเจ็กต์ทั้งหมดและตั้งค่าคุณสมบัติที่จำเป็นเพื่อเชื่อมต่อเข้าด้วยกันและตัดสินใจว่าเมื่อใดจะเรียกใช้เมธอด ตารางต่อไปนี้แสดงโหมดการใช้งานของ IOC
คอนเทนเนอร์ IOC ของ Spring Framework ถูกนำมาใช้โดยใช้ประเภท 2 และประเภท 3
การเขียนโปรแกรมเชิงแง่มุม
การเขียนโปรแกรมเชิงมุมมองหรือ AOP เป็นเทคนิคการเขียนโปรแกรมที่ช่วยให้โปรแกรมเมอร์แยกส่วนพฤติกรรมที่ตัดผ่านข้อกังวลหรือสายความรับผิดชอบทั่วไป เช่น การบันทึกและการจัดการธุรกรรม โครงสร้างหลักของ AOP คือลักษณะต่างๆ ซึ่งสรุปพฤติกรรมที่ส่งผลกระทบต่อหลายคลาสให้เป็นโมดูลที่นำมาใช้ซ้ำได้
AOP และ IOC เป็นเทคโนโลยีเสริมที่ใช้วิธีการแบบแยกส่วนเพื่อแก้ไขปัญหาที่ซับซ้อนในการพัฒนาแอปพลิเคชันระดับองค์กร ในแนวทางการพัฒนาเชิงวัตถุทั่วไป คำสั่งการบันทึกอาจถูกวางไว้ในวิธีการทั้งหมดและคลาส Java เพื่อใช้ฟังก์ชันการบันทึก ในแนวทาง AOP บริการการบันทึกสามารถปรับเปลี่ยนให้เป็นโมดูลและนำไปใช้อย่างชัดเจนกับส่วนประกอบที่ต้องมีการบันทึก แน่นอนว่าข้อดีคือคลาส Java ไม่จำเป็นต้องทราบถึงการมีอยู่ของบริการบันทึก และไม่จำเป็นต้องพิจารณาโค้ดที่เกี่ยวข้อง ดังนั้นรหัสแอปพลิเคชันที่เขียนใน Spring AOP จึงมีการเชื่อมโยงอย่างหลวมๆ
ฟังก์ชันการทำงานของ AOP ได้รับการบูรณาการอย่างสมบูรณ์ในบริบทของการจัดการธุรกรรม Spring การบันทึก และคุณสมบัติอื่นๆ มากมาย
คอนเทนเนอร์ไอโอซี
หัวใจหลักของการออกแบบของ Spring คือแพ็คเกจ org.springframework.beans ซึ่งออกแบบมาเพื่อใช้กับส่วนประกอบ JavaBean โดยทั่วไปแพ็คเกจนี้ไม่ได้ใช้โดยผู้ใช้โดยตรง แต่ถูกใช้โดยเซิร์ฟเวอร์เป็นตัวกลางระดับต่ำสำหรับฟังก์ชันอื่น ๆ ส่วนใหญ่ สิ่งที่เป็นนามธรรมระดับสูงสุดถัดไปคืออินเทอร์เฟซ BeanFactory ซึ่งเป็นการนำรูปแบบการออกแบบของ Factory ไปใช้ และอนุญาตให้สร้างและดึงออบเจ็กต์ตามชื่อ BeanFactory ยังสามารถจัดการความสัมพันธ์ระหว่างวัตถุได้
BeanFactory รองรับโมเดลออบเจ็กต์สองแบบ
□ โมเดล monomorphic จัดเตรียมอินสแตนซ์ที่ใช้ร่วมกันของออบเจ็กต์พร้อมชื่อเฉพาะที่สามารถดึงข้อมูลได้ในเวลาสืบค้น Singleton เป็นโมเดลออบเจ็กต์เริ่มต้นและใช้บ่อยที่สุด เหมาะสำหรับวัตถุบริการไร้สัญชาติ
□ โมเดลต้นแบบช่วยให้แน่ใจว่ามีการสร้างออบเจ็กต์แยกกันสำหรับการดึงข้อมูลแต่ละครั้ง โมเดลต้นแบบเหมาะที่สุดเมื่อผู้ใช้แต่ละคนต้องการวัตถุของตนเอง
แนวคิดของโรงงานถั่วเป็นพื้นฐานของ Spring ในฐานะคอนเทนเนอร์ของ IOC IOC โอนความรับผิดชอบในการจัดการสิ่งต่าง ๆ จากโค้ดแอปพลิเคชันไปยังเฟรมเวิร์ก ตามที่ฉันจะสาธิตในตัวอย่างถัดไป Spring Framework ใช้คุณสมบัติ JavaBean และข้อมูลการกำหนดค่าเพื่อระบุว่าต้องตั้งค่าการขึ้นต่อกันใด
อินเตอร์เฟซ BeanFactory
เนื่องจาก org.springframework.beans.factory.BeanFactory เป็นอินเทอร์เฟซที่เรียบง่าย จึงสามารถนำไปใช้กับวิธีการจัดเก็บข้อมูลพื้นฐานต่างๆ ได้ คำจำกัดความ BeanFactory ที่ใช้กันมากที่สุดคือ XmlBeanFactory ซึ่งโหลด bean ตามคำจำกัดความในไฟล์ XML ดังแสดงในรายการ 1
รายการ 1. XmlBeanFactory
โรงงาน BeanFactory = XMLBeanFactory ใหม่ (FileInputSteam ใหม่ ("mybean.xml"));
Beans ที่กำหนดในไฟล์ XML จะถูกโหลดแบบพาสซีฟ ซึ่งหมายความว่า bean นั้นไม่ได้ถูกเตรียมใช้งานจนกว่าจะจำเป็นต้องใช้ bean หากต้องการดึงข้อมูล bean จาก BeanFactory เพียงเรียกใช้เมธอด getBean() โดยส่งผ่านชื่อของ bean ที่จะดึงข้อมูล ดังแสดงในรายการที่ 2
รายการ 2.getBean()
MyBean mybean = (MyBean) factory.getBean("mybean");
แต่ละคำจำกัดความ bean สามารถเป็น POJO (กำหนดด้วยชื่อคลาสและคุณสมบัติการกำหนดค่าเริ่มต้น JavaBean) หรือ FactoryBean อินเทอร์เฟซ FactoryBean เพิ่มระดับทางอ้อมให้กับแอปพลิเคชันที่สร้างโดยใช้เฟรมเวิร์ก Spring
ตัวอย่างไอโอซี
วิธีที่ง่ายที่สุดในการทำความเข้าใจการผกผันของการควบคุมคือการดูการดำเนินการ ฉันได้สรุปส่วนที่ 1 ของซีรี่ส์ Spring สามส่วนของฉันพร้อมตัวอย่างที่สาธิตวิธีการฉีดการพึ่งพาแอปพลิเคชันของคุณ (แทนที่จะสร้างพวกมันเข้าไป) ผ่านคอนเทนเนอร์ Spring IOC
ฉันใช้กรณีการใช้งานของการเปิดบัญชีเครดิตออนไลน์เป็นจุดเริ่มต้น สำหรับการใช้งานนี้ การเปิดบัญชีเครดิตกำหนดให้ผู้ใช้โต้ตอบกับบริการต่อไปนี้:
☆บริการจัดอันดับเครดิต ค้นหาข้อมูลประวัติเครดิตของผู้ใช้
☆ บริการเชื่อมโยงข้อความระยะไกลเพื่อแทรกข้อมูลลูกค้าและเชื่อมต่อข้อมูลลูกค้ากับข้อมูลบัตรเครดิตและข้อมูลธนาคารเพื่อการหักบัญชีอัตโนมัติ (หากจำเป็น)
☆ บริการอีเมลเพื่อส่งอีเมลเกี่ยวกับสถานะบัตรเครดิตไปยังผู้ใช้
สามอินเทอร์เฟซ
สำหรับตัวอย่างนี้ ฉันถือว่าบริการต่างๆ มีอยู่แล้วและบูรณาการเข้าด้วยกันอย่างหลวมๆ รายการต่อไปนี้แสดง API สำหรับบริการทั้งสาม
รายชื่อ 3 CreditRatingInterface
ส่วนต่อประสานสาธารณะ CreditRatingInterface {
บูลีนสาธารณะ getUserCreditHistoryInformation (ICustomer iCustomer);
-
อินเทอร์เฟซอันดับเครดิตที่แสดงในรายการ 3 ให้ข้อมูลประวัติเครดิต จำเป็นต้องมีวัตถุลูกค้าที่มีข้อมูลลูกค้า การใช้งานอินเทอร์เฟซนี้จัดทำโดยคลาส CreditRating
รายการ 4. CreditLinkingInterface
ส่วนต่อประสานสาธารณะ CreditLinkingInterface {
สตริงสาธารณะ getUrl();
setUrl เป็นโมฆะสาธารณะ (URL สตริง);
โมฆะสาธารณะ linkCreditBankAccount() พ่นข้อยกเว้น;
-
อินเทอร์เฟซการเชื่อมโยงเครดิตจะรวมข้อมูลประวัติเครดิตเข้ากับข้อมูลธนาคาร (หากจำเป็น) และแทรกข้อมูลบัตรเครดิตของผู้ใช้ อินเทอร์เฟซลิงก์เครดิตเป็นบริการระยะไกล และการสืบค้นจะดำเนินการผ่านเมธอด getUrl() URL ถูกตั้งค่าโดยกลไกการกำหนดค่า bean ของ Spring Framework ซึ่งฉันจะหารือในภายหลัง การใช้งานอินเทอร์เฟซนี้จัดทำโดยคลาส CreditLinking
รายการ 5. อินเทอร์เฟซอีเมล
อินเทอร์เฟซสาธารณะ EmailInterface {
โมฆะสาธารณะ sendEmail (ICustomer iCustomer);
สตริงสาธารณะ getFromEmail();
โมฆะสาธารณะ setFromEmail (สตริงจากอีเมล);
สตริงสาธารณะ getPassword();
setPassword เป็นโมฆะสาธารณะ (รหัสผ่านสตริง);
สตริงสาธารณะ getSmtpHost();
โมฆะสาธารณะ setSmtpHost (สตริง smtpHost);
สตริงสาธารณะ getUserId() ;
โมฆะสาธารณะ setUserId (รหัสผู้ใช้สตริง);
บทความนี้มาจากบล็อก CSDN โปรดระบุแหล่งที่มาเมื่อพิมพ์ซ้ำ: http://blog.csdn.net/loshu2003/archive/2009/12/31/5111344.aspx
-