spring - BeanFactory बनाम ApplicationContext




managed-bean (14)

वसंत दो प्रकार के आईओसी कंटेनर प्रदान करता है, एक XMLBeanFactory और दूसरा ApplicationContext XMLBeanFactory है।

+---------------------------------------+-----------------+--------------------------------+
|                                       | BeanFactory     |       ApplicationContext       |
+---------------------------------------+-----------------+--------------------------------+
| Annotation support                    | No              | Yes                            |
| BeanPostProcessor Registration        | Manual          | Automatic                      |
| implementation                        | XMLBeanFactory  | ClassPath/FileSystem/WebXmlApplicationContext|
| internationalization                  | No              | Yes                            |
| Enterprise services                   | No              | Yes                            |
| ApplicationEvent publication          | No              | Yes                            |
+---------------------------------------+-----------------+--------------------------------+

  1. FileSystemXmlAplicationContext: पूर्ण पथ के माध्यम से बीन्स लोड किया गया।
  2. ClassPathXmlAplicationContext: क्लासस्पाथ के माध्यम से बीन्स लोड किया गया
  3. WebXmlAplicationContext: बीन्स वेब अनुप्रयोग संदर्भ के माध्यम से लोड किया गया।

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

एक अभ्यास के रूप में, मैं अपने नमूना / परीक्षण परियोजनाओं में से एक के लिए एक मुख्य विधि लिख रहा हूं। एक बात जो मैं अस्पष्ट हूं, वह BeanFactory और ApplicationContext बीच सटीक अंतर है - जो कि किस स्थितियों में उपयोग करने के लिए उपयुक्त है?

मैं समझता हूं कि ApplicationContext BeanFactory बढ़ाता है, लेकिन अगर मैं सिर्फ एक साधारण मुख्य विधि लिख रहा हूं, तो क्या मुझे अतिरिक्त कार्यक्षमता की आवश्यकता है जो ApplicationContext प्रदान करता है? और ApplicationContext प्रदान करने के लिए बिल्कुल सही कार्यक्षमता किस तरह की अतिरिक्त कार्यक्षमता प्रदान करती है?

जवाब देने के अलावा "मुझे मुख्य () विधि में किस का उपयोग करना चाहिए", क्या ऐसे मानक या दिशानिर्देश हैं जहां तक ​​इस तरह के परिदृश्य में मुझे किस कार्यान्वयन का उपयोग करना चाहिए? क्या मेरी मुख्य () विधि को XML प्रारूप में बीन / एप्लिकेशन कॉन्फ़िगरेशन पर निर्भर करने के लिए लिखा जाना चाहिए - क्या यह एक सुरक्षित धारणा है, या क्या मैं उपयोगकर्ता को कुछ विशिष्ट में लॉक कर रहा हूं?

और क्या यह उत्तर वेब वातावरण में बदलता है - यदि मेरे किसी भी वर्ग को स्प्रिंग के बारे में पता होना चाहिए, तो क्या उन्हें ApplicationContext आवश्यकता होने की अधिक संभावना है?

किसी भी मदद के लिए धन्यवाद। मुझे पता है कि इन सवालों में से बहुत से प्रश्न शायद मैनुअल में दिए गए हैं, लेकिन मुझे इन दो इंटरफेस और एक दांत-दांत कंघी के साथ मैनुअल के माध्यम से पढ़ने के बिना प्रत्येक के पेशेवर / विपक्ष को स्पष्ट रूप से तोड़ने में कठिनाई हो रही है।


  1. BeanFactory तुलना में BeanFactory अधिक पसंदीदा तरीका है

  2. नए वसंत संस्करणों में BeanFactory को ApplicationContext साथ बदल दिया गया है। लेकिन अभी भी पिछड़ा संगतता के लिए BeanFactory मौजूद है

  3. ApplicationContext extends BeanFactory और इसके निम्नलिखित लाभ हैं
    • यह टेक्स्ट संदेशों के लिए अंतर्राष्ट्रीयकरण का समर्थन करता है
    • यह पंजीकृत श्रोताओं को घटना प्रकाशन का समर्थन करता है
    • यूआरएल और फाइलों जैसे संसाधनों तक पहुंच

अधिकांश भाग के लिए, एप्लिकेशनकॉन्टेक्स्ट को तब तक प्राथमिकता दी जाती है जब तक आपको मोबाइल एप्लिकेशन पर संसाधनों को सहेजने की आवश्यकता न हो।

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

यदि आपका वेब ऐप विकसित करना है, तो यह कहना सुरक्षित है कि आपको XmlWebApplicationContext का उपयोग करने की आवश्यकता होगी।

यदि आप चाहते हैं कि आपके सेम स्प्रिंग के बारे में जागरूक हों, तो आप उन्हें बीनफैक्टरीएवेयर और / या एप्लीकेशनकॉन्टेक्स्टवेयर को कार्यान्वित कर सकते हैं, ताकि आप या तो बीनफैक्टरी या एप्लिकेशन कॉन्टेक्स्ट का उपयोग कर सकें और कौन सा इंटरफ़ेस कार्यान्वित कर सकें।


असल में हम वसंत कंटेनर ऑब्जेक्ट को दो तरीकों से बना सकते हैं

  1. BeatFactory का उपयोग कर
  2. ApplicationContext का उपयोग कर

दोनों इंटरफेस हैं

कार्यान्वयन वर्गों का उपयोग करके हम वसंत कंटेनर के लिए वस्तु बना सकते हैं

मतभेदों में आ रहा है

BeanFactory

  1. एनोटेशन आधारित निर्भरता इंजेक्शन का समर्थन नहीं करता है।

  2. I18N का समर्थन नहीं करता है

  3. डिफ़ॉल्ट रूप से इसका समर्थन आलसी लोडिंग

  4. यह कॉन्फ़िगरेशन को एकाधिक कॉन्फ़िगरेशन फ़ाइलों को अनुमति नहीं देता है।

पूर्व: बीनफ़ैक्टरी संदर्भ = नया एक्सएमएलबीन फैक्ट्री (नया संसाधन ("applicationContext.xml"));

ApplicationContext

  1. समर्थन एनोटेशन आधारित निर्भरता इंजेक्शन[email protected], @PreDestroy

  2. समर्थन I18N

  3. इसके डिफ़ॉल्ट समर्थन से Aggresive लोडिंग।

  4. यह एकाधिक विन्यास फाइलों को विन्यस्त करने की अनुमति देता है।

उदाहरण के लिए:
ApplicationContext संदर्भ = नया क्लासपाथएक्सएक्सप्लिकेशन कॉन्टेक्स्ट ("applicationContext.xml");


एप्लिकेशनकॉन्टेक्स्ट बीनफैक्टरी का एक बड़ा भाई है और यह सब कुछ होगा कि बीनफैक्टरी कई अन्य चीजें प्रदान कर रहे हैं।

मानक org.springframework.beans.factory.BeanFactory लाइफसाइक्ल क्षमताओं के अलावा, एप्लिकेशनकॉन्टेक्स्ट कार्यान्वयन अनुप्रयोगकॉन्टेक्स्टवेयरवेयर बीन्स के साथ-साथ संसाधन लोडरवेयर, एप्लिकेशनवेन्टपुब्लिशरवेयर और संदेशसोर्सवेयरवेयर बीन्स का पता लगाता है और उन्हें आमंत्रित करता है।


ए। बीन फैक्ट्री और एप्लिकेशन संदर्भ के बीच एक अंतर यह है कि जब आप getBean () विधि को कॉल करते हैं तो पूर्व केवल तत्काल बीन होता है, जबकि कंटेनर शुरू होने पर एप्लिकेशनकॉन्टेक्स्ट सिंगलटन बीन को तुरंत चालू करता है, यह GetBean को कॉल करने की प्रतीक्षा नहीं करता है।

ख।

ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");

या

ApplicationContext context = new ClassPathXmlApplicationContext{"spring_dao.xml","spring_service.xml};

आप अपनी परियोजना आवश्यकता के आधार पर एक या अधिक xml फ़ाइल का उपयोग कर सकते हैं। जैसा कि मैं यहां दो एक्सएमएल फाइलों का उपयोग कर रहा हूं यानी दाओ कक्षाओं के लिए सेवा कक्षाओं के लिए कॉन्फ़िगरेशन विवरण के लिए एक। यहां ClassPathXmlAplicationContext एप्लिकेशनकॉन्टेक्स्ट का बच्चा है।

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

घ। बीनफैक्टरी अंतर्राष्ट्रीयकरण यानी i18n के लिए समर्थन प्रदान नहीं करता है लेकिन एप्लिकेशनकॉन्टेक्स्ट इसके लिए समर्थन प्रदान करता है।

ई। बीनफैक्टरी कंटेनर ऑटोस्कैनिंग (समर्थन एनोटेशन आधारित निर्भरता इंजेक्शन) की सुविधा का समर्थन नहीं करता है, लेकिन एप्लीकेशनकॉन्टेक्स्ट कंटेनर का समर्थन करता है।

च। बीनफैक्टरी कंटेनर अनुरोध समय तक एक बीन ऑब्जेक्ट नहीं बनाएगा। इसका मतलब है कि बीनफैक्टरी कंटेनर बीन्स आलसी लोड करता है। जबकि एप्लीकेशनकॉन्टेक्स्ट कंटेनर केवल लोड होने के समय सिंगलटन बीन की ऑब्जेक्ट बनाता है। इसका मतलब है कि शुरुआती लोडिंग है।

जी। बीनफैक्टरी कंटेनर सेम के केवल दो स्कोप (सिंगलटन और प्रोटोटाइप) का समर्थन करते हैं। लेकिन एप्लीकेशनकॉन्टेक्स्ट कंटेनर सभी बीन्स स्कोप का समर्थन करता है।


मिगुएल पिंग ने जो जवाब दिया, उसे जोड़ने के लिए, यहां दस्तावेज़ों का एक और खंड है जो इसका उत्तर भी देता है:

लघु संस्करण: एप्लिकेशन कॉन्टेक्स्ट का उपयोग करें जब तक कि ऐसा करने के लिए आपके पास वास्तव में कोई अच्छा कारण न हो। आप में से उन लोगों के लिए जो ऊपर की सिफारिश के 'लेकिन क्यों' के रूप में थोड़ा अधिक गहराई की तलाश में हैं, पढ़ना जारी रखें।

(किसी भी भावी स्प्रिंग नौसिखियों के लिए इसे पोस्ट करना जो इस प्रश्न को पढ़ सकते हैं)


मुझे लगता है कि यह उल्लेखनीय है कि वसंत 3 के बाद से, यदि आप एक कारखाना बनाना चाहते हैं, तो आप उचित @scope के साथ संयुक्त @configuration एनोटेशन का भी उपयोग कर सकते हैं

@Configuration
public class MyFactory {

    @Bean
    @Scope("prototype")
    public MyClass create() {
        return new MyClass();
    }
}

आपका कारखाना @ComponentScan एनोटेशन या एक्सएमएल कॉन्फ़िगरेशन का उपयोग कर स्प्रिंग कंटेनर द्वारा दिखाई देना चाहिए

Baeldung साइट से वसंत बीन scopes लेख


मेरे लिए, ApplicationContext BeanFactory पर BeanFactory का चयन करने के लिए प्राथमिक अंतर यह प्रतीत होता है कि ApplicationContext सभी बीन्स को पूर्व-तत्काल करेगा। वसंत दस्तावेज़ों से:

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

यह देखते हुए, मैंने शुरुआत में BeanFactory को एकीकरण / प्रदर्शन परीक्षणों में उपयोग के लिए चुना क्योंकि मैं अलग-अलग बीन्स का परीक्षण करने के लिए पूरे एप्लिकेशन को लोड नहीं करना चाहता था। हालांकि - अगर कोई गलत है तो कोई मुझे सही करता है - BeanFactory classpath एक्सएमएल कॉन्फ़िगरेशन का समर्थन नहीं करता है। तो BeanFactory और ApplicationContext BeanFactory प्रत्येक एक महत्वपूर्ण विशेषता प्रदान करता है जिसे मैं चाहता था, लेकिन न तो दोनों ने किया।

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

मैं जो कर रहा हूं वह ClassPathXmlApplicationContext को विस्तार से लोड करने के लिए आलसी लोड बीन्स में विस्तारित कर रहा था:

public class LazyLoadingXmlApplicationContext extends ClassPathXmlApplicationContext {

    public LazyLoadingXmlApplicationContext(String[] configLocations) {
        super(configLocations);
    }

    /**
     * Upon loading bean definitions, force beans to be lazy-initialized.
     * @see org.springframework.context.support.AbstractXmlApplicationContext#loadBeanDefinitions(org.springframework.beans.factory.xml.XmlBeanDefinitionReader)
     */

    @Override
    protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws IOException {
        super.loadBeanDefinitions(reader);
        for (String name: reader.getBeanFactory().getBeanDefinitionNames()) {
            AbstractBeanDefinition beanDefinition = (AbstractBeanDefinition) reader.getBeanFactory().getBeanDefinition(name);
            beanDefinition.setLazyInit(true);
        }
    }

}

वसंत दस्तावेज़ इस पर बहुत अच्छे हैं: 3.8.1। बीनफैक्टरी या एप्लीकेशन कॉन्टेक्स्ट? । उनके पास तुलना के साथ एक टेबल है, मैं एक स्निपेट पोस्ट करूंगा:

बीन फैक्टरी

  • बीन तत्काल / तारों

आवेदन संदर्भ

  • बीन तत्काल / तारों
  • स्वचालित बीनपोस्टप्रोसेसर पंजीकरण
  • स्वचालित BeanFactoryPostProcessor पंजीकरण
  • सुविधाजनक संदेश स्रोत पहुंच (i18n के लिए)
  • आवेदन पत्र प्रकाशन

इसलिए यदि आपको एप्लिकेशन संदर्भ पक्ष पर प्रस्तुत किए गए किसी भी बिंदु की आवश्यकता है, तो आपको एप्लिकेशनकॉन्टेक्स्ट का उपयोग करना चाहिए।


वसंत दस्तावेज़ों से प्राप्त आवेदन संदर्भ बनाम बीन फैक्टरी बनाम फ़ीचर मैट्रिक्स

बीनफैकोटरी और एप्लिकेशन कॉन्टेक्स्ट की विशेषताओं का स्क्रीनशॉट


BeanFactory और ApplicationContext दोनों आपके वसंत आईओसी कंटेनर से सेम प्राप्त करने के तरीके हैं लेकिन अभी भी कुछ अंतर हैं।

बीनफैक्टरी वास्तविक कंटेनर है जो कई बीन की तत्कालता , विन्यास और प्रबंधन करता है। ये सेम आमतौर पर एक-दूसरे के साथ सहयोग करते हैं, और इस प्रकार उनके बीच निर्भरता होती है। ये निर्भरता बीनफैक्टरी द्वारा उपयोग किए गए विन्यास डेटा में परिलक्षित होती है।

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

एक बीनफैक्टरी का प्रतिनिधित्व इंटरफेस "org.springframework.beans.factory" द्वारा किया जाता है, जहां बीनफैक्टरी, जिसके लिए कई कार्यान्वयन होते हैं।

ClassPathResource resource = new ClassPathResource("appConfig.xml");
XmlBeanFactory factory = new XmlBeanFactory(resource);

अंतर

  1. BeanFactory तत्काल बीन जब आप getBean () विधि को कॉल करते हैं, जबकि कंटेनरटेक्स्ट त्वरित होने पर सिंगलटन बीन को कंटेनर शुरू होता है, यह getBean () को कॉल करने की प्रतीक्षा नहीं करता है।

  2. बीनफैक्टरी अंतर्राष्ट्रीयकरण के लिए समर्थन प्रदान नहीं करता है लेकिन एप्लिकेशनकॉन्टेक्स्ट इसके लिए समर्थन प्रदान करता है।

  3. BeanFactory बनाम ApplicationContext के बीच एक और अंतर श्रोता के रूप में पंजीकृत बीन्स में ईवेंट प्रकाशित करने की क्षमता है।

  4. बीनफैक्टरी इंटरफ़ेस के लोकप्रिय कार्यान्वयन में से एक XMLBeanFactory है जबकि ApplicationContext इंटरफ़ेस के लोकप्रिय कार्यान्वयन में से एक क्लासपाथएक्सएक्सप्लिकेशन कॉन्टेक्स्ट है

  5. यदि आप ऑटो वायरिंग का उपयोग कर रहे हैं और बीनफ़ैक्टरी का उपयोग कर रहे हैं, तो आपको एपीआई का उपयोग करके ऑटोवार्डबीनपोस्टप्रोसेसर को पंजीकृत करने की आवश्यकता है, जिसे आप एक्सएमएल में कॉन्फ़िगर कर सकते हैं यदि आप एप्लीकेशनकॉन्टेक्स्ट का उपयोग कर रहे हैं। संक्षेप में बीनफैक्टरी परीक्षण और गैर उत्पादन के उपयोग के लिए ठीक है, लेकिन एप्लीकेशनकॉन्टेक्स्ट अधिक सुविधा युक्त कंटेनर कार्यान्वयन है और इसे बीनफैक्टरी पर पसंद किया जाना चाहिए

  6. डिफ़ॉल्ट रूप से BeanFactory इसका समर्थन डिफ़ॉल्ट समर्थन से आलसी लोडिंग और एप्लिकेशन कॉन्टेक्स्ट Aggresive लोडिंग।


बीनफैक्टरी और एप्लिकेशन कॉन्टेक्स्ट के बीच अंतर:

Org.springframework.beans.factory.BeanFactory और org.springframework.context.AplicationContext इंटरफेस आईओसी कंटेनर के रूप में कार्य करता है। एप्लिकेशन कॉन्टेक्स्ट इंटरफ़ेस बीनफ़ैक्टरी इंटरफ़ेस के शीर्ष पर बनाया गया है। यह वेब अनुप्रयोग के लिए स्प्रिंग के एओपी, संदेश संसाधन हैंडलिंग (आई 18 एन के लिए) इवेंट प्रोपेगेशन, एप्लिकेशन लेयर विशिष्ट संदर्भ (उदाहरण के लिए WebApplicationContext) के साथ सरल एकीकरण जैसे बीनफ़ैक्टरी से कुछ अतिरिक्त कार्यक्षमता जोड़ता है। तो BeanFactory की तुलना में ApplicationContext का उपयोग करना बेहतर है।


बीनफैक्टरी और एप्लिकेशन कॉन्टेक्स्ट के बीच का अंतर निम्न है:

  1. BeanFactory आलसी प्रारंभिक उपयोग करता है लेकिन ApplicationContext उत्सुक प्रारंभिक उपयोग करता है। बीनफैक्टरी के मामले में, जब आप GetBeans () विधि को कॉल करते हैं, तो बीन बनाया जाता है, लेकिन जब अनुप्रयोगकॉन्टेक्स्ट ऑब्जेक्ट बनाया जाता है तो अनुप्रयोगकॉन्टेक्स्ट के मामले में बीन को पहले से बनाया जाता है।
  2. बीनफैक्टरी स्पष्ट रूप से सिंटैक्स का उपयोग करके संसाधन ऑब्जेक्ट प्रदान करती है लेकिन एप्लिकेशन कॉन्टेक्स्ट संसाधन वस्तुओं को स्वयं बनाता है और प्रबंधित करता है।
  3. बीनफैक्टरी इंटरटेरियलाइजेशन का समर्थन नहीं करता है लेकिन एप्लीकेशनकॉन्टेक्स्ट अंतर्राष्ट्रीयकरण का समर्थन करता है।
  4. बीनफैक्टरी एनोटेशन आधारित निर्भरता इंजेक्शन समर्थित नहीं है लेकिन एनोटेशन आधारित निर्भरता इंजेक्शन अनुप्रयोगकॉन्टेक्स्ट में समर्थित है।

बीनफैक्टरी का उपयोग करना:

BeanFactory beanfactory = new XMLBeanFactory(new FileSystemResource("spring.xml")); Triangle triangle =(Triangle)beanFactory.getBean("triangle");

एप्लिकेशन कॉन्टेक्स्ट का उपयोग करना:

ApplicationContext context = new ClassPathXMLApplicationContext("spring.xml") Triangle triangle =(Triangle)beanFactory.getBean("triangle");





applicationcontext