बीनफैक्ट्री बनाम एप्लीकेशनकोटेक्स्ट

235

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

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

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

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

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

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

spring managed-bean applicationcontext

— मैट बी
स्रोत

209

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

बीन फैक्टरी

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

आवेदन प्रसंग

बीन तत्काल / तारों
स्वचालित बीनपोस्टप्रोसेसर पंजीकरण
स्वचालित बीनफैक्टरीपोस्टप्रोसेसर पंजीकरण
सुविधाजनक मैसेज सोर्स एक्सेस (i18n के लिए)
ApplicationEvent प्रकाशन

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

— मिगुएल पिंग
स्रोत

3

BeanFactory हल्का है, लेकिन यदि आप "असली के लिए" स्प्रिंग का उपयोग करने जा रहे हैं, तो आप ApplicationContext के साथ जा सकते हैं: इसमें बहुत कम ओवरहेड शामिल हैं यदि आप इसकी फैंसी विशेषताओं का उपयोग नहीं करते हैं, लेकिन वे अभी भी उपलब्ध हैं के लिए अगर / जब आप उनका उपयोग करते हैं।

— MetroidFan2002

2

इसका क्या मतलब है जब आप कहते हैं "स्वचालित बीनपोस्टप्रोसेसर रिग्रेसरेशन"? क्या इसका मतलब यह है कि वर्ग को उस इंटरफ़ेस को लागू नहीं करना है?

— आबिदी

2

ApplicationContext बीनफैक्टिंग के खिलाफ एओपी का समर्थन करता है।

— इनिनप्रसर

1

साथ BeanFactoryहम निर्माता मापदंडों गतिशील लेकिन साथ पारित कर सकते हैं ApplicationContextहम ऐसा नहीं कर सकते हैं।

— हाफ ब्लड प्रिंस

1

लिंक्ड स्प्रिंग डॉक्यूमेंटेशन का एक महत्वपूर्ण नोट: "स्प्रिंग 2.0 और इसके बाद के संस्करण बीनपोस्टप्रोसेसर विस्तार बिंदु (निकटता और इस तरह के प्रभाव के लिए) का भारी उपयोग करते हैं, और यदि आप सिर्फ एक सादे बीनफैक्टरी का उपयोग कर रहे हैं तो लेनदेन जैसे समर्थन की एक उचित राशि है। और AOP प्रभावी नहीं होगा (कम से कम आपके हिस्से में कुछ अतिरिक्त कदम के बिना नहीं)। "

— mark.monteiro

52

स्प्रिंग IOC कंटेनर के दो प्रकार प्रदान करता है, एक है XMLBeanFactoryऔर दूसरा है ApplicationContext।

+---------------------------------------+-----------------+--------------------------------+
|                                       | 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                            |
+---------------------------------------+-----------------+--------------------------------+

FileSystemXmlApplicationContext पूरे रास्ते से भरी हुई बीन्स।
ClassPathXmlApplicationContext CLASSPATH के माध्यम से भरी हुई बीन्स
XMLWebApplicationContextऔर AnnotationConfigWebApplicationContextवेब एप्लिकेशन संदर्भ के माध्यम से सेम लोड किया गया।
AnnotationConfigApplicationContext एनोटेशन आधारित कॉन्फ़िगरेशन से स्प्रिंग सेम लोड हो रहा है।

उदाहरण:

ApplicationContext applicationContext = new AnnotationConfigApplicationContext(BeansConfiguration.class);

ApplicationContextकंटेनर एक ContextLoaderListenerया ContextLoaderServletएक में परिभाषित web.xmlऔर द्वारा ContextLoaderPluginपरिभाषित किया गया है struts-config.xml।

नोट : XmlBeanFactoryहै पदावनत के पक्ष में स्प्रिंग 3.1 के रूप में DefaultListableBeanFactoryऔर XmlBeanDefinitionReader।

— Premraj
स्रोत

2

इसकी नहीं AnnotationConfigApplicationContext -AnnotationConfigWebApplicationContext- ClassPathXmlApplicationContext नीचे चित्र में

— अखिल जैन

48

मेरे लिए, चुनने के लिए प्राथमिक अंतर BeanFactoryखत्म हो गया ApplicationContextहै कि हो रहा है ApplicationContextपूर्व इन्स्तांत सेम के सभी होगा। से वसंत डॉक्स :

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

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

पास जैसा कि मैं बता सकता हूं, डिफ़ॉल्ट तात्कालिक व्यवहार को ओवरराइड करने के बारे में प्रलेखन में नोट कॉन्फ़िगरेशन में होता है, और यह प्रति-सेम है, इसलिए मैं 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);
        }
    }

}

— लाइल
स्रोत

2

मेरा तर्क है कि यदि आपकी इकाई परीक्षण आपके पूर्ण स्प्रिंग संदर्भ को लोड कर रहे हैं, तो वे "इकाई परीक्षण" नहीं हैं, लेकिन एकीकरण परीक्षण।

— मैट बी

1

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

— लील

2

BeanFactory doesn't support classpath XML configuration.मुझे लगता है कि यह करता है: stackoverflow.com/questions/5231371/…

— Xtreme बाइकर

29

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

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

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

— मैट बी
स्रोत

19

ApplicationContext से अधिक पसंदीदा तरीका है BeanFactory
नए वसंत संस्करणों के BeanFactoryसाथ बदल दिया गया है ApplicationContext। लेकिन अभी भी BeanFactoryपिछड़े कॉम्पैटिबिलिटी के लिए मौजूद है
ApplicationContext extends BeanFactory और निम्नलिखित लाभ हैं
- यह पाठ संदेशों के लिए अंतर्राष्ट्रीयकरण का समर्थन करता है
- यह पंजीकृत श्रोताओं को ईवेंट प्रकाशन का समर्थन करता है
- URL और फ़ाइलों जैसे संसाधनों तक पहुँच

— श्रीनिवास रेड्डी
स्रोत

13

ApplicationContext: यह स्प्रिंग कॉन्फ़िगरेशन फ़ाइल में कॉन्फ़िगर की गई स्प्रिंग बीन्स को लोड करता है, और स्प्रिंग बीन के जीवन चक्र को प्रबंधित करता है और जब कंटेनर STARTS.It तब तक इंतजार नहीं करेगा जब तक गेटबैन ("स्प्रिंगबैनरी") कहा जाता है।

बीनफैक्टरी यह स्प्रिंग कॉन्फ़िगरेशन फ़ाइल में कॉन्फ़िगर की गई स्प्रिंग बीन्स को लोड करती है, जब हम getBean ("स्प्रिंगबीनेफ़र") कहते हैं तो स्प्रिंग बीन के जीवन चक्र का प्रबंधन करते हैं। जब हम स्प्रिंगबिन जीवन चक्र शुरू होने के समय गेटबिन ("स्प्रिंगबीनेफ़र") कहते हैं। ।

— विनोद
स्रोत

12

मुझे लगता है कि ApplicationContext का उपयोग करना हमेशा बेहतर होता है, जब तक कि आप मोबाइल वातावरण में न हों जैसे किसी और ने पहले ही कहा हो। ApplicationContext में अधिक कार्यक्षमता है और आप निश्चित रूप से PostProcessors जैसे RequiredAnnotationBeanPostProcessor, AutowiredAnnotationBeanPostProcessor और CommonAnnotationBostPostProcessor का उपयोग करना चाहते हैं, जो आपकी स्प्रिंग कॉन्फ़िगरेशन फ़ाइलों को सरल बनाने में मदद करेगा, और आप @Request जैसे @Rensements @ का उपयोग कर सकते हैं ।

यहां तक कि अगर आप सभी सामान ApplicationContext ऑफ़र का उपयोग नहीं करते हैं, तो वैसे भी इसका उपयोग करना बेहतर है, और फिर बाद में यदि आप कुछ संसाधन सामान जैसे संदेश या पोस्ट प्रोसेसर, या अन्य स्कीमा का उपयोग ट्रांजेक्शनल एडवाइस और इस तरह से करने का निर्णय लेते हैं, तो आप पहले से ही एक ApplicationContext होगा और उसे किसी भी कोड को बदलने की आवश्यकता नहीं होगी।

यदि आप एक स्टैंडअलोन ऐप लिख रहे हैं, तो ClassPathXmlApplicationContext का उपयोग करके अपने मुख्य तरीके में ApplicationContext को लोड करें, और मुख्य बीन प्राप्त करें और अपने ऐप को शुरू करने के लिए इसके रन () या (जो भी विधि) को लागू करें। यदि आप एक वेब ऐप लिख रहे हैं, तो Web.xml में ContextLoaderListener का उपयोग करें ताकि यह ApplicationContext बनाए और आप बाद में इसे ServletContext से प्राप्त कर सकते हैं, चाहे आप JSP, JSF, JSTL, स्ट्रट्स, टेपेस्ट्री आदि का उपयोग कर रहे हों। ।

इसके अलावा, याद रखें कि आप कई स्प्रिंग कॉन्फ़िगरेशन फ़ाइलों का उपयोग कर सकते हैं और आप कंस्ट्रक्टर में सभी फ़ाइलों को सूचीबद्ध करके या (संदर्भ के लिए उन्हें संदर्भ में सूचीबद्ध करके ApplicationContext बना सकते हैं) ContextLoaderListener के लिए), या आप केवल एक मुख्य कॉन्फ़िगरेशन फ़ाइल को लोड कर सकते हैं, जिसमें आपके पास है आयात विवरण। आप <आयात संसाधन = "otherfile.xml" /> का उपयोग करके किसी अन्य स्प्रिंग कॉन्फ़िगरेशन फ़ाइल में एक स्प्रिंग कॉन्फ़िगरेशन फ़ाइल आयात कर सकते हैं, जो मुख्य प्रोग्राम विधि में ApplicationContext बनाने और केवल एक स्प्रिंग कॉन्फ़िगरेशन फ़ाइल लोड करने पर बहुत उपयोगी है।

— Chochos
स्रोत

6

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

मुझे XML प्रारूप के आधार पर निश्चित नहीं है, लेकिन मुझे पूरा यकीन है कि ApplicationContext के सबसे सामान्य कार्यान्वयन XML वाले होते हैं जैसे कि ClassPathXmlApplicationContext, XmlWebApplicationContext, और FileSystemXmlApplicationContext। वे केवल तीन हैं जिनका मैंने कभी उपयोग किया है।

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

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

— रयान थेम्स
स्रोत

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

— एम। आतिफ रियाज़

6

BeanFactory और ApplicationContext के बीच अंतर निम्नलिखित हैं:

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

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

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

ApplicationContext का उपयोग करना:

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

— रमन गुप्ता
स्रोत

5

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

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

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

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

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

अंतर

जब आप GetBean () विधि को कॉल करते हैं तो BeanFactory तत्काल बीन, जबकि कंटेनर चालू होने पर ApplicationContext Instantiate Singleton बीन, यह GetBean () कहे जाने की प्रतीक्षा नहीं करता है।
बीनफैक्ट्री अंतर्राष्ट्रीयकरण के लिए समर्थन प्रदान नहीं करता है लेकिन ApplicationContext इसके लिए समर्थन प्रदान करता है।
BeanFactory बनाम ApplicationContext के बीच एक और अंतर श्रोता के रूप में पंजीकृत सेम की घटना को प्रकाशित करने की क्षमता है।
BeanFactory इंटरफ़ेस के लोकप्रिय कार्यान्वयन में से एक XMLBeanFactory है, जबकि ApplicationContext इंटरफ़ेस के लोकप्रिय कार्यान्वयन में से एक ClassPathXmlApplicationContext है ।
आप स्वत: तारों का उपयोग करने और उपयोग कर रहे हैं BeanFactory आप रजिस्टर करने की आवश्यकता की तुलना में AutoWiredBeanPostProcessor एपीआई जो आप XML में कॉन्फ़िगर करता है, तो आप उपयोग कर रहे कर सकते हैं का उपयोग कर ApplicationContext । संक्षेप में, बीनफैक्टिंग परीक्षण और गैर-उत्पादन उपयोग के लिए ठीक है, लेकिन ApplicationContext अधिक समृद्ध कंटेनर कार्यान्वयन की सुविधा है और इसे बीनफैक्टरी के पक्ष में होना चाहिए
डिफ़ॉल्ट रूप से इसके समर्थन में बीनफैक्टिंग आलसी लोडिंग और डिफ़ॉल्ट समर्थन एग्र्रेसिव लोडिंग द्वारा एप्लिकेशनकनेक्ट ।

— दिव्येश कंजरिया
स्रोत

क्या आप कृपया अपने # 1 को अधिक स्पष्ट रूप से समझा सकते हैं, अगर मैंने अपनी स्प्रिंग कॉन्फिग फाइल में सिंगलटन बीन को परिभाषित किया है तो स्प्रिंग कंटेनर उसी का सिंगलटन बनाएंगे, इससे कोई फर्क नहीं पड़ता कि क्या बीनफैक्टरी या एप्लीकेशन कॉन्टेक्स्ट है।

— pjj

4

बीन फैक्टरी की सुविधा मैट्रिक्स बनाम एप्लीकेशन प्रसंग वसंत डॉक्स से अलग है

_{BeanFacotry और ApplicationContext की सुविधाओं का स्क्रीनशॉट}

— सौभाग्यशाली
स्रोत

3

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

ख।

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

या

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

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

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

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

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

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

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

— rajvineet
स्रोत

बिंदु a और f समान हैं। एक साथ जोड़ा जा सकता है।

— d131310

3

मूल रूप से हम दो तरीकों से स्प्रिंग कंटेनर ऑब्जेक्ट बना सकते हैं

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

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

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

अंतर आ रहा है

बीनफैक्ट्री:

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

ex: बीनफैक्टरी संदर्भ = नया XmlBeanFactory (नया संसाधन ("applicationContext.xml"));

ApplicationContext

समर्थन एनोटेशन आधारित निर्भरता इंजेक्शन ।-@Autowired, @PreDestroy
I18N का समर्थन करें
डिफ़ॉल्ट रूप से इसका समर्थन एग्रेसिव लोडिंग है।
यह कई कॉन्फ़िगरेशन फ़ाइलों को कॉन्फ़िगर करने की अनुमति देता है।

पूर्व:
ApplicationContext संदर्भ = नया ClasspathXmlApplicationContext ("applicationContext.xml");

— श्रवणकुमार अखिरला
स्रोत

1

इस दस्तावेज़ को स्प्रिंग डॉक्स से देखें:

http://static.springsource.org/spring/docs/3.2.x/spring-framework-reference/html/beans.html#context-introduction-ctx-vs-beanfactory

५.१५.१ बीनफैक्ट्री या एप्लीकेशनकनेक्ट?

एक ApplicationContext का उपयोग करें जब तक कि आपके पास ऐसा न करने का एक अच्छा कारण है।

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

— विजयन श्रीनिवासन
स्रोत

1

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

मानक org.springframework.beans.factory.BeanFactory जीवनचक्र क्षमताओं के अलावा, ApplicationContext कार्यान्वयन का पता लगाते हैं और ApplicationContextAware बीन्स के साथ-साथ रिसोर्सएडलेवरवेयर, ApplicationEventPublisherAware और MessageSourceAware बीन्स भी बनाते हैं।

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

1

वास्तविक समय के परिदृश्य में, स्प्रिंग IOC कोर कंटेनर (बीनफैक्टिक) और उन्नत J2EE कंटेनर (ApplicationContext) के बीच अंतर निम्नानुसार है।

BeanFactory बीन्स के लिए (यानी POJO वर्गों के लिए) स्प्रिंग में वर्णित वस्तुओं को बनाएगा। xml फ़ाइल ( <bean></bean>) केवल जब आप .getBean () विधि को कॉल करते हैं, लेकिन ApplicationContext सभी बीन्स के लिए ऑब्जेक्ट बनाता है ( <bean></bean>यदि इसका दायरा नहीं है) स्पष्ट रूप से "प्रोटोटाइप" के रूप में उल्लेख किया गया है जो वसंत में कॉन्फ़िगर किया गया है। स्प्रिंग को लोड करते समय। xml फ़ाइल।
बीनफैक्टिंग: (आलसी कंटेनर क्योंकि यह केवल सेम के लिए ऑब्जेक्ट बनाता है जब आप उपयोगकर्ता / मुख्य वर्ग से स्पष्ट रूप से कॉल करते हैं)
```
/*
 * Using core Container - Lazy container - Because it creates the bean objects On-Demand
 */
//creating a resource
Resource r = (Resource) new ClassPathResource("com.spring.resources/spring.xml");
//creating BeanFactory 
BeanFactory factory=new XmlBeanFactory(r);

//Getting the bean for the POJO class "HelloWorld.java"
HelloWorld worldObj1 = (HelloWorld) factory.getBean("test");
```
ApplicationContext: (वसंत को लोड करते समय सभी सिंगलटन बीन्स के ऑब्जेक्ट बनाने के कारण ईगर कंटेनर)
```
ApplicationContext context = new ClassPathXmlApplicationContext("com/ioc/constructorDI/resources/spring.xml");
```
तकनीकी रूप से, ApplicationContext का उपयोग करने की सिफारिश की जाती है क्योंकि वास्तविक समय के अनुप्रयोगों में, बीन ऑब्जेक्ट बनाए जाएंगे जबकि एप्लिकेशन सर्वर में ही शुरू हो रहा है। यह उपयोगकर्ता के अनुरोध के लिए प्रतिक्रिया समय कम कर देता है क्योंकि ऑब्जेक्ट पहले से ही प्रतिक्रिया के लिए उपलब्ध हैं।

— KarthikPon
स्रोत

स्टैक ओवरफ्लो एक मंच नहीं है, इसलिए मैंने आपके उत्तर को सवाल के सीधे जवाब देने के लिए संपादित किया है और चर्चा को आमंत्रित करने से बचें।

— जेफरी बोसबोम

0

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

@Configuration
public class MyFactory {

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

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

बॉल्डिंग साइट से स्प्रिंग बीन स्कोप्स लेख

— रोनन क्विलेवरे
स्रोत

0

गैर-वेब अनुप्रयोगों के लिए बीनफैक्टिंग का उपयोग करें क्योंकि यह केवल सिंगलटन और प्रोटोटाइप बीन-स्कोप का समर्थन करता है।

जबकि ApplicationContext कंटेनर सभी बीन-स्कोप का समर्थन करता है, इसलिए आपको इसे वेब अनुप्रयोगों के लिए उपयोग करना चाहिए।

— अरुण राज
स्रोत

0

संक्षेप में:

ApplicationContext BeanFactory की सभी कार्यक्षमता भी शामिल है। आमतौर पर पूर्व का उपयोग करने की सिफारिश की जाती है।

कुछ सीमित परिस्थितियां हैं जैसे कि मोबाइल एप्लिकेशन, जहां मेमोरी की खपत महत्वपूर्ण हो सकती है।

उस परिदृश्य में, अधिक हल्के बीनफैक्ट्री का उपयोग करना उचित हो सकता है । हालाँकि, अधिकांश एंटरप्राइज़ अनुप्रयोगों में, ApplicationContext वह है जो आप उपयोग करना चाहते हैं।

अधिक जानकारी के लिए, मेरी ब्लॉग पोस्ट देखें:

वसंत में बीनफैक्टरी और एप्लीकेशनकोटेक्स्ट के बीच अंतर - मूल से जावा वसंत ब्लॉग

— ज़ोल्टन रफ़ाई
स्रोत

0

मुझे बीनफैक्टरी और एप्लिकेशनकंटेक्स की व्याख्या करने की आवश्यकता है।

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

बीनफैक्ट्री एक सरलतम कंटेनर है जो डिपेंडेंसी इंजेक्शन के लिए मूल समर्थन प्रदान करता है

अनुप्रयोग संदर्भ अनुप्रयोग संदर्भ वसंत अनुप्रयोग के साथ एक केंद्रीय इंटरफ़ेस है जो एप्लिकेशन को कॉन्फ़िगरेशन जानकारी प्रदान करता है। यह बीन फैक्टरी इंटरफेस को लागू करता है।

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

एक ApplicationContext प्रदान करता है:

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

— JegsVala
स्रोत