อธิบายวงจรชีวิตของ Spring Bean [พร้อมตัวอย่างการเข้ารหัส]
เผยแพร่แล้ว: 2020-08-12Bean เป็นวัตถุในแอปพลิเคชัน ถั่วจะถูกสร้างขึ้น ใช้ และถูกทำลายในที่สุดเมื่อจุดประสงค์ของมันสิ้นสุดลง นี่คือระยะต่างๆ ของวงจรชีวิตของสปริง วงจรชีวิตของถั่วสปริงทั้งหมดถูกควบคุมโดยคอนเทนเนอร์ Spring IoC (การผกผันของการควบคุม) นั่นคือเหตุผลที่ถั่วเหล่านี้เรียกว่าถั่วสปริง
แหล่งที่มา
สารบัญ
วัฏจักรชีวิตของถั่วสปริง
แหล่งที่มา
ในวงจรชีวิตของถั่วในฤดูใบไม้ผลิ อย่างแรกเลย ถั่วจะถูกสร้างอินสแตนซ์ หลังจากการยกตัวอย่าง ถั่วต้องผ่านขั้นตอนต่างๆ ตามลำดับก่อนที่จะพร้อมใช้ เมื่อไม่จำเป็นต้องใช้ถั่วสำหรับการทำงานใดๆ อีกต่อไป ถั่วก็จะถูกทำลาย
อ่าน: แนวคิดและหัวข้อโครงการฤดูใบไม้ผลิที่น่าตื่นเต้น 18 อันดับแรกสำหรับผู้เริ่มต้น
วงจรชีวิตของถั่วสปริงสามารถควบคุมได้ดังนี้
- การสร้างอินสแตนซ์โดยใช้:
- การเริ่มต้นอินเทอร์เฟซการโทรกลับของBean
- กำหนดเอง init() วิธีการจากไฟล์คอนฟิกูเรชัน bean
- อินเทอร์เฟซที่รับรู้สำหรับการดำเนินการที่แตกต่างกัน
- คำอธิบายประกอบ PostConstruct และ PreDestroy
- การทำลาย
- อินเทอร์เฟซการโทรกลับ DisposableBean
- เมธอด custom destroy() จากไฟล์คอนฟิกูเรชัน bean
อินสแตนซ์ของถั่ว
กระบวนการแรกในวงจรชีวิตของถั่วสปริงคือการสร้างอินสแตนซ์ การสร้าง bean ขึ้นอยู่กับไฟล์การกำหนดค่า JAVA หรือ XML bean สามารถทำได้สองวิธี

พวกเขาเป็น:
- InitializingBean callback interface: การ สร้างอิน สแตนซ์ด้วยวิธีนี้จะทำในเมธอดที่ชื่อ afterPropertiesSet() เมธอดนี้มีอยู่ใน อินเทอร์เฟ ซ org.springframework.beans.factory.InitializingBean ในโปรแกรมด้านล่าง มีการสร้างคลาสซึ่งใช้อินเทอร์เฟซนี้ สิ่งนี้เปิดใช้งานโดยใช้เมธอด afterPropertiesSet() ของอินเทอร์เฟซนั้นในคลาสที่สร้างขึ้น
ต่อไปนี้เป็นโปรแกรมที่แสดงภาพกระบวนการสร้างอินสแตนซ์นี้
นำเข้า org.springframework.beans.factory.InitializingBean;
คลาสสาธารณะ Createbean ใช้ InitializingBean
{
@แทนที่
โมฆะสาธารณะ afterPropertiesSet() พ่นข้อยกเว้น
{
// Bean ถูกเตรียมใช้งาน
}
}
- วิธีการสร้างอินสแตนซ์แบบกำหนดเองในไฟล์คอนฟิกูเรชัน bean: ในกระบวนการนี้ ไฟล์คอนฟิกูเรชันแบบ XML จะถูกใช้ Init-method ของไฟล์นี้ใช้เพื่อตั้งชื่อวิธีการสร้างอินสแตนซ์โดยเฉพาะ เมธอดนี้ใช้ในคลาสสำหรับการสร้างอินสแตนซ์ของ bean คำจำกัดความท้องถิ่นของถั่วเดียวแสดงอยู่ด้านล่าง ด้วยวิธีนี้ เราสามารถสร้างถั่วเม็ดเดียวได้
ถั่ว.xml:
<ถั่ว>
<bean id=”creatingbean” class=”com.workinginjava.work.Creatingbean”
init-method=”createInit” ></bean>
</beans>
เช็คเอาท์: โปรเจ็กต์และหัวข้อ Spring Boot ที่น่าตื่นเต้น 7 อันดับแรกสำหรับผู้เริ่มต้น
ต่อไปนี้เป็นโปรแกรมที่แสดงภาพกระบวนการสร้างอินสแตนซ์นี้โดยการโหลด beans.xml
แพ็คเกจ com.workinginjava.work;
คลาสสาธารณะ Makingbean
{
โมฆะสาธารณะ createInit()
//เมธอด init ที่สร้างขึ้นเองใช้สำหรับการสร้างอินสแตนซ์ของ bean
}
Aware Interfaces: โครงสร้างพื้นฐาน Spring Framework มีอินเทอร์เฟซที่รับรู้หลายส่วน อินเทอร์เฟซเหล่านี้ปลูกฝังพฤติกรรมที่แตกต่างบางอย่างให้กับ bean ที่สร้างขึ้น

อินเทอร์เฟซ Aware ที่สำคัญบางส่วน ได้แก่:
- BeanFactoryAware: setBeanFactory() ให้การเข้าถึงโรงงานถั่วที่สร้างวัตถุ
- BeanNameAware: เมธอด setBeanName() ภายใต้อินเตอร์เฟส BeanNameAware ระบุชื่อของ bean
- ApplicationContextAware: เมธอด setApplicationContext() ภายใต้อินเทอร์เฟซเฉพาะนี้มี ApplicationContext ของ bean
คำอธิบายประกอบ PostConstruct และ PreDestroy: PostConstruct เป็นวิธีการที่มีคำอธิบายประกอบ เรียกว่าหลังจากสร้างถั่วและก่อนที่จะขอวัตถุ PreDestroy ยังเป็นวิธีการที่มีคำอธิบายประกอบ มันถูกเรียกว่าก่อนการทำลายถั่ว
โปรแกรมต่อไปนี้แสดงการใช้คำอธิบายประกอบ
นำเข้า javax.annotation.PostConstruct;
นำเข้า javax.annotation.PreDestroy;
คลาสสาธารณะ BeanWork
{
@โพสต์คอนสตรัค
โมฆะสาธารณะ createInit()
{
// การเริ่มต้นของ bean (PostConstruct)
}
@PreDestroy
โมฆะสาธารณะ createDestroy()
{
//การทำลายถั่ว (PreDestroy)
}
}
createInit() และ createDestroy() เป็นวิธีการเริ่มต้นและการทำลายที่สร้างขึ้นเองของ bean ทำได้โดยใช้ไฟล์การกำหนดค่า XML bean
การทำลายของถั่ว
กระบวนการสุดท้ายในวงจรชีวิตของถั่วสปริงคือกระบวนการทำลายล้าง เป็นกระบวนการเอาถั่วออก การลบ bean ขึ้นอยู่กับไฟล์คอนฟิกูเรชัน JAVA หรือ XML bean
สามารถทำได้สองวิธี
- อินเทอร์เฟซการเรียกกลับของ DisposableBean: การ กำจัดเสร็จสิ้นในวิธีที่ชื่อ destroy() เมธอดนี้มีอยู่ใน อินเทอร์เฟ ซ org.springframework.beans.factory.DisposableBean ในโปรแกรมด้านล่าง มีการสร้างคลาสซึ่งใช้อินเทอร์เฟซนี้ เปิดใช้งานเมธอด destroy() ของอินเทอร์เฟซนั้นในคลาสที่สร้างขึ้น
ต่อไปนี้เป็นโปรแกรมที่แสดงภาพกระบวนการสร้างอินสแตนซ์นี้
นำเข้า org.springframework.beans.factory.DisposableBean;
คลาสสาธารณะ Destroyingbean ใช้ DisposableBean
{
@แทนที่
โมฆะสาธารณะทำลาย () พ่นข้อยกเว้น
{
// ถั่วถูกทำลาย
}
}
- วิธีการสร้างแบบกำหนดเองของการทำลายในไฟล์คอนฟิกูเรชัน bean: ไฟล์คอนฟิกูเรชันแบบ XML ถูกใช้ที่นี่ วิธีทำลายของไฟล์นี้ใช้เพื่อตั้งชื่อวิธีการทำลายโดยเฉพาะ วิธีนี้ใช้ในชั้นเรียนเพื่อทำลายถั่ว คำจำกัดความท้องถิ่นของถั่วเดียวและขั้นตอนในการทำลายมันแสดงอยู่ด้านล่าง
ถั่ว . xml:
<ถั่ว>
<bean id=”destroyingbean” class=”com.workinginjava.work.Destroyingbean”
destroy-method=”createDestroy” ></bean>
</beans>
ต่อไปนี้เป็นโปรแกรมที่แสดงภาพกระบวนการทำลายล้างโดยการโหลด beans.xml:
แพ็คเกจ com.workinginjava.work;
คลาสสาธารณะ Destroyingbean
{
โมฆะสาธารณะ createDestroy()
// วิธีการทำลายแบบกำหนดเองใช้สำหรับการทำลายถั่ว
}

ถั่วสปริงถูกสร้างขึ้นเพื่อวัตถุประสงค์เฉพาะ ดังนั้น ถั่วทุกชนิดจึงต้องผ่านวงจรชีวิตของสปริงที่แตกต่างกัน มีสองวิธีในการเริ่มต้นและสิ้นสุดวงจรชีวิตของ Spring bean หากใช้อินเทอร์เฟซ InitializingBean และ DisposableBean จะผูกโค้ดกับ Spring วิธีที่ดีกว่าคือการระบุ init-method และ destroy-method ในไฟล์คอนฟิกูเรชัน bean
อ่านเพิ่มเติม: เงินเดือนนักพัฒนาฤดูใบไม้ผลิในอินเดีย: สำหรับ Freshers & มีประสบการณ์
เรียนรู้ การพัฒนาซอฟต์แวร์ออนไลน์ จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม Executive PG โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว
ห่อ
ประเด็นเหล่านี้เกี่ยวกับวงจรชีวิตของถั่วสปริงอาจตอบคำถามบางข้อได้ อย่างไรก็ตาม พวกเขาสร้างสิ่งใหม่ๆ ให้กับคุณ – อะไรคือทรัพยากรสำหรับนักพัฒนา Full Stack ที่ต้องการและการใช้กรอบงานสปริง ขอบเขตในด้านนี้คืออะไร? และที่สำคัญจะสร้างอาชีพในโดเมนนี้ได้อย่างไร?
หากคุณสนใจที่จะเรียนรู้เพิ่มเติมเกี่ยวกับการพัฒนาแบบฟูลสแตก โปรดดูประกาศนียบัตร PG ของ upGrad & IIIT-B ด้านการพัฒนาซอฟต์แวร์แบบครบวงจร ซึ่งออกแบบมาสำหรับมืออาชีพที่ทำงานและมีการฝึกอบรมที่เข้มงวดมากกว่า 500 ชั่วโมง โครงการมากกว่า 9 โครงการ และการมอบหมายงาน , สถานะศิษย์เก่า IIIT-B, โครงการหลักที่นำไปปฏิบัติได้จริง & ความช่วยเหลือด้านงานกับบริษัทชั้นนำ