स्प्रिंग प्रोफेशनल सर्टिफिकेशन की तैयारी। कंटेनर, IoC, बीन्स

1. अक्सर उनमें जानकारी संरचित नहीं होती है, एकत्र नहीं की जाती है, या प्रासंगिक नहीं होती है
   
2. युवा डेवलपर्स अंग्रेजी नहीं जानते होंगे। इस चक्र का उपयोग न केवल प्रमाणीकरण के लिए किया जा सकता है, बल्कि स्व-प्रशिक्षण / सामग्रियों की पुनरावृत्ति के लिए भी किया जा सकता है।
   
3. इन सामग्रियों का उपयोग साक्षात्कार की तैयारी में किया जा सकता है, जैसा कि उन्हें प्रश्न और उत्तर के रूप में व्यवस्थित किया जाता है।
   
4. एक महत्वपूर्ण और सबसे महत्वपूर्ण लाभ यह है कि यह क्यूए आधिकारिक पिवटल स्टडी गाइड के सवालों से बना है।
   

• मैंने जानबूझकर कुछ सवाल याद किए जो मुझे बहुत अच्छे लगे या जो गाइड में नहीं थे।

1. निर्भरता इंजेक्शन, कंटेनर, IoC, सेम
2. एओपी (पहलू-उन्मुख प्रोग्रामिंग)
3. जेडीबीसी, लेनदेन, जेपीए, स्प्रिंग डेटा
4. वसंत का बूट
5. स्प्रिंग mvc
6. वसंत सुरक्षा
7. बाकी
8. परीक्षण

• स्प्रिंग 5 डिजाइन पैटर्न
  
• स्प्रिंग इन एक्शन 4 संस्करण
  
• वसंत सुरक्षा - तीसरा संस्करण
  
• इवान क्रिया द्वारा विस्तार से कोर स्प्रिंग 5 प्रमाणन
  
• स्प्रिंग डॉक्यूमेंटेशन और स्प्रिंग एपीआई जेवाडोक
  

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

• बेहतर परीक्षण। परीक्षणों में, बीन को एक विशेष ऑब्जेक्ट (मॉक या स्टब) से बदला जा सकता है जो बीन इंटरफेस को लागू करता है।
  
• आपको JDK से डायनेमिक प्रॉक्सी तंत्र का उपयोग करने की अनुमति देता है (उदाहरण के लिए, स्प्रिंग डेटा के माध्यम से एक रिपॉजिटरी बनाते समय)
  
• आपको कार्यान्वयन को छिपाने की अनुमति देता है
  

स्प्रिंग फ्रेमवर्क में, org.springframework.factory.BeanFactory इंटरफ़ेस org.springframework.factory.BeanFactory फैक्ट्री प्रदान करता है, जो एक ही समय में एक IoC एप्लीकेशन कंटेनर है। बीन प्रबंधन कॉन्फ़िगरेशन आधारित (जावा या xml) है।

org.springframework.context.ApplicationContext इंटरफ़ेस बीन फैक्ट्री पर एक आवरण है जो कुछ अतिरिक्त सुविधाएँ प्रदान करता है, जैसे AOP, लेनदेन, सुरक्षा, i18n, आदि।

स्प्रिंग फ्रेमवर्क का आधार एक कंटेनर है, और इस कंटेनर में हमारी वस्तुएं "लाइव" हैं।
एक कंटेनर आमतौर पर उनके कॉन्फ़िगरेशन के आधार पर कई ऑब्जेक्ट बनाता है और विनाश के लिए एक ऑब्जेक्ट बनाने से उनके जीवन चक्र का प्रबंधन करता है।

कंटेनर एक ऑब्जेक्ट है जो ApplicationContext इंटरफ़ेस को लागू करता है।

वसंत संदर्भ के कई रूप प्रदान करता है।

ApplicationContext इंटरफ़ेस के कई बुनियादी कार्यान्वयन हैं:

• FileSystemXmlApplicationContext
  
• ClassPathXmlApplicationContext
  
• AnnotationConfigApplicationContext
  
• XmlWebApplicationContext
  
• AnnotationConfigWebApplicationContext
  

एक संदर्भ बनाने के उदाहरण:

 ApplicationContext ctx = new FileSystemXmlApplicationContext(                                     "c:/bean_properties.xml"); ApplicationContext ctx = new AnnotationConfigApplicationContext(                            "com.springdemoapp.JavaConfig.class"); 

1. बिन विवरण लोड करना, एक निर्भरता ग्राफ बनाना (सेम के बीच)
2. BeanFactoryPostProcessors बनाना और BeanFactoryPostProcessors
3. बीन्स बनाएं
4. स्प्रिंग सेम गुणों में मूल्यों और निर्भरता को इंजेक्ट करता है
5. यदि सेम ने NameBeanAware इंटरफ़ेस से setBeanName() विधि लागू की है, तो सेम आईडी विधि को पारित कर दिया जाता है
6. यदि बीन बीनफैक्टिववेयर को लागू करता है, तो स्प्रिंग इस इंटरफेस से setBeanFactory() माध्यम से बीन कारखाने के लिए एक संदर्भ स्थापित करता है।
7. यदि सेम ApplicationContextAware इंटरफ़ेस को लागू करता है, तो स्प्रिंग setApplicationContext() माध्यम से setApplicationContext() लिए एक संदर्भ स्थापित करता है।
8. BeanPostProcessor एक विशेष इंटरफ़ेस है (इसके बारे में नीचे), और स्प्रिंग इस इंटरफेस को लागू करने की अनुमति देता है। postProcessBeforeInitialization() पद्धति को लागू करने से, आप इसे (बीन) स्थापित करने से पहले सेम के उदाहरण को बदल सकते हैं (गुण, आदि की स्थापना)
9. यदि कॉलबैक विधियों को परिभाषित किया जाता है, तो स्प्रिंग उन्हें कॉल करता है। उदाहरण के लिए, यह @Bean एनोटेशन से @PostConstruct या initMethod विधि द्वारा एनोटेट की गई विधि है।
10. बीन अब उपयोग के लिए तैयार है। यह ApplicationContext#getBean() विधि का उपयोग करके प्राप्त किया जा सकता है।
11. संदर्भ बंद होने के बाद close() ApplicationContext से विधि close() बंद हो जाता है, बीन नष्ट हो जाता है।
12. यदि बीन में @PreDestroy द्वारा एनोटेट की गई विधि है, तो विनाश से पहले इस विधि को बुलाया जाएगा। यदि बीन डिस्पोज़ेबल बीन को लागू करता है, तो स्प्रिंग आवेदन में संसाधनों को destroy() करने या प्रक्रियाओं को destroy() करने के लिए विध्वंस destroy() विधि को बुलाएगा। अगर destroyMethod में @Bean विधि को परिभाषित किया जाता है, तो इसे भी कहा जाता है।
    

यदि आप JUnit 5 का उपयोग कर रहे हैं, तो आपको 2 एनोटेशन निर्दिष्ट करने की आवश्यकता है:

• @ExtendWith (TestClass.class) - एक परीक्षण वर्ग को इंगित करने के लिए उपयोग किया जाता है
  
• @ContextConfoguration (classes = JavaConfig.class) - परीक्षण में संदर्भ बनाने के लिए जावा / xml कॉन्फ़िगरेशन को लोड करता है
  

आप @SpringJUnitConfig एनोटेशन का उपयोग कर सकते हैं, जो इन दोनों एनोटेशन को जोड़ती है।
आप वेब लेयर का परीक्षण करने के लिए @SpringJUnitWebConfig एनोटेशन का उपयोग कर सकते हैं।

यदि यह एक वेब एप्लिकेशन नहीं है, तो इसके 2 तरीके हैं:

• RegisterShutdownHook registerShutdownHook() विधि कॉल का उपयोग करके शटडाउन-हुक को registerShutdownHook() करें, यह AbstractApplicationContext वर्ग में भी लागू किया गया है। यह पसंदीदा तरीका है।
• आप AbstractApplicationContext वर्ग से close() विधि को कॉल कर सकते हैं।

स्प्रिंग बूट एप्लिकेशन में:

• स्प्रिंग बूट अपने लिए शटडाउन-हुक को पंजीकृत करेगा।

जावा कोड के आधार पर कॉन्फ़िगरेशन के साथ एक वर्ग बनाने के लिए, आपको इसके साथ एनोटेट करने की आवश्यकता है
@Configuration ।
इस वर्ग में कंटेनर में फलियां बनाने के लिए कारखाने के तरीके होंगे।
इन तरीकों को @Bean एनोटेशन के साथ एनोटेट किया जाना चाहिए।

एक उदाहरण:

 @Configuration public class DSConfig {  @Bean  public DataSource dataSource() {      return DataSourceBuilder          .create()          .username("")          .password("")          .url("")          .driverClassName("")          .build();  } } 

यह वर्ग कंटेनर में डेटा स्रोत वर्ग का एक उदाहरण देगा। बाद में डेटाबेस का उपयोग करते समय इसका उपयोग किया जा सकता है।

घटक स्कैनिंग - स्प्रिंग स्वचालित रूप से उन बीन्स का पता लगाता है जो कंटेनर में होंगे। ये एनोटेशन-स्टीरियोटाइप वाले डिब्बे हैं।

हालाँकि, घटक स्कैनिंग डिफ़ॉल्ट रूप से सक्षम नहीं है।
स्कैनिंग को सक्षम करने के लिए, एनोटेशन @ComponentScanning साथ @ कॉन्फ़िगरेशन वर्ग को एनोटेट करें। स्प्रिंग स्वचालित रूप से उस पैकेज को स्कैन करेगा जिसमें यह वर्ग और इसके सभी उप-पैकेज शामिल हैं।
आप स्कैनिंग के लिए अन्य पैकेज और यहां तक ​​कि कक्षाएं भी निर्दिष्ट कर सकते हैं:

 // 2  @Configuration(basePackages = {"soundsystem", "video"}) 

 //  @Configuration(basePackageClasses = "MyClass.class") 

ऑटो-फायरिंग - स्प्रिंग स्वचालित रूप से एक कंटेनर में बिन को स्कैन या रखने पर निर्भरता को इंजेक्ट करेगा।
निर्भरता इंजेक्शन @Autowire एनोटेशन का उपयोग करता है।

स्टीरियोटाइप विशेष कार्यक्षमता को दर्शाते हुए एनोटेशन हैं।
सभी स्टीरियोटाइप्स में @Component एनोटेशन शामिल है।

स्कोप - गुंजाइश। 2 डिफ़ॉल्ट स्कोप हैं।

और एक वेब एप्लिकेशन में 4 स्कोप।

स्कोप को @Scope @Bean तरीकों पर @Bean @Scope एनोटेशन का उपयोग करके इंगित किया गया है।

प्रोटोटाइप स्कोप थ्रेड सुरक्षित नहीं है क्योंकि यह गारंटी नहीं देता है कि एक ही उदाहरण केवल 1 थ्रेड में कहा जाएगा।

दूसरी ओर, सिंगलटन स्कोप, धागा सुरक्षित है।

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

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

सिंगलटन बीन को किसी अन्य बीन में एम्बेड किया जा सकता है।

केवल prototype या singleton को singleton एम्बेड किया जा सकता singleton ।
यदि आप प्रोटोटाइप को लागू करते हैं, तो प्रत्येक सिंगलटन के लिए एक अद्वितीय प्रोटोटाइप बनाया जाएगा।

प्रोटोटाइप किसी भी सेम के लिए एक निर्भरता हो सकता है।
आप केवल सिंगलटन या प्रोटोटाइप को लागू कर सकते हैं।

• BeanFactoryPostProcessor बिन बनाने से पहले बिन विवरण या कॉन्फ़िगरेशन मेटाडेटा पर काम करता है।
• स्प्रिंग कई उपयोगी BeanFactoryPostProcessor कार्यान्वयन प्रदान करता है, उदाहरण के लिए, संपत्ति फ़ाइलों को पढ़ना और उनसे BeanFactoryPostProcessor गुण प्राप्त करना।
• आप BFPP का अपना कार्यान्वयन लिख सकते हैं।

कस्टम BFPP का उपयोग करने के लिए। आप मेटाफ़ाइल्स से डेटा प्राप्त करने के लिए तंत्र को ओवरराइड कर सकते हैं।

 @Bean public static PropertySourcesPlaceholderConfigurer pspc() {    //,    pspc } 

• destroyMethod - एक कॉलबैक विधि को इंगित करता है। विधि बिन में है।
• initMethod - एक कॉलबैक विधि को इंगित करता है। विधि बिन में है।
• name - बीन का नाम। डिफ़ॉल्ट रूप से, बीन नाम विधि का नाम है।
• value - नाम के लिए उपनाम ()

स्प्रिंग कई बीनपोस्टप्रोसेसर का उपयोग करता है।
उदाहरण के लिए, CommonAnnotationPostProcessor या CommonAnnotationPostProcessor ।
BPP सेम इंस्टेंस के साथ काम करता है, अर्थात कंटेनर बिन बनाता है, और फिर BPP शुरू होता है।

ऐसे तरीके बनाने के लिए 3 विकल्प हैं:

• @PreDestroy और @PostConstruct एनोटेशन
• initMethod और destroyMethod एनोटेशन में destroyMethod जो बीन क्लास में तरीकों की ओर इशारा करते हैं
• InitializingBean#afterPropertiesSet() और DisposableBean#destroy() InitializingBean#afterPropertiesSet() DisposableBean#destroy() । इन विधियों को ओवरराइड करने के लिए, आपको संबंधित इंटरफेस को लागू करना होगा।

आपके आवेदन में इस्तेमाल किए जा सकने वाले DI के प्रकार निम्नलिखित हैं:

• कंस्ट्रक्टर डि
• सेटर डि
• फील्ड डि

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

1. कंटेनर एम्बेड करने के लिए ऑब्जेक्ट का प्रकार निर्धारित करता है।
2. एक कंटेनर सेम के संदर्भ में खोज करता है (उर्फ एक कंटेनर) जो वांछित प्रकार से मेल खाता है
3. यदि कई उम्मीदवार हैं, और उनमें से एक को @Primary के रूप में चिह्नित किया @Primary , तो इसे लागू किया जाता है
4. अगर @Autowire + Qualifier एनोटेशन का उपयोग किया जाता है, तो कंटेनर @Qualifier से जानकारी प्राप्त करने के लिए इस घटक का उपयोग करेगा।
5. अन्यथा, कंटेनर अपने नाम या आईडी के आधार पर घटक को इंजेक्ट करने का प्रयास करेगा।
6. यदि किसी भी तरीके ने काम नहीं किया, तो एक अपवाद फेंक दिया जाएगा

कंटेनर एक AutowiredAnnotationBeanPostProcessor का उपयोग करके DI को संभालता है। इस संबंध में, एनोटेशन का उपयोग किसी भी बीनफैक्ट्रीपीपी या बीएनपीपी में नहीं किया जा सकता है।

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

 // ,   DI @Authowired(required = true/false) 

आप विभिन्न प्रकार के कार्यान्वयन का उपयोग कर सकते हैं:

• डिजाइनर
• बैठानेवाला
• फील्ड इंजेक्शन
• मूल्य

डीआई अस्पष्टता की समस्या को दूर करने के लिए स्प्रिंग क्वालिफायर एनोटेशन प्रदान करता है।

 @Bean @Qualifier("SomeClass1") public SomeClass getField() {...} //… @Autowire @Qualifier("SomeField1") public SomeClass someField; 

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

एक प्रॉक्सी एक विशेष वस्तु है जिसमें बीन के समान सार्वजनिक तरीके हैं, लेकिन जिसमें अतिरिक्त कार्यक्षमता है।
दो प्रकार के परदे के पीछे:

• JDK- प्रॉक्सी - डायनेमिक प्रॉक्सी। एपीआई को जेडीके में बनाया गया है। इसके लिए एक इंटरफेस की जरूरत है
• CGLib प्रॉक्सी - JDK में निर्मित नहीं है। किसी ऑब्जेक्ट का इंटरफ़ेस अनुपलब्ध होने पर उपयोग किया जाता है।

प्रॉक्सी वस्तुओं के पेशेवरों:

• अतिरिक्त जोड़ने की अनुमति दें। तर्क - लेन-देन प्रबंधन, सुरक्षा, लॉगिंग
• कुछ कोड (लॉगिंग, आदि) को मुख्य तर्क से अलग करता है

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

जावा कॉन्फ़िगरेशन का उपयोग करते समय, आप @Profile एनोटेशन का उपयोग कर सकते हैं।
यह आपको निर्दिष्ट प्रोफ़ाइल के आधार पर, स्प्रिंग के लिए विभिन्न सेटिंग्स का उपयोग करने की अनुमति देता है।
इसे @Configuration और Component classes के साथ-साथ बीन के तरीकों पर रखा जा सकता है।

 Profile("!test") //   ,   

 @Bean("dataSource") @Profile("production") public DataSource jndiDataSource() {...} @Bean("dataSource") @Profile("development") public DataSource standaloneDataSource() {...} 

इसके लिए आप @Value एनोटेशन का उपयोग कर सकते हैं।
इस तरह के मूल्य संपत्ति फाइलों से, डिब्बे आदि से प्राप्त किए जा सकते हैं।

 @Value("$some.key") public String stringWithDefaultValue; 

इस चर में एक स्ट्रिंग एम्बेड किया जाएगा, उदाहरण के लिए, संपत्ति से या दृश्य से।