विश्व में स्प्रिंग बीन्स क्या हैं?

397

मुझे स्प्रिंग बीन्स की उच्च-स्तरीय परिभाषा मिलनी बाकी है, जिसे मैं समझ सकता हूं। मैं उन्हें ग्रिल्स प्रलेखन और पुस्तकों में अक्सर संदर्भित करता हूं, लेकिन मुझे लगता है कि यह समझना कि वे क्या फायदेमंद होंगे। तो वसंत सेम क्या हैं? उनका उपयोग कैसे किया जा सकता है? क्या उन्हें डिपेंडेंसी इंजेक्शन के साथ कुछ करना है?

java spring grails

— grantmcconnaughey
स्रोत

2

कब्रें स्प्रिंग पर बनी हैं। यदि आप स्प्रिंग से परिचित नहीं हैं, तो मेरा सुझाव है कि आप कम से कम इस पर कुछ सामग्री पढ़ें ताकि आप उन तकनीकों को समझ सकें जो आप उपयोग कर रहे हैं।

— जेफ मंजरी

26

मुझे लगता है कि यहाँ टिप्पणियाँ उसी समस्या से ग्रस्त हैं जो ओपी ग्रिल्स डॉक्स और किताबों के संदर्भों में देखती है: वे केवल उन लोगों के लिए आसान हैं जो पहले से ही जानते हैं कि उनका क्या मतलब है। मुझे लगता है कि विकिपीडिया का लेख एक शुरुआत के लिए इसे बेहतर बताता है।

— एलियास डोर्नेलेस

12

@MarcoForberg का एक कारण यह है कि स्प्रिंग का प्राचीन संस्करण Google पर शीर्ष हिट है क्योंकि लोग इसे SO जैसी जगहों से लिंक करते रहते हैं ... static.springsource.org/spring/docs/3.2.x/… बेहतर होगा इन दिनों शुरू करने के लिए जगह है।

— इयान रॉबर्ट्स

5

+1 @IanRoberts। यहाँ वर्तमान एक है ।

— dhahapatro

यह मदद नहीं करता है कि वे आईओसी को यह कहकर परिचय देते हैं कि आईओसी को डीआई के रूप में भी जाना जाता है। वे हां से संबंधित हैं, लेकिन IoC ज्यादा व्यापक है।

— अलुआन हदद

212

आपके अनुप्रयोग की रीढ़ बनाने वाली और स्प्रिंग आईओसी * कंटेनर द्वारा प्रबंधित वस्तुओं को सेम कहा जाता है। बीन एक ऐसी वस्तु है, जो स्प्रिंग आईओसी कंटेनर द्वारा तुरंत तैयार की जाती है, इकट्ठी की जाती है और अन्यथा प्रबंधित की जाती है। ये सेम कॉन्फ़िगरेशन मेटाडेटा के साथ बनाए जाते हैं जो आप कंटेनर को आपूर्ति करते हैं, उदाहरण के लिए, एक्सएमएल <bean/>परिभाषाओं के रूप में।

स्प्रिंगसोर्स से सेम और स्कोप के बारे में अधिक जानने के लिए :

जब आप एक बीन परिभाषा बनाते हैं तो आप जो वास्तव में बना रहे होते हैं वह उस बीन परिभाषा द्वारा परिभाषित वर्ग के वास्तविक उदाहरण बनाने के लिए एक नुस्खा है। यह विचार कि बीन की परिभाषा एक नुस्खा है, महत्वपूर्ण है, क्योंकि इसका मतलब है कि, एक वर्ग की तरह, आप संभवतः एक ही नुस्खा से निर्मित कई वस्तु उदाहरण हो सकते हैं।

आप न केवल विभिन्न निर्भरता और कॉन्फ़िगरेशन मानों को नियंत्रित कर सकते हैं, जिन्हें किसी विशेष बीन परिभाषा से बनाई गई किसी वस्तु में प्लग किया जाना है, लेकिन विशेष बीन परिभाषा से बनाई गई वस्तुओं का दायरा भी। यह दृष्टिकोण बहुत शक्तिशाली है और आपको जावा क्लास स्तर पर किसी वस्तु के दायरे को 'सेंकना' करने के बजाय कॉन्फ़िगरेशन के माध्यम से आपके द्वारा बनाई गई वस्तुओं के दायरे को चुनने की सुविधा देता है। बीन्स को कई स्कोप में से एक में तैनात किया जा सकता है

* IoC: नियंत्रण का उलटा

— जुन्न अहसन
स्रोत

10

तो ये ऐसी वस्तुएं हैं जो कंटेनर का प्रबंधन करता है और मुझे स्पर्श नहीं करना पड़ता है, लेकिन अगर मैं बीन तक पहुंच चाहता हूं तो कुछ तरीकों को कॉल कर सकता है या गुणों को प्राप्त कर सकता है, तो मैं बीन के लिए "पूछ" सकता हूं?

— अनुदानमोनूघेय

22

@grantmc यह उस तरह का है, जैसे कि नियंत्रण की चीज को उलटने के अलावा "पूछना" के विपरीत समझा जाना चाहिए: चीजों के लिए "पूछने" के बजाय, आप "घोषणा" करते हैं कि आपको इसकी आवश्यकता होगी। और फिर, जब आप ऐप को स्टार्टअप करते हैं, तो फ्रेमवर्क सभी घोषणाओं की जांच करेगा और उपयुक्त उदाहरण सेट करेगा।

— एलियास डोर्नेलेस

6

@ जेल मैं कैसे घोषित करता हूं कि मुझे इसकी आवश्यकता है? क्या यह तब है जब मैं उपयोग कर रहा हूँ @Autowired? या बस जब मैं अपना importएस करता हूं ?

— मिखाइल बैटसर

16

वसंत नवागंतुकों के लिए IoC का अर्थ क्या है, इसे परिभाषित करना उपयोगी होगा।

— लुकास

4

@ लुकास सहमत। IoC "नियंत्रण का व्युत्क्रम" है। उत्कृष्ट प्रश्नोत्तर देखें: स्प्रिंग फ्रेमवर्क में डिपेंडेंसी इंजेक्शन और नियंत्रण का व्युत्क्रम क्या है? और नियंत्रण का व्युत्क्रम क्या है? ।

— म्हाड्रेक

135

स्प्रिंग बीन्स केवल उदाहरण की वस्तुएं हैं जिन्हें स्प्रिंग कंटेनर द्वारा प्रबंधित किया जाता है, अर्थात्, वे फ्रेमवर्क द्वारा बनाई और वायर्ड की जाती हैं और "वस्तुओं का एक बैग" (कंटेनर) में डाल दिया जाता है, जहां से आप उन्हें बाद में प्राप्त कर सकते हैं।

"वायरिंग" भाग में निर्भरता इंजेक्शन के बारे में क्या है, इसका क्या मतलब है कि आप बस यह कह सकते हैं कि "मुझे इस चीज की आवश्यकता होगी" और फ्रेमवर्क आपको उचित उदाहरण प्राप्त करने के लिए कुछ नियमों का पालन करेगा।

किसी के लिए जो वसंत ऋतु के लिए उपयोग नहीं किया जाता है, मुझे लगता है कि विकिपीडिया वसंत के लेख का अच्छा वर्णन है :

सेंट्रल टू द स्प्रिंग फ्रेमवर्क कन्ट्रोल कंटेनर का विलोम है, जो परावर्तन का उपयोग करके जावा ऑब्जेक्ट को कॉन्फ़िगर और प्रबंधित करने का एक सुसंगत साधन प्रदान करता है। कंटेनर विशिष्ट वस्तुओं के ऑब्जेक्ट जीवन चक्रों को प्रबंधित करने के लिए जिम्मेदार है: इन वस्तुओं को बनाना, उनकी प्रारंभिक विधियों को कॉल करना और इन वस्तुओं को एक साथ तार करके कॉन्फ़िगर करना।

कंटेनर द्वारा बनाई गई वस्तुओं को प्रबंधित ऑब्जेक्ट या सेम भी कहा जाता है । कंटेनर को XML फ़ाइलों को लोड करके या कॉन्फ़िगरेशन कक्षाओं पर विशिष्ट जावा एनोटेशन का पता लगाकर कॉन्फ़िगर किया जा सकता है। इन डेटा स्रोतों में सेम की परिभाषाएँ हैं जो सेम बनाने के लिए आवश्यक जानकारी प्रदान करती हैं।

वस्तुओं को निर्भरता देखने या निर्भरता इंजेक्शन के माध्यम से प्राप्त किया जा सकता है । डिपेंडेंसी लुकअप एक ऐसा पैटर्न है, जहां एक कॉलर किसी ऑब्जेक्ट के लिए एक विशिष्ट नाम या एक विशिष्ट प्रकार के साथ कंटेनर ऑब्जेक्ट पूछता है। डिपेंडेंसी इंजेक्शन एक ऐसा पैटर्न है, जहां कंस्ट्रक्टर ऑब्जेक्ट्स, प्रॉपर्टीज़ या फैक्ट्री मेथड्स के ज़रिए ऑब्जेक्ट्स को अन्य ऑब्जेक्ट्स के नाम से पास करता है।

— एलियास डोर्नेल्स
स्रोत

एक उदाहरण केवल वस्तुओं के लिए एक और शब्द है। जब आप "ऑब्जेक्ट इंस्टेंस" का उपयोग करते हैं तो क्या आप ऑब्जेक्ट ऑब्जेक्ट नहीं कह रहे हैं?

— udun

दिलचस्प सवाल। विकिपीडिया के अनुसार मुझे इसके बजाय "इंस्टेंस ऑब्जेक्ट्स" कहना चाहिए: en.wikipedia.org/wiki/Instance_(computer_science)

— एलियास डॉर्नेल्स

2

खरगोश का छेद गहरा होता जाता है।

— udun

मैंने आज महसूस किया है कि "ऑब्जेक्ट ऑब्जेक्ट्स" (और इसलिए ऑब्जेक्ट इंस्टेंस) वास्तव में मेरे लिए समझ में आता है क्योंकि मैं उन भाषाओं के लिए उपयोग किया जाता हूं जहां एक क्लास भी एक ऑब्जेक्ट है (इसलिए आपके पास क्लास ऑब्जेक्ट्स हैं, और, ठीक है, "ऑब्जेक्ट" ऑब्जेक्ट्स )। वैसे भी, मैंने विकिपीडिया लेख के अनुसार "उदाहरण वस्तुओं" का उपयोग करने के लिए विवरण अपडेट किया है। ^ ^

— इलायस डॉर्नेल्स

1

@ रूही एक नियमित वस्तु, अर्थात, एक वर्ग का एक उदाहरण - यह चर्चा एक वस्तु को संदर्भित करने के लिए सही अभिव्यक्ति का उपयोग करने के बारे में एक साइडट्रैक थी। :)

— इलायस डॉर्नेल्स

50

पहले हमें वसंत को समझने दें:

वसंत एक हल्का और लचीला ढांचा है।

सादृश्य:

बीन: एक वस्तु है, जिसे स्प्रिंग कंटेनर में बनाया, प्रबंधित और नष्ट किया जाता है। हम मेटाडेटा (या तो xml या एनोटेशन) के माध्यम से स्प्रिंग कंटेनर में एक वस्तु को इंजेक्ट कर सकते हैं, जिसे नियंत्रण का उलटा कहा जाता है।

सादृश्य: मान लें कि किसान बीजों (या फलियों) से खेती कर रहा है। यहाँ, किसान स्प्रिंग फ्रेमवर्क है, फ़ार्मलैंड भूमि स्प्रिंग कंटेनर है, बीन्स स्प्रिंग बीन्स हैं, खेती स्प्रिंग प्रोसेसर्स है।

बीन के जीवन-चक्र की तरह, वसंत फलियों का भी अपना जीवन-चक्र होता है।

img स्रोत

निम्नलिखित वसंत में एक बीन जीवन चक्र का क्रम है:

झटपट: पहले स्प्रिंग कंटेनर को एक्सएमएल फ़ाइल से बीन की परिभाषा मिलती है और बीन को इंस्टेंट करता है।
गुण पॉप्युलेट करें: निर्भरता इंजेक्शन का उपयोग करके, बीन परिभाषा में निर्दिष्ट सभी गुणों को स्प्रिंग पॉप्युलेट करता है।
बीन का नाम सेट करें: यदि बीन लागू होता BeanNameAwareहै, तो स्प्रिंग बीन की आईडी को setBeanName()विधि में बदल देती है।
बीन फैक्ट्री सेट करें: यदि बीन लागू होता है तो BeanFactoryAwareइंटरफ़ेस, वसंत setBeanFactory()विधि के लिए सेमफैक्टिंग पास करता है ।
प्रारंभिक-प्रारंभिककरण: सेम की पोस्ट प्रक्रिया भी कहा जाता है। यदि बीन के साथ कोई बीन बीनपोस्टप्रोसेसर जुड़ा हुआ है, तो स्प्रिंग कॉल postProcesserBeforeInitialization()विधि।
बीन्स को इनिशियलाइज़ करें: यदि बीन लागू होता है IntializingBean, तो इसका afterPropertySet()तरीका कहा जाता है। यदि बीन में इनिट विधि घोषणा है, तो निर्दिष्ट आरंभीकरण विधि कहा जाता है।
शुरुआत के बाद: - यदि कोई BeanPostProcessorsसेम के साथ जुड़ा हुआ है, तो उनके postProcessAfterInitialization()तरीकों को बुलाया जाएगा।
उपयोग करने के लिए तैयार: अब सेम अनुप्रयोग द्वारा उपयोग करने के लिए तैयार है
नष्ट करें: यदि बीन लागू होता है DisposableBean, तो यह destroy()विधि को बुलाएगा

— Premraj
स्रोत

23

वैसे आपने इसे आंशिक रूप से समझा। आपको अपनी आवश्यकता के अनुसार बीन्स को दर्जी बनाना होगा और आवश्यकता पड़ने पर स्प्रिंग कंटेनर को प्रबंधित करने के लिए सूचित करना होगा, एक पद्धति का उपयोग करके, जिसे लोकतांत्रिक रूप से आईओसी ( नियंत्रण का उलटा ) के रूप में जाना जाता है, जिसे मार्टिन फॉलर द्वारा गढ़ा गया , जिसे डिपेंडेंसी इंजेक्शन (डीआई) भी कहा जाता है ।

आप बीन्स को एक तरह से तार करते हैं, ताकि आपको बीन पर किसी भी निर्भरता का तत्काल ध्यान रखने या मूल्यांकन करने की आवश्यकता न हो। यह लोकप्रिय हॉलीवुड सिद्धांत के रूप में जाना जाता है ।

Google इस सवाल में आपके साथ बाढ़ से जुड़े लिंक के अलावा इस पर और अधिक जानकारी प्राप्त करने का सबसे अच्छा साधन है। :)

— dmahapatro
स्रोत

2

यह इंगित नहीं कर सकता कि IoC अवधारणा है, और DI (एक) तकनीक है जिसका उपयोग IoC को प्राप्त करने के लिए किया जा सकता है, वे बदली जाने वाली परिभाषाएं नहीं हैं।

— kekko12

9

वसंत में आईओसी कंटेनर होता है जो बीन के बैग को ले जाता है; निर्माण और विलोपन स्प्रिंग कंटेनर की जिम्मेदारियां हैं। हम बीन को वायरिंग और ऑटो वायरिंग द्वारा स्प्रिंग में डाल सकते हैं। तारों का मतलब है कि हम इसे मैन्युअल रूप से XML फ़ाइल में कॉन्फ़िगर करते हैं और "ऑटो वायरिंग" का मतलब है कि हमने एनोटेशन को जावा फ़ाइल में रखा है, फिर स्प्रिंग स्वचालित रूप से रूट-संदर्भ को स्कैन करता है जहां जावा कॉन्फ़िगरेशन फ़ाइल, इसे बनाते हैं और स्प्रिंग के बैग में डालते हैं।

यहाँ विस्तार URI है जहाँ आपको बीन्स के बारे में अधिक जानकारी मिली है

— यासिर शब्बीर चौधरी
स्रोत

8

वसंत सेम कक्षाएं हैं। वर्ग का उपयोग करने के बजाय (उपयोग करते हुए new), आपको beanएप्लिकेशन संदर्भ से अपने वर्ग प्रकार के कलाकारों के रूप में एक उदाहरण मिलता है, जहां सेम वह है जिसे आपने एप्लिकेशन संदर्भ कॉन्फ़िगरेशन में कॉन्फ़िगर किया था। इस तरह से, पूरे एप्लिकेशन में पूरे आवेदन में सिंगलटन-स्कोप का उदाहरण है। सभी बीन्स को उनके विन्यास क्रम के ठीक बाद में शुरू किया जाता है, आवेदन के संदर्भ के तुरंत बाद। यहां तक कि अगर आपको अपने आवेदन में कोई सेम नहीं मिलता है, तो सभी सेम इंस्टेंस आपके द्वारा एप्लिकेशन संदर्भ बनाने के बाद पहले से ही पल बनाए जाते हैं।

— Downhillski
स्रोत

1

बीन्स कक्षाएं नहीं हैं, लेकिन एक कंटेनर कार्यान्वयन द्वारा प्रबंधित कक्षाओं के उदाहरणों के रूप में ऑब्जेक्ट।

— चतुर्मास

7

स्प्रिंग बीन्स बस वस्तु उदाहरण हैं जो स्प्रिंग आईओसी कंटेनर द्वारा प्रबंधित किए जाते हैं।
स्प्रिंग IOC कंटेनर बीन के बैग को ले जाता है। निर्माण, रखरखाव और विलोपन स्प्रिंग कंटेनर की जिम्मेदारियां हैं।
हम बीन को वायरिंग और ऑटो वायरिंग द्वारा स्प्रिंग में डाल सकते हैं।
तारों का मतलब है कि हम मैन्युअल रूप से इसे XML फ़ाइल में कॉन्फ़िगर करते हैं।
ऑटो वायरिंग का मतलब है कि हम एनोटेशन को जावा फ़ाइल में डालते हैं, फिर स्प्रिंग स्वचालित रूप से रूट-संदर्भ को स्कैन करता है जहां जावा कॉन्फ़िगरेशन फ़ाइल, इसे बनाते हैं और स्प्रिंग के बैग में डालते हैं।

— maniBrock
स्रोत

7

बीन एक पीओजेओ (प्लेन ओल्ड जावा ऑब्जेक्ट) है, जिसे स्प्रिंग कंटेनर द्वारा प्रबंधित किया जाता है।

स्प्रिंग कंटेनर डिफ़ॉल्ट रूप से बीन का केवल एक उदाहरण बनाते हैं। यह बीन स्मृति में कैश्ड है इसलिए बीन के लिए सभी अनुरोध उसी बीन के लिए एक साझा संदर्भ वापस कर देंगे।

@ बीन एनोटेशन एक ऑब्जेक्ट देता है जो स्प्रिंग को एप्लिकेशन के संदर्भ में बीन के रूप में पंजीकृत करता है। उदाहरण बनाने के लिए विधि के अंदर तर्क जिम्मेदार है।

हम @ बीन एनोटेशन का उपयोग कब करते हैं?

जब स्वचालित कॉन्फ़िगरेशन एक विकल्प नहीं है। उदाहरण के लिए जब हम किसी तीसरे पक्ष के पुस्तकालय से घटकों को तार करना चाहते हैं, क्योंकि स्रोत कोड उपलब्ध नहीं है, इसलिए हम @Component के साथ कक्षाओं को एनोटेट नहीं कर सकते।

एक वास्तविक समय परिदृश्य यह हो सकता है कि कोई व्यक्ति अमेज़ॅन एस 3 बाल्टी से कनेक्ट करना चाहता है। क्योंकि स्रोत उपलब्ध नहीं है, उसे एक @bean बनाना होगा।

@Bean
public AmazonS3 awsS3Client() {
    BasicAWSCredentials awsCreds = new BasicAWSCredentials(awsKeyId, accessKey);
    return AmazonS3ClientBuilder.standard().withRegion(Regions.fromName(region))
            .withCredentials(new AWSStaticCredentialsProvider(awsCreds)).build();
}

ऊपर दिए गए कोड का स्रोत -> https://www.devglan.com/spring-mvc/aws-s3-java

क्योंकि मैंने ऊपर @Component Annotation का उल्लेख किया है।

@Component बताता है कि एक एनोटेट वर्ग एक "घटक" है। एनोटेशन-आधारित कॉन्फ़िगरेशन और क्लास पथ स्कैनिंग का उपयोग करते समय ऐसी कक्षाओं को ऑटो-डिटेक्शन के लिए उम्मीदवार माना जाता है।

घटक एनोटेशन एक बीन के रूप में वर्ग को पंजीकृत करता है।

— IonKat
स्रोत

2

स्प्रिंग में, वे ऑब्जेक्ट जो आपके एप्लिकेशन की रीढ़ बनाते हैं और जिन्हें स्प्रिंग IoC कंटेनर द्वारा प्रबंधित किया जाता है, उन्हें सेम के रूप में संदर्भित किया जाता है। एक बीन बस एक ऐसी वस्तु है जिसे स्प्रिंग आईओसी कंटेनर द्वारा तुरंत, इकट्ठा और अन्यथा प्रबंधित किया जाता है;

— user3472473
स्रोत

1

वसंत के लिए, सभी वस्तुएं सेम हैं! स्प्रिंग फ्रेमवर्क में मूल कदम आपकी वस्तुओं को बीन्स के रूप में परिभाषित करना है। बीन्स और कुछ नहीं बल्कि वस्तु उदाहरण हैं जो वसंत ढांचे द्वारा उनकी कक्षा की परिभाषाओं को देखते हुए बनाए जाएंगे। ये परिभाषाएं मूल रूप से कॉन्फ़िगरेशन मेटाडेटा बनाती हैं। रूपरेखा तब एक योजना बनाती है जिसके लिए वस्तुओं को तुरंत तैयार करने की आवश्यकता होती है, जो इस कॉन्फ़िगरेशन मेटाडेटा के आधार पर निर्भरता को सेट करने और इंजेक्ट करने, नए बनाए गए उदाहरण के दायरे आदि की आवश्यकता होती है।

मेटाडेटा की आपूर्ति एक साधारण XML फ़ाइल में की जा सकती है, जैसे पहले अध्याय में। वैकल्पिक रूप से, कोई मेटाडेटा को एनोटेशन या जावा कॉन्फ़िगरेशन के रूप में प्रदान कर सकता है।

पुस्तक: बसंत

— बर्गुइगा मोहम्मद अमीन
स्रोत

1

स्प्रिंग का XML कॉन्फ़िगरेशन बीन्स से बना है और बीन्स मूल रूप से कक्षाएं हैं। वे केवल POJO हैं जिनका उपयोग हम अपने ApplicationContext के अंदर करते हैं। परिभाषित करने वाले बीन्स को नए कीवर्ड की जगह लेने के बारे में सोचा जा सकता है। तो जहाँ भी आप अपने एप्लिकेशन में कीवर्ड नए का उपयोग कर रहे हैं, जैसे:

MyRepository myRepository =new MyRepository ();

आप उस कीवर्ड नए का उपयोग कर रहे हैं, जो कहीं न कहीं आप उस कॉन्फ़िगरेशन को हटाने और XML फ़ाइल में रखने पर देख सकते हैं। तो हम इस तरह कोड करेंगे:

<bean name="myRepository " 
      class="com.demo.repository.MyRepository " />

अब हम बस सेटर इंजेक्शन / कंस्ट्रक्टर इंजेक्शन का उपयोग कर सकते हैं। मैं सेटर इंजेक्शन का उपयोग कर रहा हूं।

public class MyServiceImpl implements MyService {
    private MyRepository myRepository;
    public void setMyRepository(MyRepository myRepository)
        {
    this.myRepository = myRepository ;
        }
public List<Customer> findAll() {
        return myRepository.findAll();
    }
}

— मुहम्मद वकास दिलावर
स्रोत