वसंत - त्वरित गाइड
एंटरप्राइज जावा के लिए स्प्रिंग सबसे लोकप्रिय एप्लिकेशन डेवलपमेंट फ्रेमवर्क है। दुनिया भर में लाखों डेवलपर्स उच्च प्रदर्शन, आसानी से परीक्षण करने योग्य और पुन: प्रयोज्य कोड बनाने के लिए स्प्रिंग फ्रेमवर्क का उपयोग करते हैं।
स्प्रिंग फ्रेमवर्क एक ओपन सोर्स जावा प्लेटफॉर्म है। यह शुरुआत में रॉड जॉनसन द्वारा लिखा गया था और पहली बार जून 2003 में अपाचे 2.0 लाइसेंस के तहत जारी किया गया था।
आकार और पारदर्शिता की बात करें तो स्प्रिंग हल्का होता है। स्प्रिंग फ्रेमवर्क का मूल संस्करण 2MB के आसपास है।
स्प्रिंग फ्रेमवर्क की मुख्य विशेषताओं का उपयोग किसी भी जावा एप्लिकेशन को विकसित करने में किया जा सकता है, लेकिन जावा ईई प्लेटफॉर्म के शीर्ष पर वेब अनुप्रयोगों के निर्माण के लिए एक्सटेंशन हैं। स्प्रिंग फ्रेमवर्क JJEE विकास को आसान बनाने के लिए लक्ष्य बनाता है और POJO- आधारित प्रोग्रामिंग मॉडल को सक्षम करके अच्छी प्रोग्रामिंग प्रथाओं को बढ़ावा देता है।
स्प्रिंग फ्रेमवर्क का उपयोग करने के लाभ
स्प्रिंग फ्रेमवर्क का उपयोग करने के कुछ महान लाभों की सूची निम्नलिखित है -
स्प्रिंग डेवलपर्स को POJOs का उपयोग करके उद्यम-श्रेणी के अनुप्रयोगों को विकसित करने में सक्षम बनाता है। केवल POJOs का उपयोग करने का लाभ यह है कि आपको एक EJB कंटेनर उत्पाद जैसे एप्लिकेशन सर्वर की आवश्यकता नहीं है, लेकिन आपके पास केवल एक मजबूत सर्वलेट कंटेनर जैसे Tomcat या कुछ वाणिज्यिक उत्पाद का उपयोग करने का विकल्प है।
वसंत एक मॉड्यूलर फैशन में आयोजित किया जाता है। भले ही पैकेज और कक्षाएं पर्याप्त हों, आपको केवल उन लोगों के बारे में चिंता करनी होगी जिनकी आपको ज़रूरत है और बाकी को अनदेखा करें।
वसंत पहिया को सुदृढ़ नहीं करता है, इसके बजाय यह वास्तव में कुछ मौजूदा तकनीकों जैसे कि कई ओआरएम फ्रेमवर्क, लॉगिंग फ्रेमवर्क, जेईई, क्वार्ट्ज और जेडडीके टाइमर, और अन्य दृश्य प्रौद्योगिकियों का उपयोग करता है।
स्प्रिंग के साथ लिखे गए एप्लिकेशन का परीक्षण करना सरल है क्योंकि पर्यावरण-निर्भर कोड को इस ढांचे में स्थानांतरित कर दिया गया है। इसके अलावा, जावाबिनस्टाइल पीओजेओ का उपयोग करके, परीक्षण डेटा को इंजेक्ट करने के लिए निर्भरता इंजेक्शन का उपयोग करना आसान हो जाता है।
स्प्रिंग का वेब ढांचा एक अच्छी तरह से डिज़ाइन किया गया वेब MVC फ्रेमवर्क है, जो वेब फ्रेमवर्क जैसे स्ट्रट्स या अन्य अति-इंजीनियर या कम लोकप्रिय वेब फ्रेमवर्क का एक शानदार विकल्प प्रदान करता है।
स्प्रिंग प्रौद्योगिकी-विशिष्ट अपवादों का अनुवाद करने के लिए एक सुविधाजनक एपीआई प्रदान करता है (उदाहरण के लिए, जेडीबीसी, हाइबरनेट या जेडीओ द्वारा फेंका गया), अनियंत्रित अपवादों में।
लाइटवेट IoC कंटेनर हल्के होते हैं, खासकर जब EJB कंटेनरों की तुलना में, उदाहरण के लिए। यह सीमित मेमोरी और सीपीयू संसाधनों के साथ कंप्यूटर पर अनुप्रयोगों को विकसित करने और तैनात करने के लिए फायदेमंद है।
स्प्रिंग एक सुसंगत लेनदेन प्रबंधन इंटरफ़ेस प्रदान करता है जो स्थानीय लेनदेन (उदाहरण के लिए एकल डेटाबेस का उपयोग करके) और वैश्विक लेनदेन (उदाहरण के लिए, जेटा का उपयोग करके) तक स्केल कर सकता है।
निर्भरता इंजेक्शन (DI)
जिस तकनीक से स्प्रिंग की पहचान की जाती है वह है Dependency Injection (DI)नियंत्रण के उलटा का स्वाद। Inversion of Control (IoC)एक सामान्य अवधारणा है, और इसे कई अलग-अलग तरीकों से व्यक्त किया जा सकता है। निर्भरता इंजेक्शन नियंत्रण के व्युत्क्रम का केवल एक ठोस उदाहरण है।
एक जटिल जावा एप्लिकेशन लिखते समय, इन कक्षाओं के पुन: उपयोग की संभावना बढ़ाने के लिए और यूनिट परीक्षण करते समय अन्य वर्गों के स्वतंत्र रूप से परीक्षण करने के लिए आवेदन कक्षाएं अन्य जावा कक्षाओं के रूप में स्वतंत्र होनी चाहिए। निर्भरता इंजेक्शन इन वर्गों को एक साथ और एक ही समय में उन्हें स्वतंत्र रखने में मदद करता है।
निर्भरता इंजेक्शन वास्तव में क्या है? आइए इन दोनों शब्दों को अलग-अलग देखें। यहाँ पर निर्भरता भाग दो वर्गों के बीच संबंध में परिवर्तित होता है। उदाहरण के लिए, क्लास ए कक्षा बी के आश्रित है। अब, दूसरे भाग को देखें, इंजेक्शन। इसका मतलब यह है कि, वर्ग बी को आईओसी द्वारा कक्षा ए में इंजेक्ट किया जाएगा।
डिपेंडेंसी इंजेक्शन कंस्ट्रक्टर को पैरामीटर पास करने या सेटर निर्माण विधियों का उपयोग करके पोस्ट-कंस्ट्रक्शन के तरीके से हो सकता है। जैसा कि निर्भरता इंजेक्शन वसंत फ्रेमवर्क का दिल है, हम इस अवधारणा को प्रासंगिक उदाहरण के साथ एक अलग अध्याय में समझाएंगे।
पहलू उन्मुख प्रोग्रामिंग (AOP)
वसंत के प्रमुख घटकों में से एक है Aspect Oriented Programming (AOP)ढांचा। किसी अनुप्रयोग के कई बिंदुओं को जोड़ने वाले कार्य कहलाते हैंcross-cutting concernsऔर ये क्रॉस-कटिंग चिंताएं वैचारिक रूप से एप्लिकेशन के व्यावसायिक तर्क से अलग हैं। लॉगिंग, घोषणात्मक लेनदेन, सुरक्षा, कैशिंग, आदि पहलुओं के विभिन्न सामान्य अच्छे उदाहरण हैं।
OOP में प्रतिरूपकता की प्रमुख इकाई वर्ग है, जबकि AOP में प्रतिरूपकता की इकाई पहलू है। DI आपकी एप्लिकेशन ऑब्जेक्ट्स को एक-दूसरे से अलग करने में आपकी मदद करता है, जबकि AOP आपको उन वस्तुओं से क्रॉस-कटिंग चिंताओं को कम करने में मदद करता है जो वे प्रभावित करते हैं।
स्प्रिंग फ्रेमवर्क का एओपी मॉड्यूल एक पहलू-उन्मुख प्रोग्रामिंग कार्यान्वयन प्रदान करता है जो आपको विधि-अवरोधक और बिंदुओं को साफ-साफ कोड को परिभाषित करने की अनुमति देता है जो कार्यक्षमता को अलग करता है जिसे अलग किया जाना चाहिए। हम एक अलग अध्याय में स्प्रिंग एओपी अवधारणाओं के बारे में अधिक चर्चा करेंगे।
वसंत संभवतः आपके सभी उद्यम अनुप्रयोगों के लिए एक-स्टॉप शॉप हो सकता है। हालाँकि, स्प्रिंग मॉड्यूलर है, जिससे आप चुन सकते हैं कि कौन से मॉड्यूल आपके लिए लागू हैं, बाकी में लाने के बिना। निम्न अनुभाग स्प्रिंग फ्रेमवर्क में उपलब्ध सभी मॉड्यूल के बारे में विवरण प्रदान करता है।
स्प्रिंग फ्रेमवर्क लगभग 20 मॉड्यूल प्रदान करता है जिसका उपयोग एप्लिकेशन आवश्यकता के आधार पर किया जा सकता है।
कोर कंटेनर
कोर कंटेनर में कोर, बीन्स, संदर्भ और अभिव्यक्ति भाषा मॉड्यूल शामिल हैं, जिनका विवरण निम्नानुसार है -
Core मॉड्यूल IoC और निर्भरता इंजेक्शन सुविधाओं सहित, ढांचे के मूलभूत भागों को प्रदान करता है।
Bean मॉड्यूल बीनफैक्टिंग प्रदान करता है, जो कारखाने पैटर्न का एक परिष्कृत कार्यान्वयन है।
Contextमॉड्यूल कोर और बीन्स मॉड्यूल द्वारा प्रदान किए गए ठोस आधार पर बनाता है और यह परिभाषित और कॉन्फ़िगर किसी भी ऑब्जेक्ट तक पहुंचने के लिए एक माध्यम है। ApplicationContext इंटरफ़ेस कॉन्टेक्ट मॉड्यूल का केंद्र बिंदु है।
SpEL मॉड्यूल रनटाइम पर ऑब्जेक्ट ग्राफ़ को क्वेरी और हेरफेर करने के लिए एक शक्तिशाली अभिव्यक्ति भाषा प्रदान करता है।
डेटा एक्सेस / इंटीग्रेशन
डेटा एक्सेस / इंटीग्रेशन लेयर में JDBC, ORM, OXM, JMS और ट्रांजैक्शन मॉड्यूल होते हैं, जिनका विवरण इस प्रकार है:
JDBC मॉड्यूल एक JDBC-अमूर्त परत प्रदान करता है जो थकाऊ JDBC संबंधित कोडिंग की आवश्यकता को दूर करता है।
ORM मॉड्यूल लोकप्रिय ऑब्जेक्ट-रिलेशनल मैपिंग एपीआई के लिए एकीकरण परतें प्रदान करता है, जिसमें जेपीए, जेडीओ, हाइबरनेट और आईबैटिस शामिल हैं।
OXM मॉड्यूल एक अमूर्त परत प्रदान करता है जो JAXB, कैस्टर, XMLBeans, JiBX और XStream के लिए ऑब्जेक्ट / XML मैपिंग कार्यान्वयन का समर्थन करता है।
जावा मैसेजिंग सर्विस JMS मॉड्यूल में संदेशों को बनाने और उपभोग करने की विशेषताएं हैं।
Transaction मॉड्यूल उन वर्गों के लिए प्रोग्रामेटिक और घोषणात्मक लेनदेन प्रबंधन का समर्थन करता है जो विशेष इंटरफेस को लागू करते हैं और आपके सभी पीओजेओ के लिए।
वेब
वेब परत में वेब, वेब-एमवीसी, वेब-सॉकेट और वेब-पोर्टलेट मॉड्यूल शामिल हैं, जिनका विवरण निम्नानुसार है:
Web मॉड्यूल बुनियादी वेब-उन्मुख एकीकरण सुविधाएँ प्रदान करता है जैसे मल्टीपार्ट फ़ाइल-अपलोड कार्यक्षमता और IoC कंटेनर के आरंभ में सर्वलेट श्रोताओं और एक वेब-उन्मुख अनुप्रयोग संदर्भ का उपयोग करना।
Web-MVC मॉड्यूल में वेब अनुप्रयोगों के लिए स्प्रिंग का मॉडल-व्यू-कंट्रोलर (MVC) कार्यान्वयन है।
Web-Socket मॉड्यूल WebSocket- आधारित, क्लाइंट और सर्वर के बीच वेब एप्लिकेशन में दो-तरफ़ा संचार के लिए समर्थन प्रदान करता है।
Web-Portlet मॉड्यूल पोर्ट परिवेश में उपयोग किया जाने वाला MVC कार्यान्वयन प्रदान करता है और वेब-सर्वलेट मॉड्यूल की कार्यक्षमता को प्रतिबिंबित करता है।
कई तरह का
AOP, पहलू, इंस्ट्रूमेंटेशन, वेब और टेस्ट मॉड्यूल जैसे कुछ अन्य महत्वपूर्ण मॉड्यूल हैं जिनका विवरण निम्नानुसार है -
AOP मॉड्यूल एक पहलू-उन्मुख प्रोग्रामिंग कार्यान्वयन प्रदान करता है जो आपको विधि-अवरोधक और बिंदुओं को साफ-साफ कोड को परिभाषित करने की अनुमति देता है जो कार्यक्षमता को अलग करता है जिसे अलग किया जाना चाहिए।
Aspects मॉड्यूल AspectJ के साथ एकीकरण प्रदान करता है, जो फिर से एक शक्तिशाली और परिपक्व एओपी फ्रेमवर्क है।
Instrumentation मॉड्यूल कुछ एप्लिकेशन सर्वर में उपयोग किए जाने के लिए क्लास इंस्ट्रूमेंटेशन समर्थन और क्लास लोडर कार्यान्वयन प्रदान करता है।
Messagingमॉड्यूल अनुप्रयोगों में उपयोग करने के लिए WebSocket उप-प्रोटोकॉल के रूप में STOMP के लिए समर्थन प्रदान करता है। यह WebSocket क्लाइंट से STOMP संदेशों को रूट करने और संसाधित करने के लिए एक एनोटेशन प्रोग्रामिंग मॉडल का भी समर्थन करता है।
Test मॉड्यूल JUnit या TestNG चौखटे के साथ वसंत घटकों के परीक्षण का समर्थन करता है।
यह अध्याय आपको इस बात पर मार्गदर्शन देगा कि स्प्रिंग फ्रेमवर्क के साथ अपना काम शुरू करने के लिए विकास का माहौल कैसे तैयार करें। यह भी सिखाएगा कि स्प्रिंग फ्रेमवर्क सेट करने से पहले अपनी मशीन पर JDK, Tomcat और Eclipse कैसे सेट करें -
चरण 1 - सेटअप जावा डेवलपमेंट किट (JDK)
आप ओरेकल के जावा साइट से एसडीके के नवीनतम संस्करण को डाउनलोड कर सकते हैं - जावा एसई डाउनलोड। आपको डाउनलोड की गई फ़ाइलों में जेडीके स्थापित करने के लिए निर्देश मिलेंगे, सेटअप को स्थापित करने और कॉन्फ़िगर करने के लिए दिए गए निर्देशों का पालन करें। अंत में PATH और JAVA_HOME वातावरण चर को उस निर्देशिका के संदर्भ में सेट करें जिसमें क्रमशः java और javac शामिल हैं, आमतौर पर java_install_dir / bin और java_install_dir।
यदि आप Windows चला रहे हैं और JDK को C: \ jdk1.6.0_15 में स्थापित किया है, तो आपको अपनी C: \ autoexec.bat फ़ाइल में निम्न पंक्ति डालनी होगी।
set PATH=C:\jdk1.6.0_15\bin;%PATH%
set JAVA_HOME=C:\jdk1.6.0_15वैकल्पिक रूप से, विंडोज एनटी / 2000 / एक्सपी पर, आपको माय कंप्यूटर पर राइट-क्लिक करना होगा, गुण → उन्नत → पर्यावरण चर का चयन करें। फिर, आपको पैथ मान को अपडेट करना होगा और ओके बटन पर क्लिक करना होगा।
Unix (Solaris, Linux, आदि) पर, यदि SDK /usr/local/jdk1.6.0_15 में स्थापित है और आप C शेल का उपयोग करते हैं, तो आपको निम्नलिखित .cshrc फ़ाइल में डालनी होगी।
setenv PATH /usr/local/jdk1.6.0_15/bin:$PATH
setenv JAVA_HOME /usr/local/jdk1.6.0_15वैकल्पिक रूप से, यदि आप Borland JBuilder, Eclipse, IntelliJ IDEA या Sun ONE स्टूडियो जैसे एक एकीकृत विकास पर्यावरण (IDE) का उपयोग करते हैं, तो आपको यह पुष्टि करने के लिए एक साधारण प्रोग्राम संकलित और चलाना होगा कि IDE जानता है कि आपने जावा कहाँ स्थापित किया है। अन्यथा, आपको एक उचित सेटअप करना होगा जैसा कि आईडीई के दस्तावेज में दिया गया है।
चरण 2 - अपाचे कॉमन लॉगिंग एपीआई स्थापित करें
आप अपाचे कॉमन्स लॉगिंग एपीआई के नवीनतम संस्करण को डाउनलोड कर सकते हैं https://commons.apache.org/logging/। एक बार जब आप इंस्टॉलेशन डाउनलोड कर लेते हैं, तो बाइनरी वितरण को सुविधाजनक स्थान पर अनपैक कर दें। उदाहरण के लिए, विंडोज पर C: \ commons-logging-1.1.1, या लिनक्स / यूनिक्स पर /usr/local/commons-logging-1.1.1। इस निर्देशिका में निम्नलिखित जार फाइलें और अन्य सहायक दस्तावेज होंगे, आदि।
सुनिश्चित करें कि आपने अपना CLASSPATH चर इस निर्देशिका पर ठीक से सेट किया है अन्यथा आपको अपना आवेदन चलाते समय समस्या का सामना करना पड़ेगा।
चरण 3 - सेटअप ग्रहण आईडीई
इस ट्यूटोरियल के सभी उदाहरण ग्रहण आईडीई का उपयोग करके लिखे गए हैं। इसलिए हमारा सुझाव है कि आपके पास अपनी मशीन पर स्थापित ग्रहण का नवीनतम संस्करण होना चाहिए।
ग्रहण आईडीई स्थापित करने के लिए, से नवीनतम ग्रहण बायनेरिज़ डाउनलोड करें https://www.eclipse.org/downloads/। एक बार जब आप इंस्टॉलेशन डाउनलोड कर लेते हैं, तो बाइनरी वितरण को सुविधाजनक स्थान पर अनपैक कर दें। उदाहरण के लिए, विंडोज पर C: \ ग्रहण में, या लिनक्स / यूनिक्स पर / usr / स्थानीय / ग्रहण और अंत में उचित रूप से पथ परिवर्तन सेट करें।
विंडोज मशीन पर निम्नलिखित कमांड को निष्पादित करके ग्रहण शुरू किया जा सकता है, या आप केवल eclipse.exe पर डबल-क्लिक कर सकते हैं
%C:\eclipse\eclipse.exeयूनिक्स (सोलारिस, लिनक्स, आदि) मशीन पर निम्नलिखित आदेशों को निष्पादित करके ग्रहण शुरू किया जा सकता है -
$/usr/local/eclipse/eclipseएक सफल स्टार्टअप के बाद, यदि सब कुछ ठीक है, तो उसे निम्नलिखित परिणाम प्रदर्शित करने चाहिए -
चरण 4 - सेटअप स्प्रिंग फ्रेमवर्क लाइब्रेरी
अब यदि सब कुछ ठीक है, तो आप अपने स्प्रिंग ढांचे को स्थापित करने के लिए आगे बढ़ सकते हैं। अपनी मशीन पर फ्रेमवर्क को डाउनलोड करने और स्थापित करने के सरल चरण निम्नलिखित हैं।
एक विकल्प बनाएं कि क्या आप विंडोज या यूनिक्स पर स्प्रिंग स्थापित करना चाहते हैं, और फिर विंडोज के लिए .zip और यूनिक्स के लिए .tz फ़ाइल डाउनलोड करने के लिए अगले चरण पर आगे बढ़ें।
स्प्रिंग फ्रेमवर्क बायनेरिज़ का नवीनतम संस्करण डाउनलोड करें https://repo.spring.io/release/org/springframework/spring।
इस ट्यूटोरियल को विकसित करने के समय, spring-framework-4.1.6.RELEASE-dist.zipविंडोज मशीन पर डाउनलोड किया गया था। डाउनलोड की गई फ़ाइल को अनज़िप करने के बाद, यह E: \ spring के अंदर निम्न निर्देशिका संरचना देती है।
आपको निर्देशिका में सभी स्प्रिंग लाइब्रेरी मिलेंगी E:\spring\libs। सुनिश्चित करें कि आपने अपना CLASSPATH चर इस निर्देशिका पर ठीक से सेट किया है अन्यथा आपको अपना आवेदन चलाते समय समस्या का सामना करना पड़ेगा। यदि आप ग्रहण का उपयोग कर रहे हैं, तो CLASSPATH को सेट करने की आवश्यकता नहीं है क्योंकि सभी सेटिंग ग्रहण के माध्यम से की जाएंगी।
एक बार जब आप इस अंतिम चरण के साथ हो जाते हैं, तो आप अगले अध्याय में अपने पहले स्प्रिंग उदाहरण के लिए आगे बढ़ने के लिए तैयार हैं।
चलिए हम स्प्रिंग फ्रेमवर्क के साथ वास्तविक प्रोग्रामिंग शुरू करते हैं। इससे पहले कि आप स्प्रिंग फ्रेमवर्क का उपयोग करके अपना पहला उदाहरण लिखना शुरू करें, आपको यह सुनिश्चित करना होगा कि आपने अपना स्प्रिंग वातावरण ठीक से सेट कर दिया है जैसा कि स्प्रिंग - स्प्रिंग सेटअप अध्याय में समझाया गया है । हम यह भी मानते हैं कि आपके पास ग्रहण आईडीई पर थोड़ा काम करने का ज्ञान है।
अब हम एक सरल स्प्रिंग एप्लीकेशन लिखने के लिए आगे बढ़ते हैं, जो "हेल्लो वर्ल्ड!" या स्प्रिंग बीन्स कॉन्फ़िगरेशन फ़ाइल में किए गए कॉन्फ़िगरेशन के आधार पर कोई अन्य संदेश।
चरण 1 - जावा प्रोजेक्ट बनाएं
पहला कदम ग्रहण आईडीई का उपयोग करके एक सरल जावा प्रोजेक्ट बनाना है। विकल्प का पालन करेंFile → New → Project और अंत में चयन करें Java Projectविज़ार्ड सूची से विज़ार्ड। अब अपने प्रोजेक्ट का नाम बताइएHelloSpring विज़ार्ड विंडो का उपयोग निम्नानुसार है -
एक बार जब आपका प्रोजेक्ट सफलतापूर्वक बन जाता है, तो आपके पास निम्नलिखित सामग्री होगी Project Explorer -
चरण 2 - आवश्यक पुस्तकालय जोड़ें
दूसरे चरण के रूप में, हम अपने प्रोजेक्ट में स्प्रिंग फ्रेमवर्क और कॉमन लॉगिंग एपीआई लाइब्रेरीज़ को जोड़ते हैं। ऐसा करने के लिए, अपने प्रोजेक्ट नाम पर राइट-क्लिक करेंHelloSpring और फिर संदर्भ मेनू में उपलब्ध निम्नलिखित विकल्प का पालन करें - Build Path → Configure Build Path निम्नानुसार जावा बिल्ड पाथ विंडो प्रदर्शित करने के लिए -
अब उपयोग करें Add External JARs के तहत उपलब्ध बटन Libraries स्प्रिंग फ्रेमवर्क और कॉमन लॉगिंग इंस्टॉलेशन निर्देशिकाओं से निम्नलिखित कोर JAR जोड़ने के लिए टैब -
commons-logging-1.1.1
spring-aop-4.1.6.RELEASE
spring-aspects-4.1.6.RELEASE
spring-beans-4.1.6.RELEASE
spring-context-4.1.6.RELEASE
spring-context-support-4.1.6.RELEASE
spring-core-4.1.6.RELEASE
spring-expression-4.1.6.RELEASE
spring-instrument-4.1.6.RELEASE
spring-instrument-tomcat-4.1.6.RELEASE
spring-jdbc-4.1.6.RELEASE
spring-jms-4.1.6.RELEASE
spring-messaging-4.1.6.RELEASE
spring-orm-4.1.6.RELEASE
spring-oxm-4.1.6.RELEASE
spring-test-4.1.6.RELEASE
spring-tx-4.1.6.RELEASE
spring-web-4.1.6.RELEASE
spring-webmvc-4.1.6.RELEASE
spring-webmvc-portlet-4.1.6.RELEASE
spring-websocket-4.1.6.RELEASE
चरण 3 - स्रोत फ़ाइलें बनाएँ
अब हम वास्तविक स्रोत फाइल बनाते हैं HelloSpringपरियोजना। पहले हमें एक पैकेज बनाने की आवश्यकता है जिसे कहा जाता हैcom.tutorialspoint। ऐसा करने के लिए, राइट क्लिक करेंsrc पैकेज एक्सप्लोरर अनुभाग में और विकल्प का पालन करें - New → Package।
आगे हम बनाएंगे HelloWorld.java तथा MainApp.java com.tutorialspoint पैकेज के तहत फाइलें।
यहाँ की सामग्री है HelloWorld.java फ़ाइल -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}निम्नलिखित दूसरी फ़ाइल की सामग्री है MainApp.java -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
}
}मुख्य कार्यक्रम के बारे में दो महत्वपूर्ण बिंदुओं पर ध्यान दिया जाना चाहिए -
पहला कदम एक एप्लिकेशन संदर्भ बनाना है जहां हमने फ्रेमवर्क एपीआई का उपयोग किया है ClassPathXmlApplicationContext()। यह एपीआई बीन्स विन्यास फाइल को लोड करता है और अंततः प्रदान की गई एपीआई पर आधारित है, यह विन्यास फाइल में उल्लिखित सभी ऑब्जेक्ट्स यानी बीन्स को बनाने और शुरू करने का ख्याल रखता है।
दूसरे चरण का उपयोग आवश्यक बीन का उपयोग करने के लिए किया जाता है getBean()निर्मित प्रसंग की विधि। यह विधि एक सामान्य वस्तु को वापस करने के लिए बीन आईडी का उपयोग करती है, जिसे अंत में वास्तविक वस्तु में डाला जा सकता है। एक बार जब आपके पास कोई ऑब्जेक्ट होता है, तो आप किसी भी क्लास विधि को कॉल करने के लिए इस ऑब्जेक्ट का उपयोग कर सकते हैं।
चरण 4 - बीन विन्यास फ़ाइल बनाएँ
आपको एक बीन कॉन्फ़िगरेशन फ़ाइल बनाने की आवश्यकता है जो एक XML फ़ाइल है और सेम को गोंद करने वाली एक सीमेंट के रूप में कार्य करती है, अर्थात एक साथ कक्षाएं। इस फ़ाइल के तहत बनाया जाना चाहिएsrc निर्देशिका निम्न स्क्रीनशॉट में दिखाया गया है -
आमतौर पर डेवलपर्स इस फाइल को इस नाम देते हैं Beans.xml, लेकिन आप अपनी पसंद का कोई भी नाम चुनने के लिए स्वतंत्र हैं। आपको यह सुनिश्चित करना होगा कि यह फ़ाइल CLASSPATH में उपलब्ध है और मुख्य ऐप्लीकेशन में मेनएप.जवा फाइल में दिखाए अनुसार एक ही नाम का उपयोग करें।
Beans.xml का उपयोग विभिन्न बीन्स के लिए अद्वितीय आईडी प्रदान करने और किसी भी स्प्रिंग स्रोत फ़ाइलों को प्रभावित किए बिना विभिन्न मूल्यों के साथ वस्तुओं के निर्माण को नियंत्रित करने के लिए किया जाता है। उदाहरण के लिए, निम्न फ़ाइल का उपयोग करके आप "संदेश" चर के लिए कोई भी मान पास कर सकते हैं और आप HelloWorld.java और MainApp.java फ़ाइलों को प्रभावित किए बिना संदेश के विभिन्न मूल्यों को प्रिंट कर सकते हैं। आइए देखें कि यह कैसे काम करता है -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>जब स्प्रिंग एप्लिकेशन मेमोरी में लोड हो जाता है, तो फ्रेमवर्क उपरोक्त कॉन्फ़िगरेशन फ़ाइल का उपयोग सभी परिभाषित बीन्स को बनाने और उन्हें एक अद्वितीय आईडी प्रदान करने के लिए करता है। <bean>टैग। आप उपयोग कर सकते हैं<property> ऑब्जेक्ट निर्माण के समय उपयोग किए जाने वाले विभिन्न चर के मूल्यों को पास करने के लिए टैग।
चरण 5 - कार्यक्रम चलाना
एक बार जब आप स्रोत और सेम कॉन्फ़िगरेशन फाइल बनाने के साथ हो जाते हैं, तो आप इस चरण के लिए तैयार हैं, जो आपके प्रोग्राम को संकलित और चला रहा है। ऐसा करने के लिए, MainApp.Java फ़ाइल टैब सक्रिय रखें और या तो उपयोग करेंRun ग्रहण आईडीई या उपयोग में उपलब्ध विकल्प Ctrl + F11 संकलन और चलाने के लिए अपने MainAppआवेदन। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को ग्रहण आईडीई के कंसोल में प्रिंट करेगा -
Your Message : Hello World!बधाई हो, आपने अपना पहला स्प्रिंग एप्लिकेशन सफलतापूर्वक बनाया है। आप "संदेश" संपत्ति के मूल्य को बदलकर और दोनों स्रोत फ़ाइलों को अपरिवर्तित रखकर उपरोक्त स्प्रिंग एप्लिकेशन के लचीलेपन को देख सकते हैं।
स्प्रिंग कंटेनर स्प्रिंग फ्रेमवर्क के मूल में है। कंटेनर वस्तुओं का निर्माण करेगा, उन्हें एक साथ तार देगा, उन्हें कॉन्फ़िगर करेगा और निर्माण से विनाश तक उनके पूर्ण जीवन चक्र का प्रबंधन करेगा। स्प्रिंग कंटेनर किसी अनुप्रयोग को बनाने वाले घटकों का प्रबंधन करने के लिए DI का उपयोग करता है। इन वस्तुओं को स्प्रिंग बीन्स कहा जाता है, जिसकी चर्चा हम अगले अध्याय में करेंगे।
कंटेनर को निर्देश मिलता है कि कौन सी वस्तुएं प्रदान की गई हैं, विन्यास मेटाडाटा को पढ़कर, कॉन्फ़िगर करें और इकट्ठा करें। कॉन्फ़िगरेशन मेटाडेटा को एक्सएमएल, जावा एनोटेशन या जावा कोड द्वारा भी दर्शाया जा सकता है। निम्न आरेख वसंत के काम करने के तरीके के एक उच्च-स्तरीय दृश्य का प्रतिनिधित्व करता है। स्प्रिंग IoC कंटेनर पूरी तरह से कॉन्फ़िगर और निष्पादन योग्य सिस्टम या एप्लिकेशन का उत्पादन करने के लिए जावा POJO वर्गों और कॉन्फ़िगरेशन मेटाडेटा का उपयोग करता है।
वसंत निम्नलिखित दो प्रकार के कंटेनर प्रदान करता है।
| अनु क्रमांक। | कंटेनर और विवरण |
|---|---|
| 1 | स्प्रिंग बीनफैक्ट्री कंटेनर यह डीआई के लिए मूल समर्थन प्रदान करने वाला सबसे सरल कंटेनर है और इसे org.springframework.beans.factory.BeanFactory इंटरफ़ेस द्वारा परिभाषित किया गया है। बीनफैक्टरी और संबंधित इंटरफेस, जैसे बीनफैक्टरीवेयर, इनिशियलाइजिंग बीन, डिस्पोजेबल बीन, स्प्रिंग के साथ एकीकृत होने वाले बड़ी संख्या में तीसरे पक्ष के ढांचे के साथ पिछड़े संगतता के उद्देश्य के लिए वसंत में अभी भी मौजूद हैं। |
| 2 | वसंत ApplicationContext कंटेनर यह कंटेनर अधिक उद्यम-विशिष्ट कार्यक्षमता जोड़ता है जैसे कि गुण फ़ाइल से पाठ संदेश को हल करने की क्षमता और इच्छुक श्रोताओं को एप्लिकेशन ईवेंट प्रकाशित करने की क्षमता। इस कंटेनर को org.springframework.context.ApplicationContext इंटरफ़ेस द्वारा परिभाषित किया गया है। |
ApplicationContext कंटेनर की सभी कार्यक्षमता शामिल BeanFactory तो यह आम तौर पर अधिक की सिफारिश की है, कंटेनर BeanFactory । बीनफैक्ट का उपयोग अभी भी मोबाइल उपकरणों या ऐपलेट-आधारित अनुप्रयोगों जैसे हल्के अनुप्रयोगों के लिए किया जा सकता है जहां डेटा की मात्रा और गति महत्वपूर्ण है।
आपके अनुप्रयोग की रीढ़ बनाने वाली और स्प्रिंग आईओसी कंटेनर द्वारा प्रबंधित वस्तुओं को कहा जाता है beans। बीन एक ऐसी वस्तु है, जो स्प्रिंग आईओसी कंटेनर द्वारा तुरंत तैयार की जाती है, इकट्ठी की जाती है और अन्यथा प्रबंधित की जाती है। ये सेम कॉन्फ़िगरेशन मेटाडेटा के साथ बनाए जाते हैं जो आप कंटेनर को आपूर्ति करते हैं। उदाहरण के लिए, XML <bean /> परिभाषाओं के रूप में जो आप पहले ही पिछले अध्यायों में देख चुके हैं।
बीन परिभाषा में सूचना कहा जाता है configuration metadata, जो निम्नलिखित जानने के लिए कंटेनर के लिए आवश्यक है -
- बीन कैसे बनाएं
- बीन के जीवन चक्र का विवरण
- बीन की निर्भरता
उपरोक्त सभी विन्यास मेटाडेटा निम्नलिखित गुणों के एक सेट में तब्दील हो जाता है जो प्रत्येक बीन की परिभाषा बनाता है।
| अनु क्रमांक। | गुण और विवरण |
|---|---|
| 1 | class यह विशेषता अनिवार्य है और बीन बनाने के लिए उपयोग की जाने वाली बीन क्लास को निर्दिष्ट करती है। |
| 2 | name यह विशेषता विशिष्ट रूप से बीन पहचानकर्ता को निर्दिष्ट करती है। XMLbased कॉन्फ़िगरेशन मेटाडेटा में, आप बीन आइडेंटिफ़ायर को निर्दिष्ट करने के लिए आईडी और / या नाम विशेषताओं का उपयोग करते हैं। |
| 3 | scope यह विशेषता एक विशेष बीन परिभाषा से निर्मित वस्तुओं के दायरे को निर्दिष्ट करती है और बीन स्कोप अध्याय में इसकी चर्चा की जाएगी। |
| 4 | constructor-arg यह निर्भरता को इंजेक्ट करने के लिए उपयोग किया जाता है और बाद के अध्यायों में चर्चा की जाएगी। |
| 5 | properties यह निर्भरता को इंजेक्ट करने के लिए उपयोग किया जाता है और बाद के अध्यायों में चर्चा की जाएगी। |
| 6 | autowiring mode यह निर्भरता को इंजेक्ट करने के लिए उपयोग किया जाता है और बाद के अध्यायों में चर्चा की जाएगी। |
| 7 | lazy-initialization mode एक आलसी-आरंभिक बीन IoC कंटेनर को एक बीन उदाहरण बनाने के लिए कहता है जब इसे पहली बार अनुरोध किया जाता है, बजाय स्टार्टअप पर। |
| 8 | initialization method कंटेनर द्वारा सेम पर सभी आवश्यक गुणों के बाद कॉलबैक को कॉल किया जाना है। इसकी चर्चा बीन लाइफ साइकल चैप्टर में की जाएगी। |
| 9 | destruction method बीन युक्त कंटेनर को नष्ट होने पर उपयोग किया जाने वाला कॉलबैक। इसकी चर्चा बीन लाइफ साइकल चैप्टर में की जाएगी। |
वसंत विन्यास मेटाडेटा
स्प्रिंग IoC कंटेनर उस प्रारूप से पूरी तरह से डिकोड किया गया है जिसमें यह कॉन्फ़िगरेशन मेटाडेटा वास्तव में लिखा गया है। स्प्रिंग कंटेनर में कॉन्फ़िगरेशन मेटाडेटा प्रदान करने के लिए तीन महत्वपूर्ण तरीके निम्नलिखित हैं -
- XML आधारित कॉन्फ़िगरेशन फ़ाइल।
- एनोटेशन-आधारित कॉन्फ़िगरेशन
- जावा-आधारित कॉन्फ़िगरेशन
आपने पहले ही देखा है कि XML-आधारित कॉन्फ़िगरेशन मेटाडेटा कंटेनर को कैसे प्रदान किया जाता है, लेकिन आइए हम XML-आधारित कॉन्फ़िगरेशन फ़ाइल का एक और नमूना देखते हैं जिसमें आलसी इनिशियलाइज़ेशन, इनिशियलाइज़ेशन विधि और विनाश विधि सहित विभिन्न बीन परिभाषाएँ शामिल हैं -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- A simple bean definition -->
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with lazy init set on -->
<bean id = "..." class = "..." lazy-init = "true">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with initialization method -->
<bean id = "..." class = "..." init-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- A bean definition with destruction method -->
<bean id = "..." class = "..." destroy-method = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->
</beans>स्प्रिंग बीन्स को परिभाषित, कॉन्फ़िगर और बनाने के तरीके को समझने के लिए आप स्प्रिंग हैलो वर्ल्ड उदाहरण की जांच कर सकते हैं ।
हम एक अलग अध्याय में एनोटेशन आधारित कॉन्फ़िगरेशन के बारे में चर्चा करेंगे। जानबूझकर एक अलग अध्याय में चर्चा की जाती है क्योंकि हम चाहते हैं कि आप कुछ अन्य महत्वपूर्ण वसंत अवधारणाओं को समझें, इससे पहले कि आप एनोटेशन के साथ स्प्रिंग डिपेंडेंसी इंजेक्शन के साथ प्रोग्रामिंग शुरू करें।
<B> को परिभाषित करते समय आपके पास उस बीन के लिए एक गुंजाइश घोषित करने का विकल्प होता है। उदाहरण के लिए, स्प्रिंग को हर बार एक नए सेम उदाहरण का निर्माण करने के लिए मजबूर करने के लिए, आपको बीन के दायरे की विशेषता को घोषित करना चाहिएprototype। इसी तरह, यदि आप चाहते हैं कि स्प्रिंग को हर बार एक ही सेम उदाहरण वापस करना चाहिए, तो आपको बीन के दायरे को घोषित करना चाहिएsingleton।
स्प्रिंग फ्रेमवर्क निम्नलिखित पाँच स्कोपों का समर्थन करता है, जिनमें से तीन केवल तभी उपलब्ध होते हैं जब आप किसी वेब-जागरूक ApplicationContext का उपयोग करते हैं।
| अनु क्रमांक। | स्कोप और विवरण |
|---|---|
| 1 | singleton यह प्रति स्प्रिंग IoC कंटेनर (डिफ़ॉल्ट) में एकल उदाहरण के लिए बीन की परिभाषा देता है। |
| 2 | prototype यह किसी भी संख्या उदाहरण के उदाहरण के लिए एक एकल बीन की परिभाषा देता है। |
| 3 | request यह एक HTTP अनुरोध के लिए एक बीन परिभाषा स्कोप करता है। केवल एक वेब-जागरूक स्प्रिंग एप्लिकेशन कॉन्टेक्स्ट के संदर्भ में मान्य है। |
| 4 | session यह HTTP सत्र में बीन की परिभाषा देता है। केवल एक वेब-जागरूक स्प्रिंग एप्लिकेशन कॉन्टेक्स्ट के संदर्भ में मान्य है। |
| 5 | global-session यह वैश्विक HTTP सत्र में सेम की परिभाषा देता है। केवल एक वेब-जागरूक स्प्रिंग एप्लिकेशन कॉन्टेक्स्ट के संदर्भ में मान्य है। |
इस अध्याय में, हम पहले दो स्कोपों के बारे में चर्चा करेंगे और शेष तीन पर चर्चा की जाएगी, जब हम वेब-अवगत स्प्रिंग एप्लाइटेक्स के बारे में चर्चा करेंगे।
सिंगलटन स्कोप
यदि कोई दायरा सिंगलटन पर सेट है, तो स्प्रिंग IoC कंटेनर उस बीन परिभाषा द्वारा परिभाषित ऑब्जेक्ट का ठीक एक उदाहरण बनाता है। इस एकल उदाहरण को ऐसी सिंगलटन बीन्स के एक कैश में संग्रहीत किया जाता है, और उसके बाद के सभी अनुरोधों और संदर्भों के लिए जिसका नाम सेम की गई वस्तु वापस किया जाता है।
डिफ़ॉल्ट स्कोप हमेशा सिंगलटन होता है। हालाँकि, जब आपको बीन की एक और एक ही आवश्यकता होती है, तो आप इसे सेट कर सकते हैंscope के लिए संपत्ति singleton सेम कॉन्फ़िगरेशन फ़ाइल में, जैसा कि निम्नलिखित कोड स्निपेट में दिखाया गया है -
<!-- A bean definition with singleton scope -->
<bean id = "..." class = "..." scope = "singleton">
<!-- collaborators and configuration for this bean go here -->
</bean>उदाहरण
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}निम्नलिखित विन्यास फाइल है Beans.xml सिंगलटन स्कोप के लिए आवश्यक -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "singleton">
</bean>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
Your Message : I'm object A
Your Message : I'm object Aप्रोटोटाइप गुंजाइश
यदि स्कोप प्रोटोटाइप के लिए सेट किया गया है, तो स्प्रिंग IoC कंटेनर हर बार उस विशिष्ट बीन के लिए अनुरोध का एक नया बीन उदाहरण बनाता है। एक नियम के रूप में, सभी स्टेट-फुल बीन्स के लिए प्रोटोटाइप स्कोप और स्टेटलेस बीन्स के लिए सिंगलटन स्कोप का उपयोग करें।
एक प्रोटोटाइप दायरे को परिभाषित करने के लिए, आप इसे सेट कर सकते हैं scope के लिए संपत्ति prototype सेम कॉन्फ़िगरेशन फ़ाइल में, जैसा कि निम्नलिखित कोड स्निपेट में दिखाया गया है -
<!-- A bean definition with prototype scope -->
<bean id = "..." class = "..." scope = "prototype">
<!-- collaborators and configuration for this bean go here -->
</bean>उदाहरण
आइए हम जगह में ग्रहण आईडीई काम कर रहे हैं और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित चरणों का पालन करें -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.setMessage("I'm object A");
objA.getMessage();
HelloWorld objB = (HelloWorld) context.getBean("helloWorld");
objB.getMessage();
}
}निम्नलिखित विन्यास फाइल है Beans.xml प्रोटोटाइप दायरे के लिए आवश्यक -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" scope = "prototype">
</bean>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
Your Message : I'm object A
Your Message : nullएक स्प्रिंग बीन के जीवन चक्र को समझना आसान है। जब एक बीन तुरंत तैयार किया जाता है, तो इसे एक उपयोगी अवस्था में लाने के लिए कुछ प्रारंभिक प्रदर्शन करने की आवश्यकता हो सकती है। इसी तरह, जब बीन की आवश्यकता नहीं होती है और कंटेनर से निकाल दिया जाता है, तो कुछ सफाई की आवश्यकता हो सकती है।
हालांकि, बीन इंस्टेंटेशन के समय और उसके विनाश के बीच दृश्य के पीछे होने वाली गतिविधियों की सूची है, इस अध्याय में केवल दो महत्वपूर्ण बीन जीवन चक्र कॉलबैक विधियों पर चर्चा की जाएगी, जो बीन इनिशियलाइज़ेशन और इसके विनाश के समय आवश्यक हैं।
एक बीन के लिए सेटअप और टैडडाउन को परिभाषित करने के लिए, हम बस <b> के साथ की घोषणा करते हैं initmethod और / या destroy-methodमापदंडों। Init- विधि विशेषता एक विधि को निर्दिष्ट करती है जिसे बीन पर तुरंत इंस्टेंटेशन पर बुलाया जाना है। इसी तरह, डिस्ट्रोइमेथोड एक विधि को निर्दिष्ट करता है जिसे कंटेनर से निकालने से ठीक पहले कहा जाता है।
प्रारंभिक कॉलबैक
Org.springframework.beans.factory.InitializingBean इंटरफ़ेस एक एकल विधि निर्दिष्ट करता है -
void afterPropertiesSet() throws Exception;इस प्रकार, आप बस उपरोक्त इंटरफ़ेस को लागू कर सकते हैं और इनिशियलाइज़ेशन कार्य afterPropertiesSet () विधि के अंदर किया जा सकता है -
public class ExampleBean implements InitializingBean {
public void afterPropertiesSet() {
// do some initialization work
}
}XML- आधारित कॉन्फ़िगरेशन मेटाडेटा के मामले में, आप का उपयोग कर सकते हैं init-methodउस विधि का नाम निर्दिष्ट करने की विशेषता जिसमें शून्य-तर्क हस्ताक्षर हो। उदाहरण के लिए -
<bean id = "exampleBean" class = "examples.ExampleBean" init-method = "init"/>निम्नलिखित वर्ग परिभाषा है -
public class ExampleBean {
public void init() {
// do some initialization work
}
}विनाश कॉलबैक
Org.springframework.beans.factory.DisposableBean इंटरफ़ेस एक भी विधि निर्दिष्ट करता है -
void destroy() throws Exception;इस प्रकार, आप बस उपरोक्त इंटरफ़ेस को लागू कर सकते हैं और अंतिम रूप देने का काम नष्ट () विधि के अंदर किया जा सकता है -
public class ExampleBean implements DisposableBean {
public void destroy() {
// do some destruction work
}
}XML- आधारित कॉन्फ़िगरेशन मेटाडेटा के मामले में, आप का उपयोग कर सकते हैं destroy-methodउस विधि का नाम निर्दिष्ट करने की विशेषता जिसमें शून्य-तर्क हस्ताक्षर हो। उदाहरण के लिए -
<bean id = "exampleBean" class = "examples.ExampleBean" destroy-method = "destroy"/>निम्नलिखित वर्ग परिभाषा है -
public class ExampleBean {
public void destroy() {
// do some destruction work
}
}यदि आप गैर-वेब अनुप्रयोग वातावरण में स्प्रिंग के IoC कंटेनर का उपयोग कर रहे हैं; उदाहरण के लिए, एक अमीर क्लाइंट डेस्कटॉप वातावरण में, आप JVM के साथ शटडाउन हुक को पंजीकृत करते हैं। ऐसा करने से एक सुंदर शटडाउन सुनिश्चित होता है और आपके सिंगलटन बीन्स पर प्रासंगिक नष्ट तरीकों को कॉल करता है ताकि सभी संसाधन जारी हो सकें।
यह अनुशंसा की जाती है कि आप InitializingBean या डिस्पोजेबल बीनबैक का उपयोग न करें, क्योंकि XML कॉन्फ़िगरेशन आपके नामकरण के संदर्भ में बहुत लचीलापन देता है।
उदाहरण
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy() {
System.out.println("Bean will destroy now.");
}
}निम्नलिखित की सामग्री है MainApp.javaफ़ाइल। यहां आपको शटडाउन हुक को पंजीकृत करने की आवश्यकता हैregisterShutdownHook()वह विधि जो AbstractApplicationContext क्लास पर घोषित की जाती है। यह एक सुंदर शटडाउन सुनिश्चित करेगा और प्रासंगिक विनाश विधियों को कॉल करेगा।
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}निम्नलिखित विन्यास फाइल है Beans.xml init और विध्वंस विधियों के लिए आवश्यक -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" init-method = "init"
destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
Bean is going through init.
Your Message : Hello World!
Bean will destroy now.डिफ़ॉल्ट आरंभीकरण और तरीकों को नष्ट
यदि आपके पास एक ही नाम के साथ आरंभिक और / या विधियाँ नष्ट करने वाली बहुत सी फलियाँ हैं, तो आपको घोषणा करने की आवश्यकता नहीं है init-method तथा destroy-methodप्रत्येक व्यक्तिगत बीन पर। इसके बजाय, फ्रेमवर्क ऐसी स्थिति का उपयोग करने के लिए लचीलापन प्रदान करता हैdefault-init-method तथा default-destroy-method <सेम> तत्व पर निम्नानुसार विशेषताएं -
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"
default-init-method = "init"
default-destroy-method = "destroy">
<bean id = "..." class = "...">
<!-- collaborators and configuration for this bean go here -->
</bean>
</beans>BeanPostProcessor इंटरफ़ेस कॉलबैक विधियों को परिभाषित करता है जिसे आप अपने स्वयं के तात्कालिकता तर्क, निर्भरता-संकल्प तर्क, आदि प्रदान करने के लिए लागू कर सकते हैं। आप स्प्रिंग कंटेनर के तुरंत खत्म होने, कॉन्फ़िगर करने और एक या अधिक बीनपोस्टप्रोसेसर कार्यान्वयन में बीन को शुरू करने के बाद कुछ कस्टम तर्क भी लागू कर सकते हैं ।
आप कई बीनपोस्टप्रोसेसर इंटरफेस कॉन्फ़िगर कर सकते हैं और आप उस क्रम को नियंत्रित कर सकते हैं जिसमें ये बीनपोस्टप्रोसेसर इंटरफेस सेट करने के लिए निष्पादित होते हैं order संपत्ति बीनपोस्टप्रोसेसर प्रदान करती है Ordered इंटरफेस।
बीनपोस्टप्रोसेसर बीन (या ऑब्जेक्ट) इंस्टेंस पर काम करते हैं, जिसका अर्थ है कि स्प्रिंग आईओसी कंटेनर बीन इंस्टेंट को इंस्टेंट करता है और फिर बीनपोस्टप्रोसेसर इंटरफेस अपना काम करते हैं।
एक ApplicationContext स्वचालित रूप से किसी भी बीन्स का पता लगाता है जिसे के कार्यान्वयन के साथ परिभाषित किया गया है BeanPostProcessor इंटरफ़ेस और इन सेम को पोस्टप्रोसेसर के रूप में पंजीकृत करता है, फिर सेम निर्माण पर कंटेनर द्वारा उचित रूप से कहा जाता है।
उदाहरण
निम्नलिखित उदाहरण दिखाते हैं कि कैसे एक आवेदन पत्र के संदर्भ में बीनपोस्टप्रोसेसर को लिखना, पंजीकरण करना और उसका उपयोग करना है।
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld , InitHelloWorld और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल -
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
public void init(){
System.out.println("Bean is going through init.");
}
public void destroy(){
System.out.println("Bean will destroy now.");
}
}यह बीनपोस्टप्रोसेसर को लागू करने का एक बहुत ही बुनियादी उदाहरण है, जो किसी भी बीन के आरंभीकरण से पहले और बाद में एक बीन नाम प्रिंट करता है। आप बीन को पहले और बाद में अधिक जटिल तर्क को लागू कर सकते हैं क्योंकि आपके पास दोनों पोस्ट प्रोसेसर विधियों के अंदर बीन ऑब्जेक्ट पर पहुंच है।
यहाँ की सामग्री है InitHelloWorld.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.beans.BeansException;
public class InitHelloWorld implements BeanPostProcessor {
public Object postProcessBeforeInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("BeforeInitialization : " + beanName);
return bean; // you can return any other object as well
}
public Object postProcessAfterInitialization(Object bean, String beanName)
throws BeansException {
System.out.println("AfterInitialization : " + beanName);
return bean; // you can return any other object as well
}
}निम्नलिखित की सामग्री है MainApp.javaफ़ाइल। यहां आपको शटडाउन हुक को पंजीकृत करने की आवश्यकता हैregisterShutdownHook()वह विधि जो AbstractApplicationContext क्लास पर घोषित की जाती है। यह एक सुंदर शटडाउन सुनिश्चित करता है और प्रासंगिक विनाश विधियों को कॉल करता है।
package com.tutorialspoint;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
context.registerShutdownHook();
}
}निम्नलिखित विन्यास फाइल है Beans.xml init और विध्वंस विधियों के लिए आवश्यक -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
init-method = "init" destroy-method = "destroy">
<property name = "message" value = "Hello World!"/>
</bean>
<bean class = "com.tutorialspoint.InitHelloWorld" />
</beans>एक बार जब आप स्रोत और बीन विन्यास फाइल बनाने के साथ हो जाते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
BeforeInitialization : helloWorld
Bean is going through init.
AfterInitialization : helloWorld
Your Message : Hello World!
Bean will destroy now.एक बीन परिभाषा में बहुत सारी कॉन्फ़िगरेशन जानकारी हो सकती है, जिसमें कंस्ट्रक्टर तर्क, संपत्ति मान और कंटेनर-विशिष्ट जानकारी जैसे कि इनिशियलाइज़ेशन मेथड, स्टैटिक फ़ैक्टरी मेथड नेम, इत्यादि शामिल हैं।
एक बाल बीन परिभाषा एक मूल परिभाषा से विन्यास डेटा विरासत में मिली है। बच्चे की परिभाषा कुछ मूल्यों को ओवरराइड कर सकती है, या आवश्यकतानुसार दूसरों को जोड़ सकती है।
स्प्रिंग बीन परिभाषा वंशानुक्रम का जावा वर्ग विरासत के साथ कोई लेना-देना नहीं है, लेकिन विरासत की अवधारणा समान है। आप एक पेरेंट बीन परिभाषा को एक टेम्पलेट के रूप में परिभाषित कर सकते हैं और अन्य बच्चे बीन्स पेरेंट बीन से आवश्यक कॉन्फ़िगरेशन प्राप्त कर सकते हैं।
जब आप XML- आधारित कॉन्फ़िगरेशन मेटाडेटा का उपयोग करते हैं, तो आप का उपयोग करके चाइल्ड बीन परिभाषा इंगित करते हैं parent विशेषता, इस विशेषता के मूल्य के रूप में मूल बीन को निर्दिष्ट करना।
उदाहरण
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld , HelloIndia और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
निम्नलिखित विन्यास फाइल है Beans.xmlजहाँ हमने "helloWorld" बीन को परिभाषित किया है जिसमें दो गुणन संदेश 1 और संदेश 2 हैं । अगले "हेल्लोइंडिया" बीन को "हेल्लोवर्ल्ड" बीन के एक बच्चे के रूप में परिभाषित किया गया हैparentविशेषता। बच्चे सेम inherits message2 संपत्ति के रूप में है, और ओवरराइड message1 संपत्ति और प्रस्तुत किया एक और संपत्ति message3 ।
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
</bean>
<bean id ="helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "helloWorld">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>यहाँ की सामग्री है HelloWorld.java फ़ाइल -
package com.tutorialspoint;
public class HelloWorld {
private String message1;
private String message2;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void getMessage1(){
System.out.println("World Message1 : " + message1);
}
public void getMessage2(){
System.out.println("World Message2 : " + message2);
}
}यहाँ की सामग्री है HelloIndia.java फ़ाइल -
package com.tutorialspoint;
public class HelloIndia {
private String message1;
private String message2;
private String message3;
public void setMessage1(String message){
this.message1 = message;
}
public void setMessage2(String message){
this.message2 = message;
}
public void setMessage3(String message){
this.message3 = message;
}
public void getMessage1(){
System.out.println("India Message1 : " + message1);
}
public void getMessage2(){
System.out.println("India Message2 : " + message2);
}
public void getMessage3(){
System.out.println("India Message3 : " + message3);
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
HelloWorld objA = (HelloWorld) context.getBean("helloWorld");
objA.getMessage1();
objA.getMessage2();
HelloIndia objB = (HelloIndia) context.getBean("helloIndia");
objB.getMessage1();
objB.getMessage2();
objB.getMessage3();
}
}एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
World Message1 : Hello World!
World Message2 : Hello Second World!
India Message1 : Hello India!
India Message2 : Hello Second World!
India Message3 : Namaste India!यदि आपने यहां देखा, तो हमने "helloIndia" बीन बनाते समय मैसेज 2 पास नहीं किया, लेकिन यह बीन डेफिनिशन इनहेरिटेंस के कारण पास हो गया।
बीन परिभाषा टेम्पलेट
आप एक बीन डेफिनिशन टेम्प्लेट बना सकते हैं, जिसका उपयोग अन्य बाल बीन परिभाषाओं द्वारा बहुत प्रयास किए बिना किया जा सकता है। बीन डेफिनिशन टेम्पलेट को परिभाषित करते समय, आपको निर्दिष्ट नहीं करना चाहिएclass विशेषता और निर्दिष्ट करना चाहिए abstract विशेषता और अमूर्त विशेषता को एक मान के साथ निर्दिष्ट करना चाहिए true जैसा कि निम्नलिखित कोड स्निपेट में दिखाया गया है -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "beanTeamplate" abstract = "true">
<property name = "message1" value = "Hello World!"/>
<property name = "message2" value = "Hello Second World!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
<bean id = "helloIndia" class = "com.tutorialspoint.HelloIndia" parent = "beanTeamplate">
<property name = "message1" value = "Hello India!"/>
<property name = "message3" value = "Namaste India!"/>
</bean>
</beans>अभिभावक बीन को अपने दम पर तुरंत नहीं दे सकता क्योंकि यह अधूरा है, और इसे स्पष्ट रूप से सार के रूप में भी चिह्नित किया गया है । जब एक परिभाषा इस तरह से अमूर्त होती है, तो यह केवल एक शुद्ध टेम्पलेट बीन परिभाषा के रूप में उपयोग करने योग्य होती है जो बच्चे की परिभाषा के लिए मूल परिभाषा के रूप में कार्य करती है।
हर जावा-आधारित एप्लिकेशन में कुछ ऑब्जेक्ट्स होते हैं जो एक साथ काम करने के लिए एंड-यूज़र को एक कार्य अनुप्रयोग के रूप में प्रस्तुत करने के लिए काम करते हैं। एक जटिल जावा एप्लिकेशन लिखते समय, इन कक्षाओं के पुन: उपयोग की संभावना बढ़ाने के लिए और यूनिट परीक्षण करते समय अन्य वर्गों के स्वतंत्र रूप से परीक्षण करने के लिए आवेदन कक्षाएं अन्य जावा कक्षाओं के रूप में स्वतंत्र होनी चाहिए। निर्भरता इंजेक्शन (या कुछ समय जिसे वायरिंग कहा जाता है) इन वर्गों को एक साथ चमकाने में मदद करता है और साथ ही उन्हें स्वतंत्र रखता है।
विचार करें कि आपके पास एक एप्लिकेशन है जिसमें एक पाठ संपादक घटक है और आप एक वर्तनी जांच प्रदान करना चाहते हैं। आपका मानक कोड कुछ इस तरह दिखेगा -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor() {
spellChecker = new SpellChecker();
}
}हमने यहां जो कुछ किया है, वह TextEditor और SpellChecker के बीच निर्भरता पैदा करता है। नियंत्रण परिदृश्य के विलोम में, हम इसके बजाय कुछ ऐसा करेंगे -
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker) {
this.spellChecker = spellChecker;
}
}यहां, TextEditor को SpellChecker के कार्यान्वयन के बारे में चिंता नहीं करनी चाहिए। SpellChecker को स्वतंत्र रूप से लागू किया जाएगा और उसे TextEditor को इंस्टेंटएडर इंस्टेंटेशन के समय प्रदान किया जाएगा। यह पूरी प्रक्रिया स्प्रिंग फ्रेमवर्क द्वारा नियंत्रित की जाती है।
यहां, हमने TextEditor से कुल नियंत्रण हटा दिया है और इसे कहीं और (यानी XML कॉन्फ़िगरेशन फ़ाइल) रखा है और निर्भरता (यानी वर्ग वर्तनी जाँचकर्ता) को TextEditor के माध्यम से कक्षा में इंजेक्ट किया जा रहा है Class Constructor। इस प्रकार नियंत्रण का प्रवाह निर्भरता इंजेक्शन (डीआई) द्वारा "उलटा" किया गया है क्योंकि आपने कुछ बाहरी सिस्टम पर निर्भरता को प्रभावी ढंग से प्रत्यायोजित किया है।
निर्भरता को इंजेक्ट करने की दूसरी विधि है Setter MethodsTextEditor वर्ग की जहां हम एक SpellChecker उदाहरण बनाएंगे। इस उदाहरण का उपयोग TextEditor के गुणों को प्रारंभ करने के लिए सेटर विधियों को कॉल करने के लिए किया जाएगा।
इस प्रकार, डीआई दो प्रमुख संस्करणों में मौजूद है और निम्नलिखित दो उप-अध्याय दोनों को उदाहरणों के साथ कवर करेंगे -
| अनु क्रमांक। | निर्भरता इंजेक्शन प्रकार और विवरण |
|---|---|
| 1 | कंस्ट्रक्टर-आधारित निर्भरता इंजेक्शन कंस्ट्रक्टर-आधारित DI को तब पूरा किया जाता है जब कंटेनर एक क्लास कंस्ट्रक्टर को कई तर्कों के साथ आमंत्रित करता है, प्रत्येक दूसरे क्लास पर निर्भरता का प्रतिनिधित्व करता है। |
| 2 | सेटर-आधारित निर्भरता इंजेक्शन सेटर-आधारित डि को आपके सेम पर तत्काल तर्क निर्माता या नो-लॉजिक स्टैटिक फैक्ट्री विधि के आह्वान के बाद आपकी सेम पर सेटर कॉलिंग विधियों द्वारा पूरा किया जाता है। |
आप कंस्ट्रक्टर-आधारित और सेटर-आधारित DI दोनों का मिश्रण कर सकते हैं, लेकिन अनिवार्य निर्भरता के लिए कंस्ट्रक्टर के तर्क का उपयोग करना और वैकल्पिक निर्भरता के लिए बसने के लिए अंगूठे का एक अच्छा नियम है।
कोड डीआई सिद्धांत के साथ क्लीनर है और वस्तुओं को उनकी निर्भरता के साथ प्रदान किए जाने पर डिकॉउलिंग अधिक प्रभावी है। ऑब्जेक्ट अपनी निर्भरता को नहीं देखता है और निर्भरता के स्थान या वर्ग को नहीं जानता है, बल्कि स्प्रिंग फ्रेमवर्क द्वारा सब कुछ ध्यान रखा जाता है।
जैसा कि आप जानते हैं कि जावा आंतरिक कक्षाएं अन्य वर्गों के दायरे में परिभाषित की जाती हैं, इसी तरह, inner beansबीन्स हैं जो एक और सेम के दायरे में परिभाषित किए गए हैं। इस प्रकार, <गुण /> या <निर्माणकर्ता-आर्ग /> तत्वों के अंदर एक <बीन /> तत्व को आंतरिक बीन कहा जाता है और इसे नीचे दिखाया गया है।
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "outerBean" class = "...">
<property name = "target">
<bean id = "innerBean" class = "..."/>
</property>
</bean>
</beans>उदाहरण
आइए हम जगह में ग्रहण आईडीई काम कर रहे हैं और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित चरणों का पालन करें -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java क्लासेज TextEditor , SpellChecker और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है TextEditor.java फ़ाइल -
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
// a setter method to inject the dependency.
public void setSpellChecker(SpellChecker spellChecker) {
System.out.println("Inside setSpellChecker." );
this.spellChecker = spellChecker;
}
// a getter method to return spellChecker
public SpellChecker getSpellChecker() {
return spellChecker;
}
public void spellCheck() {
spellChecker.checkSpelling();
}
}निम्नलिखित अन्य निर्भर वर्ग फ़ाइल की सामग्री है SpellChecker.java -
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
TextEditor te = (TextEditor) context.getBean("textEditor");
te.spellCheck();
}
}निम्नलिखित विन्यास फाइल है Beans.xml जिसमें सेटर-आधारित इंजेक्शन के लिए कॉन्फ़िगरेशन है, लेकिन उपयोग कर रहा है inner beans -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for textEditor bean using inner bean -->
<bean id = "textEditor" class = "com.tutorialspoint.TextEditor">
<property name = "spellChecker">
<bean id = "spellChecker" class = "com.tutorialspoint.SpellChecker"/>
</property>
</bean>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
Inside SpellChecker constructor.
Inside setSpellChecker.
Inside checkSpelling.आपने देखा है कि कैसे आदिम डेटा प्रकार का उपयोग करके कॉन्फ़िगर किया जाता है value विशेषता और ऑब्जेक्ट संदर्भों का उपयोग करना refआपकी बीन कॉन्फ़िगरेशन फ़ाइल में <संपत्ति> टैग की विशेषता। दोनों मामले एक बीन के लिए एकवचन मान से गुजरते हैं।
अब क्या होगा यदि आप बहुवचन मानों जैसे कि जावा संग्रह प्रकार जैसे सूची, सेट, मानचित्र और गुण पास करना चाहते हैं। स्थिति को संभालने के लिए, स्प्रिंग चार प्रकार के संग्रह विन्यास तत्व प्रदान करता है जो इस प्रकार हैं -
| अनु क्रमांक | तत्व और विवरण |
|---|---|
| 1 | <list> यह डुप्लिकेट को अनुमति देते हुए वायरिंग यानी मानों की सूची को इंजेक्ट करने में मदद करता है। |
| 2 | <set> यह मूल्यों का एक सेट वायरिंग में मदद करता है लेकिन बिना किसी डुप्लिकेट के। |
| 3 | <map> इसका उपयोग नाम-मूल्य जोड़े के संग्रह को इंजेक्ट करने के लिए किया जा सकता है जहां नाम और मूल्य किसी भी प्रकार के हो सकते हैं। |
| 4 | <props> इसका उपयोग नाम-मूल्य जोड़े के संग्रह को इंजेक्ट करने के लिए किया जा सकता है जहां नाम और मूल्य दोनों स्ट्रिंग्स हैं। |
Java.util.Collection या a के किसी भी कार्यान्वयन को तार करने के लिए आप या तो <सूची> या <सेट> का उपयोग कर सकते हैं array।
आप दो स्थितियों में आएंगे (ए) संग्रह के प्रत्यक्ष मूल्यों को पास करना और (बी) संग्रह तत्वों में से एक के रूप में एक सेम के संदर्भ में गुजरना।
उदाहरण
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Com.tutorialspoint पैकेज के तहत Java क्लासेज JavaCollection और MainApp बनाएं । |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है JavaCollection.java फ़ाइल -
package com.tutorialspoint;
import java.util.*;
public class JavaCollection {
List addressList;
Set addressSet;
Map addressMap;
Properties addressProp;
// a setter method to set List
public void setAddressList(List addressList) {
this.addressList = addressList;
}
// prints and returns all the elements of the list.
public List getAddressList() {
System.out.println("List Elements :" + addressList);
return addressList;
}
// a setter method to set Set
public void setAddressSet(Set addressSet) {
this.addressSet = addressSet;
}
// prints and returns all the elements of the Set.
public Set getAddressSet() {
System.out.println("Set Elements :" + addressSet);
return addressSet;
}
// a setter method to set Map
public void setAddressMap(Map addressMap) {
this.addressMap = addressMap;
}
// prints and returns all the elements of the Map.
public Map getAddressMap() {
System.out.println("Map Elements :" + addressMap);
return addressMap;
}
// a setter method to set Property
public void setAddressProp(Properties addressProp) {
this.addressProp = addressProp;
}
// prints and returns all the elements of the Property.
public Properties getAddressProp() {
System.out.println("Property Elements :" + addressProp);
return addressProp;
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल -
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
JavaCollection jc=(JavaCollection)context.getBean("javaCollection");
jc.getAddressList();
jc.getAddressSet();
jc.getAddressMap();
jc.getAddressProp();
}
}निम्नलिखित विन्यास फाइल है Beans.xml जिसमें सभी प्रकार के संग्रह के लिए विन्यास है -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Definition for javaCollection -->
<bean id = "javaCollection" class = "com.tutorialspoint.JavaCollection">
<!-- results in a setAddressList(java.util.List) call -->
<property name = "addressList">
<list>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</list>
</property>
<!-- results in a setAddressSet(java.util.Set) call -->
<property name = "addressSet">
<set>
<value>INDIA</value>
<value>Pakistan</value>
<value>USA</value>
<value>USA</value>
</set>
</property>
<!-- results in a setAddressMap(java.util.Map) call -->
<property name = "addressMap">
<map>
<entry key = "1" value = "INDIA"/>
<entry key = "2" value = "Pakistan"/>
<entry key = "3" value = "USA"/>
<entry key = "4" value = "USA"/>
</map>
</property>
<!-- results in a setAddressProp(java.util.Properties) call -->
<property name = "addressProp">
<props>
<prop key = "one">INDIA</prop>
<prop key = "one">INDIA</prop>
<prop key = "two">Pakistan</prop>
<prop key = "three">USA</prop>
<prop key = "four">USA</prop>
</props>
</property>
</bean>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
List Elements :[INDIA, Pakistan, USA, USA]
Set Elements :[INDIA, Pakistan, USA]
ap Elements :{1 = INDIA, 2 = Pakistan, 3 = USA, 4 = USA}
Property Elements :{two = Pakistan, one = INDIA, three = USA, four = USA}बीन सन्दर्भों का इंजेक्शन
निम्नलिखित बीन परिभाषा आपको यह समझने में मदद करेगी कि संग्रह के तत्व में से एक के रूप में बीन संदर्भ को कैसे इंजेक्ट किया जाए। यहां तक कि आप निम्नलिखित कोड स्निपेट में दिखाए गए संदर्भों और मूल्यों को एक साथ मिला सकते हैं -
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<!-- Bean Definition to handle references and values -->
<bean id = "..." class = "...">
<!-- Passing bean reference for java.util.List -->
<property name = "addressList">
<list>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</list>
</property>
<!-- Passing bean reference for java.util.Set -->
<property name = "addressSet">
<set>
<ref bean = "address1"/>
<ref bean = "address2"/>
<value>Pakistan</value>
</set>
</property>
<!-- Passing bean reference for java.util.Map -->
<property name = "addressMap">
<map>
<entry key = "one" value = "INDIA"/>
<entry key = "two" value-ref = "address1"/>
<entry key = "three" value-ref = "address2"/>
</map>
</property>
</bean>
</beans>उपरोक्त बीन परिभाषा का उपयोग करने के लिए, आपको अपनी सेटर विधियों को इस तरह से परिभाषित करने की आवश्यकता है कि वे संदर्भों को भी संभालने में सक्षम हों।
अशक्त और रिक्त स्ट्रिंग मानों को इंजेक्ट करना
यदि आपको मान के रूप में एक खाली स्ट्रिंग पास करने की आवश्यकता है, तो आप इसे निम्नानुसार पारित कर सकते हैं -
<bean id = "..." class = "exampleBean">
<property name = "email" value = ""/>
</bean>पूर्ववर्ती उदाहरण जावा कोड के बराबर है: exampleBean.setEmail ("")
यदि आपको NULL मान पास करने की आवश्यकता है, तो आप इसे निम्न प्रकार से पारित कर सकते हैं -
<bean id = "..." class = "exampleBean">
<property name = "email"><null/></property>
</bean>पूर्ववर्ती उदाहरण जावा कोड के बराबर है: exampleBean.setEmail (शून्य)
आपने XML विन्यास फाइल में <b> तत्व और इंजेक्शन <b> का उपयोग करके सेम का ऐलान करना सीख लिया है।
स्प्रिंग कंटेनर कर सकते हैं autowire <constructor-arg> और <property> तत्वों का उपयोग किए बिना बीन्स का सहयोग करने के बीच के संबंध, जो एक बड़े स्प्रिंग-आधारित एप्लिकेशन के लिए आपके द्वारा लिखे गए XML कॉन्फ़िगरेशन की मात्रा में कटौती करने में मदद करता है।
ऑटोडायरिंग मोड्स
निम्नलिखित ऑटोवेयरिंग मोड हैं, जिनका उपयोग स्प्रिंग कंटेनर को निर्भरता इंजेक्शन के लिए ऑटोवेयरिंग का उपयोग करने के निर्देश के लिए किया जा सकता है। आप निर्दिष्ट करने के लिए <bean /> तत्व की ऑटोवेयर विशेषता का उपयोग करते हैंautowire एक सेम परिभाषा के लिए मोड।
| अनु क्रमांक | मोड और विवरण |
|---|---|
| 1 | no यह डिफ़ॉल्ट सेटिंग है, जिसका अर्थ है कि कोई भी ऑटो-फायरिंग नहीं है और आपको वायरिंग के लिए स्पष्ट बीन संदर्भ का उपयोग करना चाहिए। इस वायरिंग के लिए आपको कुछ खास नहीं करना है। यह आप पहले से ही डिपेंडेंसी इंजेक्शन अध्याय में देख चुके हैं। |
| 2 | नाम से संपत्ति के नाम से ऑटोराइरिंग। स्प्रिंग कंटेनर उन बीन्स के गुणों को देखता है जिन पर XML कॉन्फ़िगरेशन फ़ाइल में ऑटोनाम विशेषता को byName पर सेट किया गया है। यह कॉन्फ़िगरेशन फ़ाइल में समान नामों से परिभाषित फलियों के साथ इसके गुणों को मिलान और तार करने की कोशिश करता है। |
| 3 | प्रकार से संपत्ति डेटाटाइप द्वारा स्वतः-लोड हो रहा है। स्प्रिंग कन्टेनर उन बीन्स के गुणों को देखता है जिन पर XML कॉन्फ़िगरेशन फ़ाइल में ऑटोटायर विशेषता को बाईटाइप पर सेट किया गया है। यह तब एक संपत्ति को मैच और तार करने की कोशिश करता है अगर इसकीtypeकॉन्फ़िगरेशन फ़ाइल में सेम नाम में से एक के साथ मेल खाता है। यदि एक से अधिक ऐसी फलियां मौजूद हैं, तो एक घातक अपवाद फेंक दिया जाता है। |
| 4 | constructor Similar to byType, but type applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised. |
| 5 | autodetect Spring first tries to wire using autowire by constructor, if it does not work, Spring tries to autowire by byType. |
You can use byType or constructor autowiring mode to wire arrays and other typed-collections.
Limitations with autowiring
Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing for developers to use it to wire only one or two bean definitions. Though, autowiring can significantly reduce the need to specify properties or constructor arguments but you should consider the limitations and disadvantages of autowiring before using them.
| Sr.No. | Limitations & Description |
|---|---|
| 1 | Overriding possibility You can still specify dependencies using <constructor-arg> and <property> settings which will always override autowiring. |
| 2 | Primitive data types You cannot autowire so-called simple properties such as primitives, Strings, and Classes. |
| 3 | Confusing nature Autowiring is less exact than explicit wiring, so if possible prefer using explict wiring. |
Starting from Spring 2.5 it became possible to configure the dependency injection using annotations. So instead of using XML to describe a bean wiring, you can move the bean configuration into the component class itself by using annotations on the relevant class, method, or field declaration.
Annotation injection is performed before XML injection. Thus, the latter configuration will override the former for properties wired through both approaches.
Annotation wiring is not turned on in the Spring container by default. So, before we can use annotation-based wiring, we will need to enable it in our Spring configuration file. So consider the following configuration file in case you want to use any annotation in your Spring application.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:context = "http://www.springframework.org/schema/context"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:annotation-config/>
<!-- bean definitions go here -->
</beans>Once <context:annotation-config/> is configured, you can start annotating your code to indicate that Spring should automatically wire values into properties, methods, and constructors. Let us look at a few important annotations to understand how they work −
| Sr.No. | Annotation & Description |
|---|---|
| 1 | @Required The @Required annotation applies to bean property setter methods. |
| 2 | @Autowired The @Autowired annotation can apply to bean property setter methods, non-setter methods, constructor and properties. |
| 3 | @Qualifier The @Qualifier annotation along with @Autowired can be used to remove the confusion by specifiying which exact bean will be wired. |
| 4 | JSR-250 Annotations Spring supports JSR-250 based annotations which include @Resource, @PostConstruct and @PreDestroy annotations. |
So far you have seen how we configure Spring beans using XML configuration file. If you are comfortable with XML configuration, then it is really not required to learn how to proceed with Java-based configuration as you are going to achieve the same result using either of the configurations available.
Java-based configuration option enables you to write most of your Spring configuration without XML but with the help of few Java-based annotations explained in this chapter.
@Configuration & @Bean Annotations
Annotating a class with the @Configuration indicates that the class can be used by the Spring IoC container as a source of bean definitions. The @Bean annotation tells Spring that a method annotated with @Bean will return an object that should be registered as a bean in the Spring application context. The simplest possible @Configuration class would be as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}The above code will be equivalent to the following XML configuration −
<beans>
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld" />
</beans>Here, the method name is annotated with @Bean works as bean ID and it creates and returns the actual bean. Your configuration class can have a declaration for more than one @Bean. Once your configuration classes are defined, you can load and provide them to Spring container using AnnotationConfigApplicationContext as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}You can load various configuration classes as follows −
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
ctx.register(AppConfig.class, OtherConfig.class);
ctx.register(AdditionalConfig.class);
ctx.refresh();
MyService myService = ctx.getBean(MyService.class);
myService.doStuff();
}Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes HelloWorldConfig, HelloWorld and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of HelloWorldConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class HelloWorldConfig {
@Bean
public HelloWorld helloWorld(){
return new HelloWorld();
}
}Here is the content of HelloWorld.java file
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(HelloWorldConfig.class);
HelloWorld helloWorld = ctx.getBean(HelloWorld.class);
helloWorld.setMessage("Hello World!");
helloWorld.getMessage();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Your Message : Hello World!Injecting Bean Dependencies
When @Beans have dependencies on one another, expressing that the dependency is as simple as having one bean method calling another as follows −
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class AppConfig {
@Bean
public Foo foo() {
return new Foo(bar());
}
@Bean
public Bar bar() {
return new Bar();
}
}Here, the foo bean receives a reference to bar via the constructor injection. Now let us look at another working example.
Example
Let us have a working Eclipse IDE in place and take the following steps to create a Spring application −
| Steps | Description |
|---|---|
| 1 | Create a project with a name SpringExample and create a package com.tutorialspoint under the src folder in the created project. |
| 2 | Add required Spring libraries using Add External JARs option as explained in the Spring Hello World Example chapter. |
| 3 | Because you are using Java-based annotations, so you also need to add CGLIB.jar from your Java installation directory and ASM.jar library which can be downloaded from asm.ow2.org. |
| 4 | Create Java classes TextEditorConfig, TextEditor, SpellChecker and MainApp under the com.tutorialspoint package. |
| 5 | The final step is to create the content of all the Java files and Bean Configuration file and run the application as explained below. |
Here is the content of TextEditorConfig.java file
package com.tutorialspoint;
import org.springframework.context.annotation.*;
@Configuration
public class TextEditorConfig {
@Bean
public TextEditor textEditor(){
return new TextEditor( spellChecker() );
}
@Bean
public SpellChecker spellChecker(){
return new SpellChecker( );
}
}Here is the content of TextEditor.java file
package com.tutorialspoint;
public class TextEditor {
private SpellChecker spellChecker;
public TextEditor(SpellChecker spellChecker){
System.out.println("Inside TextEditor constructor." );
this.spellChecker = spellChecker;
}
public void spellCheck(){
spellChecker.checkSpelling();
}
}Following is the content of another dependent class file SpellChecker.java
package com.tutorialspoint;
public class SpellChecker {
public SpellChecker(){
System.out.println("Inside SpellChecker constructor." );
}
public void checkSpelling(){
System.out.println("Inside checkSpelling." );
}
}Following is the content of the MainApp.java file
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.*;
public class MainApp {
public static void main(String[] args) {
ApplicationContext ctx =
new AnnotationConfigApplicationContext(TextEditorConfig.class);
TextEditor te = ctx.getBean(TextEditor.class);
te.spellCheck();
}
}Once you are done creating all the source files and adding the required additional libraries, let us run the application. You should note that there is no configuration file required. If everything is fine with your application, it will print the following message −
Inside SpellChecker constructor.
Inside TextEditor constructor.
Inside checkSpelling.The @Import Annotation
The @Import annotation allows for loading @Bean definitions from another configuration class. Consider a ConfigA class as follows −
@Configuration
public class ConfigA {
@Bean
public A a() {
return new A();
}
}You can import above Bean declaration in another Bean Declaration as follows −
@Configuration
@Import(ConfigA.class)
public class ConfigB {
@Bean
public B b() {
return new B();
}
}Now, rather than needing to specify both ConfigA.class and ConfigB.class when instantiating the context, only ConfigB needs to be supplied as follows −
public static void main(String[] args) {
ApplicationContext ctx = new AnnotationConfigApplicationContext(ConfigB.class);
// now both beans A and B will be available...
A a = ctx.getBean(A.class);
B b = ctx.getBean(B.class);
}जीवनचक्र कॉलबैक
@ बीन एनोटेशन, मनमाने ढंग से आरंभीकरण और विनाश कॉलबैक विधियों को निर्दिष्ट करने का समर्थन करता है, जैसे कि स्प्रिंग एक्सएमएल की इनिट-मेथड और बीन तत्व पर विनाश-विधि विशेषताएँ -
public class Foo {
public void init() {
// initialization logic
}
public void cleanup() {
// destruction logic
}
}
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup" )
public Foo foo() {
return new Foo();
}
}बीन स्कोप निर्दिष्ट करना
डिफ़ॉल्ट स्कोप सिंगलटन है, लेकिन आप इसे इस प्रकार मिटा सकते हैं @ स्कोप एनोटेशन निम्नानुसार है -
@Configuration
public class AppConfig {
@Bean
@Scope("prototype")
public Foo foo() {
return new Foo();
}
}आपने सभी अध्यायों में देखा है कि वसंत का मूल है ApplicationContext, जो फलियों के पूर्ण जीवन चक्र का प्रबंधन करता है। बीन्स लोड करते समय ApplicationContext कुछ प्रकार की घटनाओं को प्रकाशित करता है। उदाहरण के लिए, संदर्भ प्रारंभ होने पर एक ContextStartedEvent प्रकाशित होता है और संदर्भ बंद होने पर ContextStontinEvent प्रकाशित होता है।
ApplicationContext में ईवेंट हैंडलिंग ApplicationEvent वर्ग और ApplicationListener इंटरफ़ेस के माध्यम से प्रदान की जाती है। इसलिए, यदि कोई सेम ApplicationListener को लागू करता है , तो हर बार एक ApplicationEvent ApplicationContext पर प्रकाशित हो जाता है, उस सेम को अधिसूचित किया जाता है।
वसंत निम्नलिखित मानक कार्यक्रम प्रदान करता है -
| अनु क्रमांक। | स्प्रिंग बिल्ट-इन इवेंट्स और विवरण |
|---|---|
| 1 | ContextRefreshedEvent यह ईवेंट तब प्रकाशित किया जाता है जब ApplicationContext या तो इनिशियलाइज़ या रिफ्रेश होता है। इसे कॉन्फ़िगरेबल एप्लायसेशन कॉन्टेक्स्ट इंटरफेस पर रिफ्रेश () पद्धति का उपयोग करके भी उठाया जा सकता है। |
| 2 | ContextStartedEvent यह घटना तब प्रकाशित होती है जब ApplicationContext को कॉन्फ़िगरेबल एप्लायसेशन कॉन्टेक्स्ट इंटरफ़ेस पर स्टार्ट () विधि का उपयोग करके शुरू किया जाता है। आप अपने डेटाबेस को प्रदूषित कर सकते हैं या इस घटना को प्राप्त करने के बाद किसी भी रुके हुए आवेदन को पुनः आरंभ कर सकते हैं। |
| 3 | ContextStoppedEvent यह घटना तब प्रकाशित होती है जब ApplicationContext को कॉन्फ़िगरेबल एप्लायसेशन कॉन्टेक्स्ट इंटरफ़ेस पर स्टॉप () विधि का उपयोग करके रोका जाता है। आप इस घटना को प्राप्त करने के बाद आवश्यक हाउसकीप कार्य कर सकते हैं। |
| 4 | ContextClosedEvent यह घटना तब प्रकाशित होती है जब ApplicationContext को कॉन्फ़िगर करने योग्यApplicationContext इंटरफ़ेस पर बंद () विधि का उपयोग करके बंद कर दिया जाता है। एक बंद संदर्भ उसके जीवन के अंत तक पहुंचता है; इसे रिफ्रेश या रीस्टार्ट नहीं किया जा सकता है। |
| 5 | RequestHandledEvent यह एक वेब-विशिष्ट घटना है जो सभी बीन्स को बताती है कि एक HTTP अनुरोध सेवित किया गया है। |
स्प्रिंग की ईवेंट हैंडलिंग एकल-थ्रेडेड है, इसलिए यदि कोई ईवेंट प्रकाशित किया जाता है, जब तक और जब तक कि सभी रिसीवर्स को मैसेज न मिल जाए, प्रॉसेस ब्लॉक हो जाते हैं और फ्लो जारी नहीं रहेगा। इसलिए, अपने एप्लिकेशन को डिज़ाइन करते समय ध्यान रखा जाना चाहिए यदि इवेंट हैंडलिंग का उपयोग किया जाना है।
प्रसंग प्रसंग सुनकर
एक संदर्भ घटना को सुनने के लिए, एक सेम को ApplicationListener इंटरफ़ेस को लागू करना चाहिए जिसमें सिर्फ एक विधि हैonApplicationEvent()। तो आइए एक उदाहरण लिखें कि कैसे घटनाओं का प्रसार होता है और कुछ घटनाओं के आधार पर आवश्यक कार्य करने के लिए आप अपना कोड कैसे डाल सकते हैं।
आइए हम एक काम कर रहे ग्रहण आईडीई को जगह दें और स्प्रिंग एप्लिकेशन बनाने के लिए निम्नलिखित कदम उठाएं -
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | जावा वर्गों बनाएं HelloWorld , CStartEventHandler , CStopEventHandler और MainApp तहत com.tutorialspoint पैकेज। |
| 4 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 5 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage(){
System.out.println("Your Message : " + message);
}
}निम्नलिखित की सामग्री है CStartEventHandler.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStartedEvent;
public class CStartEventHandler
implements ApplicationListener<ContextStartedEvent>{
public void onApplicationEvent(ContextStartedEvent event) {
System.out.println("ContextStartedEvent Received");
}
}निम्नलिखित की सामग्री है CStopEventHandler.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextStoppedEvent;
public class CStopEventHandler
implements ApplicationListener<ContextStoppedEvent>{
public void onApplicationEvent(ContextStoppedEvent event) {
System.out.println("ContextStoppedEvent Received");
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
// Let us raise a start event.
context.start();
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
// Let us raise a stop event.
context.stop();
}
}निम्नलिखित विन्यास फाइल है Beans.xml
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
<bean id = "cStartEventHandler" class = "com.tutorialspoint.CStartEventHandler"/>
<bean id = "cStopEventHandler" class = "com.tutorialspoint.CStopEventHandler"/>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
ContextStartedEvent Received
Your Message : Hello World!
ContextStoppedEvent Receivedयदि आप चाहें, तो आप अपनी खुद की कस्टम घटनाओं को प्रकाशित कर सकते हैं और बाद में आप उन कस्टम घटनाओं के खिलाफ कोई भी कार्रवाई करने के लिए उसी पर कब्जा कर सकते हैं। यदि आप अपनी स्वयं की कस्टम ईवेंट लिखने में रुचि रखते हैं, तो आप स्प्रिंग में कस्टम ईवेंट की जांच कर सकते हैं ।
अपनी खुद की कस्टम घटनाओं को लिखने और प्रकाशित करने के लिए कई कदम उठाए जाने हैं। कस्टम स्प्रिंग ईवेंट को लिखने, प्रकाशित करने और संभालने के लिए इस अध्याय में दिए गए निर्देशों का पालन करें।
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrcबनाया परियोजना में फ़ोल्डर। इस पैकेज के तहत सभी कक्षाएं बनाई जाएंगी। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | एक घटना वर्ग, बनाएं CustomEvent बढ़ा करApplicationEvent। इस वर्ग को डिफॉल्ट कंस्ट्रक्टर को परिभाषित करना चाहिए जो कि ApplicationEvent क्लास से कंस्ट्रक्टर को इनहेरिट करना चाहिए। |
| 4 | एक बार जब आपका ईवेंट क्लास परिभाषित हो जाता है, तो आप इसे किसी भी क्लास से प्रकाशित कर सकते हैं, चलिए हम बताते हैं EventClassPublisher जो ApplicationEventPublisherAware को लागू करता है । आपको XML कॉन्फ़िगरेशन फ़ाइल में इस वर्ग को बीन के रूप में घोषित करने की आवश्यकता होगी ताकि कंटेनर बीन को एक इवेंट प्रकाशक के रूप में पहचान सके क्योंकि यह ApplicationEventPublisherAware इंटरफ़ेस को लागू करता है। |
| 5 | एक प्रकाशित घटना को एक कक्षा में संभाला जा सकता है, चलिए बताते हैं EventClassHandler जो ApplicationListener इंटरफ़ेस को लागू करता है और कस्टम इवेंट के लिए OnApplicationEvent विधि को लागू करता है । |
| 6 | सेम कॉन्फ़िगरेशन फ़ाइल Beans.xml के तहत बनाएँsrcफ़ोल्डर और एक MainApp वर्ग जो स्प्रिंग एप्लिकेशन के रूप में काम करेगा। |
| 7 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है CustomEvent.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ApplicationEvent;
public class CustomEvent extends ApplicationEvent{
public CustomEvent(Object source) {
super(source);
}
public String toString(){
return "My Custom Event";
}
}निम्नलिखित की सामग्री है CustomEventPublisher.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.context.ApplicationEventPublisherAware;
public class CustomEventPublisher implements ApplicationEventPublisherAware {
private ApplicationEventPublisher publisher;
public void setApplicationEventPublisher (ApplicationEventPublisher publisher) {
this.publisher = publisher;
}
public void publish() {
CustomEvent ce = new CustomEvent(this);
publisher.publishEvent(ce);
}
}निम्नलिखित की सामग्री है CustomEventHandler.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ApplicationListener;
public class CustomEventHandler implements ApplicationListener<CustomEvent> {
public void onApplicationEvent(CustomEvent event) {
System.out.println(event.toString());
}
}निम्नलिखित की सामग्री है MainApp.java फ़ाइल
package com.tutorialspoint;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ConfigurableApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
CustomEventPublisher cvp =
(CustomEventPublisher) context.getBean("customEventPublisher");
cvp.publish();
cvp.publish();
}
}निम्नलिखित विन्यास फाइल है Beans.xml
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "customEventHandler" class = "com.tutorialspoint.CustomEventHandler"/>
<bean id = "customEventPublisher" class = "com.tutorialspoint.CustomEventPublisher"/>
</beans>एक बार जब आप स्रोत और बीन कॉन्फ़िगरेशन फ़ाइलों का निर्माण कर लेते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को प्रिंट करेगा -
y Custom Event
y Custom Eventस्प्रिंग फ्रेमवर्क के प्रमुख घटकों में से एक है Aspect oriented programming (AOP)ढांचा। पहलू-ओरिएंटेड प्रोग्रामिंग विभिन्न भागों में प्रोग्राम लॉजिक को तोड़ने के लिए मजबूर करता है जिसे तथाकथित चिंता कहा जाता है। किसी अनुप्रयोग के कई बिंदुओं को जोड़ने वाले कार्य कहलाते हैंcross-cutting concernsऔर ये क्रॉस-कटिंग चिंताएं वैचारिक रूप से एप्लिकेशन के व्यावसायिक तर्क से अलग हैं। लॉगिंग, ऑडिटिंग, घोषणात्मक लेनदेन, सुरक्षा, कैशिंग आदि जैसे पहलुओं के विभिन्न सामान्य अच्छे उदाहरण हैं।
OOP में प्रतिरूपकता की प्रमुख इकाई वर्ग है, जबकि AOP में प्रतिरूपकता की इकाई पहलू है। निर्भरता इंजेक्शन आपको एक दूसरे से अपने आवेदन की वस्तुओं को कम करने में मदद करता है और एओपी आपको प्रभावित होने वाली वस्तुओं से क्रॉस-कटिंग चिंताओं को कम करने में मदद करता है। AOP प्रोग्रामिंग भाषाओं जैसे Perl, .NET, Java, और अन्य में ट्रिगर की तरह है।
स्प्रिंग एओपी मॉड्यूल किसी अनुप्रयोग को अवरोधन करने के लिए इंटरसेप्टर प्रदान करता है। उदाहरण के लिए, जब किसी विधि को निष्पादित किया जाता है, तो आप विधि के निष्पादन से पहले या बाद में अतिरिक्त कार्यक्षमता जोड़ सकते हैं।
एओपी शब्दावली
इससे पहले कि हम एओपी के साथ काम करना शुरू करें, आइए हम एओपी अवधारणाओं और शब्दावली से परिचित हों। ये पद वसंत के लिए विशिष्ट नहीं हैं, बल्कि वे एओपी से संबंधित हैं।
| अनु क्रमांक | शर्तें और विवरण |
|---|---|
| 1 | Aspect यह एक मॉड्यूल है जिसमें एपीआई का एक सेट है जो क्रॉस-कटिंग आवश्यकताओं को प्रदान करता है। उदाहरण के लिए, एक लॉगिंग मॉड्यूल को लॉगिंग के लिए एओपी पहलू कहा जाएगा। एक आवेदन में आवश्यकता के आधार पर किसी भी संख्या में पहलू हो सकते हैं। |
| 2 | Join point यह आपके एप्लिकेशन के एक बिंदु का प्रतिनिधित्व करता है जहां आप AOP पहलू को प्लग-इन कर सकते हैं। आप यह भी कह सकते हैं, यह आवेदन में वास्तविक स्थान है जहां स्प्रिंग एओपी ढांचे का उपयोग करके एक कार्रवाई की जाएगी। |
| 3 | Advice यह विधि निष्पादन से पहले या बाद में की जाने वाली वास्तविक क्रिया है। यह कोड का एक वास्तविक टुकड़ा है जिसे स्प्रिंग एओपी ढांचे द्वारा कार्यक्रम के निष्पादन के दौरान लगाया जाता है। |
| 4 | Pointcut यह एक या एक से अधिक जुड़ने वाले बिंदुओं का एक समूह है जहां एक सलाह पर अमल किया जाना चाहिए। आप अभिव्यक्तियों या पैटर्न का उपयोग करके बिंदु निर्दिष्ट कर सकते हैं जैसा कि हम अपने एओपी उदाहरणों में देखेंगे। |
| 5 | Introduction एक परिचय आपको मौजूदा कक्षाओं में नए तरीकों या विशेषताओं को जोड़ने की अनुमति देता है। |
| 6 | Target object किसी एक या अधिक पहलुओं द्वारा दी जाने वाली वस्तु। यह वस्तु हमेशा एक अनुमानित वस्तु होगी, जिसे सलाहित वस्तु भी कहा जाता है। |
| 7 | Weaving बुनाई एक सलाह दी गई वस्तु बनाने के लिए अन्य एप्लिकेशन प्रकारों या वस्तुओं के साथ पहलुओं को जोड़ने की प्रक्रिया है। यह संकलन समय, लोड समय, या रनटाइम पर किया जा सकता है। |
सलाह के प्रकार
वसंत के पहलू पांच प्रकार की सलाह के साथ काम कर सकते हैं जो निम्नानुसार हैं -
| अनु क्रमांक | सलाह और विवरण |
|---|---|
| 1 | before विधि निष्पादन से पहले सलाह चलाएँ। |
| 2 | after विधि निष्पादन के बाद सलाह चलाएँ, चाहे उसका परिणाम कुछ भी हो। |
| 3 | after-returning विधि निष्पादन के बाद सलाह चलाएँ, यदि विधि सफलतापूर्वक पूर्ण होती है। |
| 4 | after-throwing विधि निष्पादन के बाद सलाह तभी चलाएँ जब कोई अपवाद छोड़ कर विधि बाहर निकलती है। |
| 5 | around सलाह दी गई विधि से पहले और बाद में सलाह चलाएँ। |
कस्टम पहलू कार्यान्वयन
वसंत समर्थन करता है @AspectJ annotation style दृष्टिकोण और schema-basedकस्टम पहलुओं को लागू करने के लिए दृष्टिकोण। इन दो दृष्टिकोणों को निम्नलिखित वर्गों में विस्तार से बताया गया है।
| अनु क्रमांक | दृष्टिकोण और विवरण |
|---|---|
| 1 | XML स्कीमा आधारित एक्सएमएल आधारित कॉन्फ़िगरेशन के साथ नियमित कक्षाओं का उपयोग करके पहलुओं को लागू किया जाता है। |
| 2 | @AspectJ आधारित @AspectJ जावा 5 एनोटेशन के साथ नियमित जावा कक्षाओं के रूप में पहलुओं को घोषित करने की शैली को संदर्भित करता है। |
सादे पुराने JDBC का उपयोग करते हुए डेटाबेस के साथ काम करते समय, अपवादों को खोलने और खोलने और डेटाबेस कनेक्शनों को बंद करने के लिए अनावश्यक कोड लिखना बोझिल हो जाता है, हालांकि, स्प्रिंग JDBC फ्रेमवर्क कनेक्शन खोलने से शुरू होने वाले सभी निम्न-स्तरीय विवरणों की देखभाल करता है, तैयार करता है और SQL कथन, प्रक्रिया अपवादों को निष्पादित करें, लेनदेन को संभालें और अंत में कनेक्शन को बंद करें।
तो आपको जो करना है वह बस कनेक्शन मापदंडों को परिभाषित करें और SQL स्टेटमेंट को निष्पादित करने के लिए निर्दिष्ट करें और डेटाबेस से डेटा प्राप्त करते समय प्रत्येक पुनरावृत्ति के लिए आवश्यक कार्य करें।
स्प्रिंग JDBC डेटाबेस के साथ इंटरफेस करने के लिए कई दृष्टिकोण और इसी तरह अलग-अलग कक्षाएं प्रदान करता है। मैं क्लासिक और सबसे लोकप्रिय दृष्टिकोण लेने जा रहा हूं जो इसका उपयोग करता हैJdbcTemplateढांचे का वर्ग। यह केंद्रीय ढांचा वर्ग है जो सभी डेटाबेस संचार और अपवाद हैंडलिंग का प्रबंधन करता है।
JdbcTemplate क्लास
JDBC टेम्प्लेट क्लास SQL क्वेरीज़, स्टेटमेंट्स को अपडेट करता है, कॉल प्रक्रिया को स्टोर करता है, ResultSets पर पुनरावृत्ति करता है और अर्क पैरामीटर मान लौटाता है। यह JDBC अपवादों को भी पकड़ता है और उन्हें org.springframework.dao पैकेज में परिभाषित सामान्य, अधिक जानकारीपूर्ण, अपवाद पदानुक्रम में अनुवाद करता है।
के उदाहरण JdbcTemplate वर्ग के हैं threadsafe एक बार कॉन्फ़िगर किया गया। तो आप JdbcTemplate के एकल उदाहरण को कॉन्फ़िगर कर सकते हैं और फिर इस साझा संदर्भ को कई DAO में सुरक्षित रूप से इंजेक्ट कर सकते हैं ।
JDBC टेम्प्लेट क्लास का उपयोग करते समय एक सामान्य अभ्यास आपकी स्प्रिंग कॉन्फ़िगरेशन फ़ाइल में एक DataSource कॉन्फ़िगर करना है, और फिर निर्भरता-इंजेक्शन जो आपके DAO वर्गों में DataSource बीन साझा करता है, और JdbcTemplate DataSource के लिए सेट्टर में बनाया गया है।
डेटा स्रोत को कॉन्फ़िगर करना
आइए हम एक डेटाबेस तालिका बनाते हैं Student हमारे डेटाबेस में TEST। हम मानते हैं कि आप MySQL डेटाबेस के साथ काम कर रहे हैं, यदि आप किसी अन्य डेटाबेस के साथ काम करते हैं तो आप अपने DDL और SQL प्रश्नों को तदनुसार बदल सकते हैं।
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);अब हमें JDBC टेम्प्लेट के लिए एक डेटा स्रोत की आपूर्ति करने की आवश्यकता है ताकि यह डेटाबेस एक्सेस प्राप्त करने के लिए खुद को कॉन्फ़िगर कर सके। आप निम्न कोड स्निपेट में दिखाए गए कोड के एक टुकड़े के साथ XML फ़ाइल में डेटा स्रोत कॉन्फ़िगर कर सकते हैं -
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "password"/>
</bean>डेटा एक्सेस ऑब्जेक्ट (DAO)
DAO का अर्थ डेटा एक्सेस ऑब्जेक्ट है, जो आमतौर पर डेटाबेस इंटरैक्शन के लिए उपयोग किया जाता है। DAO डेटाबेस में डेटा को पढ़ने और लिखने का साधन प्रदान करने के लिए मौजूद है और उन्हें इस कार्यक्षमता को एक इंटरफ़ेस के माध्यम से उजागर करना चाहिए जिसके द्वारा बाकी एप्लिकेशन उन तक पहुंच पाएंगे।
स्प्रिंग में DAO का समर्थन डेटा एक्सेस तकनीकों जैसे JDBC, हाइबरनेट, JPA या JDO के साथ सुसंगत तरीके से काम करना आसान बनाता है।
SQL कथन निष्पादित करना
देखते हैं कि हम SQL और JDBC टेम्पलेट ऑब्जेक्ट का उपयोग करके डेटाबेस तालिकाओं पर CRUD (क्रिएट, रीड, अपडेट और डिलीट) ऑपरेशन कैसे कर सकते हैं।
Querying for an integer
String SQL = "select count(*) from Student";
int rowCount = jdbcTemplateObject.queryForInt( SQL );Querying for a long
String SQL = "select count(*) from Student";
long rowCount = jdbcTemplateObject.queryForLong( SQL );A simple query using a bind variable
String SQL = "select age from Student where id = ?";
int age = jdbcTemplateObject.queryForInt(SQL, new Object[]{10});Querying for a String
String SQL = "select name from Student where id = ?";
String name = jdbcTemplateObject.queryForObject(SQL, new Object[]{10}, String.class);Querying and returning an object
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{10}, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Querying and returning multiple objects
String SQL = "select * from Student";
List<Student> students = jdbcTemplateObject.query(
SQL, new StudentMapper());
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setID(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}Inserting a row into the table
String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 11} );Updating a row into the table
String SQL = "update Student set name = ? where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{"Zara", 10} );Deleting a row from the table
String SQL = "delete Student where id = ?";
jdbcTemplateObject.update( SQL, new Object[]{20} );डीडीएल विवरणों को निष्पादित करना
आप उपयोग कर सकते हैं execute(..)किसी भी SQL स्टेटमेंट या DDL स्टेटमेंट को निष्पादित करने के लिए jdbcTemplate से विधि । तालिका बनाने के लिए क्रिएट स्टेटमेंट का उपयोग करने के लिए एक उदाहरण है -
String SQL = "CREATE TABLE Student( " +
"ID INT NOT NULL AUTO_INCREMENT, " +
"NAME VARCHAR(20) NOT NULL, " +
"AGE INT NOT NULL, " +
"PRIMARY KEY (ID));"
jdbcTemplateObject.execute( SQL );स्प्रिंग JDBC फ्रेमवर्क उदाहरण
उपरोक्त अवधारणाओं के आधार पर, आइए कुछ महत्वपूर्ण उदाहरणों की जाँच करें जो आपको स्प्रिंग में JDBC ढांचे के उपयोग को समझने में मदद करेंगे -
| अनु क्रमांक। | उदाहरण और विवरण |
|---|---|
| 1 | स्प्रिंग JDBC उदाहरण यह उदाहरण बताएगा कि कैसे एक सरल JDBC- आधारित स्प्रिंग एप्लिकेशन लिखना है। |
| 2 | वसंत में एसक्यूएल संग्रहित प्रक्रिया जानें कि स्प्रिंग में JDBC का उपयोग करते समय SQL संग्रहीत प्रक्रिया को कैसे कॉल करें। |
एक डेटाबेस लेन-देन क्रियाओं का एक क्रम है जो एक एकल इकाई के रूप में माना जाता है। इन क्रियाओं को या तो पूरी तरह से पूरा करना चाहिए या कोई भी प्रभाव नहीं लेना चाहिए। डेटा अखंडता और स्थिरता सुनिश्चित करने के लिए लेनदेन प्रबंधन RDBMS- उन्मुख उद्यम अनुप्रयोग का एक महत्वपूर्ण हिस्सा है। लेनदेन की अवधारणा को निम्नलिखित चार प्रमुख गुणों के साथ वर्णित किया जा सकता हैACID -
Atomicity - एक लेनदेन को ऑपरेशन की एकल इकाई के रूप में माना जाना चाहिए, जिसका अर्थ है कि या तो संचालन का पूरा अनुक्रम सफल या असफल है।
Consistency - यह डेटाबेस की संदर्भित अखंडता, तालिकाओं में अद्वितीय प्राथमिक कुंजियों, आदि की स्थिरता का प्रतिनिधित्व करता है।
Isolation- एक ही समय में एक ही डेटा सेट के साथ कई लेनदेन प्रसंस्करण हो सकते हैं। प्रत्येक लेनदेन को डेटा भ्रष्टाचार को रोकने के लिए दूसरों से अलग किया जाना चाहिए।
Durability - एक बार जब कोई लेन-देन पूरा हो जाता है, तो इस लेनदेन के परिणामों को स्थायी किया जाना चाहिए और सिस्टम की विफलता के कारण डेटाबेस से मिटाया नहीं जा सकता है।
एक वास्तविक RDBMS डेटाबेस सिस्टम प्रत्येक लेनदेन के लिए सभी चार गुणों की गारंटी देगा। SQL का उपयोग कर डेटाबेस को जारी किए गए लेनदेन का सरलीकृत दृश्य इस प्रकार है -
ट्रांजेक्शन कमांड का उपयोग करके लेनदेन शुरू करें ।
SQL क्वेरी का उपयोग करके विभिन्न हटाए गए, अपडेट या सम्मिलित ऑपरेशन करें।
यदि सभी ऑपरेशन सफल होते हैं तो कमिट करें अन्यथा सभी ऑपरेशन रोलबैक करें।
स्प्रिंग फ्रेमवर्क विभिन्न अंतर्निहित लेनदेन प्रबंधन एपीआई के शीर्ष पर एक सार परत प्रदान करता है। स्प्रिंग के लेन-देन समर्थन का उद्देश्य POJOs में लेनदेन क्षमताओं को जोड़कर EJB लेनदेन का एक विकल्प प्रदान करना है। स्प्रिंग प्रोग्रामेटिक और डिक्लेक्टिव ट्रांजैक्शन मैनेजमेंट दोनों का समर्थन करता है। ईजेबी को एक एप्लिकेशन सर्वर की आवश्यकता होती है, लेकिन स्प्रिंग लेनदेन प्रबंधन को एप्लिकेशन सर्वर की आवश्यकता के बिना लागू किया जा सकता है।
स्थानीय बनाम वैश्विक लेनदेन
स्थानीय लेनदेन JDBC कनेक्शन जैसे एकल लेन-देन संसाधन के लिए विशिष्ट होते हैं, जबकि वैश्विक लेनदेन एक वितरण प्रणाली में लेन-देन जैसे कई लेनदेन लेनदेन कर सकते हैं।
स्थानीय लेनदेन प्रबंधन एक केंद्रीकृत कंप्यूटिंग वातावरण में उपयोगी हो सकता है जहां आवेदन घटक और संसाधन एक ही साइट पर स्थित होते हैं, और लेनदेन प्रबंधन में केवल एक मशीन पर चलने वाला स्थानीय डेटा प्रबंधक शामिल होता है। स्थानीय लेनदेन को लागू करना आसान है।
एक वितरित कंप्यूटिंग वातावरण में वैश्विक लेनदेन प्रबंधन की आवश्यकता होती है जहां सभी संसाधनों को कई प्रणालियों में वितरित किया जाता है। ऐसे में लेन-देन प्रबंधन स्थानीय और वैश्विक दोनों स्तरों पर किए जाने की जरूरत है। एक वितरित या एक वैश्विक लेनदेन को कई प्रणालियों में निष्पादित किया जाता है, और इसके निष्पादन के लिए वैश्विक लेनदेन प्रबंधन प्रणाली और सभी शामिल प्रणालियों के सभी स्थानीय डेटा प्रबंधकों के बीच समन्वय की आवश्यकता होती है।
प्रोग्रामेटिक बनाम डिक्लेरेटिव
स्प्रिंग दो प्रकार के लेनदेन प्रबंधन का समर्थन करता है -
प्रोग्राममैटिक ट्रांजैक्शन मैनेजमेंट - इसका मतलब है कि आपको प्रोग्रामिंग की मदद से ट्रांजैक्शन को मैनेज करना है। यह आपको अत्यधिक लचीलापन देता है, लेकिन इसे बनाए रखना मुश्किल है।
डिक्लरेटिव ट्रांजैक्शन मैनेजमेंट - इसका मतलब है कि आप बिजनेस कोड से ट्रांजैक्शन मैनेजमेंट अलग कर सकते हैं। आप लेनदेन का प्रबंधन करने के लिए केवल एनोटेशन या XML- आधारित कॉन्फ़िगरेशन का उपयोग करते हैं।
डिक्लेरेटिव ट्रांजैक्शन मैनेजमेंट प्रोग्रामेटिक ट्रांजैक्शन मैनेजमेंट पर बेहतर होता है, हालांकि यह प्रोग्रामेटिक ट्रांजैक्शन मैनेजमेंट की तुलना में कम लचीला होता है, जो आपको अपने कोड के जरिए लेनदेन को नियंत्रित करने की अनुमति देता है। लेकिन एक प्रकार के क्रॉसकटिंग चिंता के रूप में, घोषणात्मक लेनदेन प्रबंधन को एओपी दृष्टिकोण के साथ संशोधित किया जा सकता है। स्प्रिंग एओपी ढांचे के माध्यम से घोषणात्मक लेनदेन प्रबंधन का समर्थन करता है।
स्प्रिंग लेन-देन का सार
स्प्रिंग लेन-देन अमूर्त की कुंजी को org.springframework.transaction.PlatformTransactionManager इंटरफ़ेस द्वारा परिभाषित किया गया है, जो इस प्रकार है -
public interface PlatformTransactionManager {
TransactionStatus getTransaction(TransactionDefinition definition);
throws TransactionException;
void commit(TransactionStatus status) throws TransactionException;
void rollback(TransactionStatus status) throws TransactionException;
}| अनु क्रमांक | विधि और विवरण |
|---|---|
| 1 | TransactionStatus getTransaction(TransactionDefinition definition) यह विधि निर्दिष्ट प्रचार व्यवहार के अनुसार वर्तमान में सक्रिय लेनदेन लौटाती है या एक नया बनाती है। |
| 2 | void commit(TransactionStatus status) यह पद्धति दी गई लेन-देन को उसकी स्थिति के संबंध में बताती है। |
| 3 | void rollback(TransactionStatus status) यह विधि दिए गए लेन-देन का रोलबैक करती है। |
TransactionDefinition वसंत में लेन-देन समर्थन के मूल स्वरूप है और इस प्रकार यह परिभाषित किया गया है -
public interface TransactionDefinition {
int getPropagationBehavior();
int getIsolationLevel();
String getName();
int getTimeout();
boolean isReadOnly();
}| अनु क्रमांक | विधि और विवरण |
|---|---|
| 1 | int getPropagationBehavior() यह विधि प्रचार व्यवहार लौटाती है। स्प्रिंग ईजेबी सीएमटी से परिचित सभी लेनदेन प्रचार विकल्प प्रदान करता है। |
| 2 | int getIsolationLevel() यह विधि उस डिग्री को लौटाती है जिससे यह लेनदेन अन्य लेनदेन के काम से अलग हो जाता है। |
| 3 | String getName() यह विधि इस लेनदेन का नाम लौटाती है। |
| 4 | int getTimeout() यह विधि सेकंड में उस समय को वापस करती है जिसमें लेनदेन पूरा होना चाहिए। |
| 5 | boolean isReadOnly() यह विधि लौटाती है कि क्या लेन-देन केवल पढ़ने के लिए है। |
अलगाव स्तर के लिए संभावित मूल्य निम्नलिखित हैं -
| अनु क्रमांक | अलगाव और विवरण |
|---|---|
| 1 | TransactionDefinition.ISOLATION_DEFAULT यह डिफ़ॉल्ट आइसोलेशन स्तर है। |
| 2 | TransactionDefinition.ISOLATION_READ_COMMITTED इंगित करता है कि गंदे रीड को रोका जाता है; गैर-दोहराने योग्य रीड और प्रेत रीडिंग हो सकती हैं। |
| 3 | TransactionDefinition.ISOLATION_READ_UNCOMMITTED इंगित करता है कि गंदे पढ़ता है, गैर-दोहराने योग्य पढ़ता है, और प्रेत रीड पढ़ सकता है। |
| 4 | TransactionDefinition.ISOLATION_REPEATABLE_READ इंगित करता है कि गंदे पढ़ता है और गैर-दोहराने योग्य रीड को रोका जाता है; प्रेत रीडिंग हो सकती है। |
| 5 | TransactionDefinition.ISOLATION_SERIALIZABLE इंगित करता है कि गंदे पढ़ता है, गैर-दोहराने योग्य पढ़ता है, और प्रेत रीड को रोका जाता है। |
प्रसार प्रकारों के लिए संभावित मूल्य निम्नलिखित हैं -
| अनु क्रमांक। | प्रचार और विवरण |
|---|---|
| 1 | TransactionDefinition.PROPAGATION_MANDATORY एक वर्तमान लेनदेन का समर्थन करता है; यदि कोई वर्तमान लेनदेन मौजूद नहीं है, तो एक अपवाद को फेंकता है। |
| 2 | TransactionDefinition.PROPAGATION_NESTED यदि वर्तमान लेनदेन मौजूद है, तो एक नेस्टेड लेनदेन के भीतर निष्पादित। |
| 3 | TransactionDefinition.PROPAGATION_NEVER वर्तमान लेनदेन का समर्थन नहीं करता है; वर्तमान लेनदेन मौजूद है, तो एक अपवाद फेंकता है। |
| 4 | TransactionDefinition.PROPAGATION_NOT_SUPPORTED वर्तमान लेनदेन का समर्थन नहीं करता है; बल्कि हमेशा nontransactically निष्पादित करें। |
| 5 | TransactionDefinition.PROPAGATION_REQUIRED एक वर्तमान लेनदेन का समर्थन करता है; यदि कोई मौजूद नहीं है तो एक नया निर्माण करता है। |
| 6 | TransactionDefinition.PROPAGATION_REQUIRES_NEW यदि कोई मौजूद है, तो वर्तमान लेनदेन को स्थगित करते हुए एक नया लेनदेन बनाता है। |
| 7 | TransactionDefinition.PROPAGATION_SUPPORTS एक वर्तमान लेनदेन का समर्थन करता है; यदि कोई मौजूद नहीं है, तो गैर-लेन-देन निष्पादित करता है। |
| 8 | TransactionDefinition.TIMEOUT_DEFAULT अंतर्निहित लेनदेन प्रणाली के डिफ़ॉल्ट टाइमआउट का उपयोग करता है, या यदि टाइमआउट समर्थित नहीं हैं, तो कोई भी नहीं। |
TransactionStatus इंटरफेस नियंत्रण लेनदेन निष्पादन और क्वेरी लेन-देन की स्थिति के व्यवहार कोड के लिए एक आसान तरीका प्रदान करता है।
public interface TransactionStatus extends SavepointManager {
boolean isNewTransaction();
boolean hasSavepoint();
void setRollbackOnly();
boolean isRollbackOnly();
boolean isCompleted();
}| अनु क्रमांक। | विधि और विवरण |
|---|---|
| 1 | boolean hasSavepoint() यह विधि लौटाती है कि क्या यह लेन-देन आंतरिक रूप से एक बचत बिंदु को वहन करता है, अर्थात, एक बचत के आधार पर नेस्टेड लेनदेन के रूप में बनाया गया है। |
| 2 | boolean isCompleted() यह विधि लौटाती है कि क्या यह लेन-देन पूरा हुआ है, अर्थात, चाहे वह पहले से ही प्रतिबद्ध हो या लुढ़का हो। |
| 3 | boolean isNewTransaction() वर्तमान लेनदेन नया होने की स्थिति में यह तरीका सही है। |
| 4 | boolean isRollbackOnly() यह विधि लौटाती है कि क्या लेन-देन केवल रोलबैक के रूप में चिह्नित किया गया है। |
| 5 | void setRollbackOnly() यह विधि लेन-देन को केवल रोलबैक के रूप में सेट करती है। |
स्प्रिंग वेब एमवीसी ढांचा मॉडल-व्यू-कंट्रोलर (एमवीसी) आर्किटेक्चर और तैयार घटकों को प्रदान करता है, जिनका उपयोग लचीला और शिथिल युग्मित वेब अनुप्रयोगों को विकसित करने के लिए किया जा सकता है। MVC पैटर्न इन तत्वों के बीच एक ढीली युग्मन प्रदान करते हुए आवेदन के विभिन्न पहलुओं (इनपुट लॉजिक, बिजनेस लॉजिक और UI लॉजिक) को अलग करता है।
Model एप्लिकेशन डेटा को एनकैप्सुलेट करता है और सामान्य तौर पर वे POJO से मिलकर बनते हैं।
View मॉडल डेटा रेंडर करने के लिए जिम्मेदार है और सामान्य तौर पर यह HTML आउटपुट उत्पन्न करता है जो क्लाइंट के ब्राउज़र की व्याख्या कर सकता है।
Controller उपयोगकर्ता के अनुरोधों को संसाधित करने और एक उपयुक्त मॉडल बनाने के लिए जिम्मेदार है और इसे प्रतिपादन के लिए दृश्य में भेजता है।
डिस्पैचरसर्वलेट
स्प्रिंग वेब मॉडल-व्यू-कंट्रोलर (MVC) फ्रेमवर्क एक डिस्पैचरसर्वलेट के आसपास डिज़ाइन किया गया है जो सभी HTTP अनुरोधों और प्रतिक्रियाओं को संभालता है। स्प्रिंग वेब एमवीसी डिस्पैचर सेलेट का अनुरोध प्रसंस्करण वर्कफ़्लो निम्नलिखित चित्र में चित्रित किया गया है -
DispatcherServlet पर आने वाले HTTP अनुरोध के अनुरूप घटनाओं का क्रम निम्नलिखित है -
HTTP अनुरोध प्राप्त करने के बाद, DispatcherServlet उपयुक्त नियंत्रक को कॉल करने के लिए हैंडलर मैपिंग को सलाह देता है ।
नियंत्रक अनुरोध लेता है और इस्तेमाल किया GET या POST पद्धति के आधार पर उपयुक्त सेवा तरीकों कहता है। सेवा पद्धति निर्धारित डेटा लॉजिक के आधार पर मॉडल डेटा सेट करेगी और डिस्पैसरसर्वलेट को दृश्य नाम लौटाएगी ।
DispatcherServlet से मदद ले जाएगा ViewResolver अनुरोध के लिए निर्धारित दृश्य पिक करने के लिए।
एक बार जब दृश्य को अंतिम रूप दिया जाता है, तो डिस्पैचरसर्वलेट उस मॉडल डेटा को पास करता है, जो अंततः ब्राउज़र पर प्रदान किया जाता है।
सभी उपर्युक्त घटकों, यानी HandlerMapping, नियंत्रक, और ViewResolver के हिस्से हैं WebApplicationContext w जो सादा का ही विस्तार है ApplicationContext कुछ अतिरिक्त के साथ वेब अनुप्रयोगों के लिए आवश्यक सुविधा है।
आवश्यक कॉन्फ़िगरेशन
आपको URL मैपिंग का उपयोग करके डिस्पैचरसर्वलेट को हैंडल करने के लिए अनुरोध करने की आवश्यकता हैweb.xmlफ़ाइल। निम्नलिखित के लिए घोषणा और मानचित्रण दिखाने के लिए एक उदाहरण हैHelloWeb डिस्पैचर सेलेट उदाहरण -
<web-app id = "WebApp_ID" version = "2.4"
xmlns = "http://java.sun.com/xml/ns/j2ee"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
<display-name>Spring MVC Application</display-name>
<servlet>
<servlet-name>HelloWeb</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>HelloWeb</servlet-name>
<url-pattern>*.jsp</url-pattern>
</servlet-mapping>
</web-app>web.xmlफ़ाइल को आपके वेब एप्लिकेशन के WebContent / WEB-INF निर्देशिका में रखा जाएगा। के आरंभ होने परHelloWeb DispatcherServlet, रूपरेखा नाम की फ़ाइल से एप्लिकेशन संदर्भ को लोड करने का प्रयास करेगी [servlet-name]-servlet.xmlअनुप्रयोग के WebContent / WEB-INFdirectory में स्थित है। इस मामले में, हमारी फाइल होगीHelloWebservlet.xml।
अगला, <सर्वलेट-मैपिंग> टैग इंगित करता है कि URL को किस डिस्पैचरवेरलेट द्वारा संभाला जाएगा। यहां सभी HTTP अनुरोध समाप्त हो रहे हैं.jsp द्वारा नियंत्रित किया जाएगा HelloWeb DispatcherServlet।
आप के रूप में डिफ़ॉल्ट फ़ाइल नाम के साथ जाने के लिए नहीं करना चाहते हैं [सर्वलेट-नाम] -servlet.xml के रूप में और डिफ़ॉल्ट स्थान WebContent / वेब-INF , आप श्रोता सर्वलेट जोड़कर इस फ़ाइल नाम और स्थान को अनुकूलित कर सकते ContextLoaderListener अपने web.xml फ़ाइल में निम्नानुसार है -
<web-app...>
<!-------- DispatcherServlet definition goes here----->
....
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/HelloWeb-servlet.xml</param-value>
</context-param>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
</web-app>अब, हम के लिए आवश्यक विन्यास की जाँच करें HelloWeb-servlet.xmlफ़ाइल, आपके वेब एप्लिकेशन के वेबकंटेंट / वेब-इन- डायरेक्टरी में रखी गई -
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:context = "http://www.springframework.org/schema/context"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package = "com.tutorialspoint" />
<bean class = "org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name = "prefix" value = "/WEB-INF/jsp/" />
<property name = "suffix" value = ".jsp" />
</bean>
</beans>निम्नलिखित महत्वपूर्ण बिंदु हैं HelloWeb-servlet.xml फ़ाइल -
[सर्वलेट-नाम] -servlet.xml फ़ाइल वैश्विक क्षेत्र में एक ही नाम के साथ परिभाषित किसी भी सेम की परिभाषा अधिभावी, सेम परिभाषित बनाने के लिए इस्तेमाल किया जाएगा।
<संदर्भ: घटक स्कैन ...> टैग को सक्रिय वसंत MVC एनोटेशन स्कैनिंग क्षमता जो @Controller और @RequestMapping आदि जैसे एनोटेशन का उपयोग करने के लिए अनुमति देता है के लिए उपयोग किया जाएगा
InternalResourceViewResolver दृश्य नामों को हल करने परिभाषित नियमों होगा। उपर्युक्त परिभाषित नियम के अनुसार, एक तार्किक दृष्टिकोण जिसका नाम हैhello/WEB-INF/jsp/hello.jsp पर स्थित दृश्य कार्यान्वयन के लिए प्रत्यायोजित किया जाता है ।
निम्न अनुभाग आपको दिखाएगा कि आपके वास्तविक घटक, अर्थात, नियंत्रक, मॉडल और दृश्य कैसे बनाएं।
एक नियंत्रक को परिभाषित करना
DispatcherServlet नियंत्रकों को अनुरोध करता है कि वे इसके लिए कार्यशीलता को निष्पादित करें। @Controllerएनोटेशन इंगित करता है कि एक विशेष वर्ग एक नियंत्रक की भूमिका निभाता है। @RequestMapping एनोटेशन का उपयोग URL को पूरी कक्षा या किसी विशेष हैंडलर विधि के लिए मैप करने के लिए किया जाता है।
@Controller
@RequestMapping("/hello")
public class HelloController {
@RequestMapping(method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}@Controllerएनोटेशन एक वर्ग MVC नियंत्रक के रूप में परिभाषित करता है। यहाँ, का पहला उपयोग@RequestMapping इंगित करता है कि इस नियंत्रक पर सभी हैंडलिंग विधियों के सापेक्ष हैं /helloपथ। अगला एनोटेशन@RequestMapping(method = RequestMethod.GET)HTTP GET अनुरोध को संभालने के लिए नियंत्रक की डिफ़ॉल्ट सेवा विधि के रूप में aprintHello () विधि को घोषित करने के लिए उपयोग किया जाता है। आप एक ही URL पर किसी भी POST अनुरोध को संभालने के लिए दूसरी विधि को परिभाषित कर सकते हैं।
आप उपरोक्त नियंत्रक को दूसरे रूप में लिख सकते हैं जहाँ आप @RequestMapping में अतिरिक्त विशेषताएँ जोड़ सकते हैं -
@Controller
public class HelloController {
@RequestMapping(value = "/hello", method = RequestMethod.GET)
public String printHello(ModelMap model) {
model.addAttribute("message", "Hello Spring MVC Framework!");
return "hello";
}
}value विशेषता उस URL को इंगित करती है जिससे हैंडलर विधि मैप की गई है और methodविशेषता HTTP GET अनुरोध को संभालने के लिए सेवा पद्धति को परिभाषित करता है। ऊपर दिए गए नियंत्रक के बारे में निम्नलिखित महत्वपूर्ण बिंदुओं पर ध्यान दिया जाना चाहिए -
आप एक सेवा पद्धति के अंदर आवश्यक व्यावसायिक तर्क को परिभाषित करेंगे। आप आवश्यकता के अनुसार इस विधि के अंदर एक और विधि कह सकते हैं।
परिभाषित व्यावसायिक तर्क के आधार पर, आप इस पद्धति के भीतर एक मॉडल बनाएंगे। आप सेटर के विभिन्न मॉडल विशेषताओं का उपयोग कर सकते हैं और अंतिम परिणाम प्रस्तुत करने के लिए इन विशेषताओं का उपयोग किया जाएगा। यह उदाहरण इसकी विशेषता "संदेश" के साथ एक मॉडल बनाता है।
एक परिभाषित सेवा पद्धति एक स्ट्रिंग लौटा सकती है, जिसमें का नाम शामिल है viewमॉडल प्रस्तुत करने के लिए इस्तेमाल किया जाएगा। यह उदाहरण तार्किक दृश्य नाम के रूप में "हैलो" देता है।
JSP व्यूज बनाना
स्प्रिंग एमवीसी विभिन्न प्रस्तुति प्रौद्योगिकियों के लिए कई प्रकार के विचारों का समर्थन करता है। इनमें शामिल हैं - जेएसपी, एचटीएमएल, पीडीएफ, एक्सेल वर्कशीट, एक्सएमएल, वेलोसिटी टेम्प्लेट, एक्सएसएलटी, जेएसएन, एटम और आरएसएस फीड, जैस्परपरपोर्ट्स आदि। लेकिन ज्यादातर हम जेएसटीएल के साथ लिखे गए जेएसपी टेम्प्लेट का उपयोग करते हैं।
हमें एक सरल लिखना है hello /WEB-INF/hello/hello.jsp में देखें -
<html>
<head>
<title>Hello Spring MVC</title>
</head>
<body>
<h2>${message}</h2>
</body>
</html>यहाँ ${message}वह विशेषता है जो हमने नियंत्रक के अंदर स्थापित की है। आपके पास अपने दृश्य के अंदर प्रदर्शित करने के लिए कई गुण हो सकते हैं।
स्प्रिंग वेब एमवीसी फ्रेमवर्क उदाहरण
उपरोक्त अवधारणाओं के आधार पर, आइए हम कुछ महत्वपूर्ण उदाहरणों की जांच करें जो आपको अपने स्प्रिंग वेब एप्लिकेशन बनाने में मदद करेंगे -
| अनु क्रमांक। | उदाहरण और विवरण |
|---|---|
| 1 | स्प्रिंग एमवीसी हैलो वर्ल्ड उदाहरण यह उदाहरण बताएगा कि एक सरल स्प्रिंग वेब हैलो वर्ल्ड एप्लिकेशन कैसे लिखना है। |
| 2 | स्प्रिंग एमवीसी फॉर्म हैंडलिंग उदाहरण यह उदाहरण समझाएगा कि नियंत्रक को डेटा जमा करने और संसाधित परिणाम प्रदर्शित करने के लिए HTML रूपों का उपयोग करके स्प्रिंग वेब एप्लिकेशन कैसे लिखना है। |
| 3 | स्प्रिंग पेज पुनर्निर्देशन उदाहरण स्प्रिंग MVC फ्रेमवर्क में पेज पुनर्निर्देशन कार्यक्षमता का उपयोग करना सीखें। |
| 4 | स्प्रिंग स्टेटिक पेज उदाहरण स्प्रिंग एमवीसी फ्रेमवर्क में डायनेमिक पेजों के साथ-साथ स्टैटिक पेजों तक पहुंचने का तरीका जानें। |
| 5 | स्प्रिंग एक्सेप्शन हैंडलिंग उदाहरण स्प्रिंग एमवीसी फ्रेमवर्क में अपवादों को संभालना सीखें। |
यह स्प्रिंग एप्लिकेशन के अंदर एक बहुत ही आसान उपयोग लॉग 4 जे कार्यक्षमता है। निम्नलिखित उदाहरण आपको Log4J और स्प्रिंग के बीच सरल एकीकरण की व्याख्या करने के लिए सरल चरणों के माध्यम से ले जाएगा।
हम आपको पहले से ही मान लेते हैं log4Jआपकी मशीन पर स्थापित है। अगर आपके पास नहीं है तो आप इससे डाउनलोड कर सकते हैंhttps://logging.apache.org/और बस किसी भी फ़ोल्डर में ज़िपित फ़ाइल निकालें। हम ही उपयोग करेंगेlog4j-x.y.z.jar हमारे प्रोजेक्ट में।
इसके बाद, हमारे पास कार्यशील ग्रहण आईडीई है और डायनेमिक फॉर्म-आधारित वेब एप्लिकेशन विकसित करने के लिए निम्नलिखित कदम उठाएं।
| कदम | विवरण |
|---|---|
| 1 | SpringExample नाम से एक प्रोजेक्ट बनाएं और के तहत एक पैकेज com.tutorialspoint बनाएंsrc बनाया परियोजना में फ़ोल्डर। |
| 2 | स्प्रिंग हैलो वर्ल्ड उदाहरण चैप्टर में बताए अनुसार एक्सटर्नल JARs विकल्प का उपयोग करके आवश्यक स्प्रिंग लाइब्रेरी जोड़ें । |
| 3 | Add बाह्य JAR का उपयोग करके अपने प्रोजेक्ट में log4j लाइब्रेरी log4j-xyzjar जोड़ें । |
| 4 | Com.tutorialspoint पैकेज के तहत Java कक्षाएं HelloWorld और MainApp बनाएं । |
| 5 | के तहत बीन्स कॉन्फ़िगरेशन फ़ाइल Beans.xml बनाएँsrc फ़ोल्डर। |
| 6 | के तहत log4J विन्यास फाइल log4j.properties बनाएँsrc फ़ोल्डर। |
| 7 | अंतिम चरण सभी जावा फ़ाइलों और बीन कॉन्फ़िगरेशन फ़ाइल की सामग्री बनाना और नीचे बताए अनुसार आवेदन चलाना है। |
यहाँ की सामग्री है HelloWorld.java फ़ाइल
package com.tutorialspoint;
public class HelloWorld {
private String message;
public void setMessage(String message){
this.message = message;
}
public void getMessage() {
System.out.println("Your Message : " + message);
}
}निम्नलिखित दूसरी फ़ाइल की सामग्री है MainApp.java
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.log4j.Logger;
public class MainApp {
static Logger log = Logger.getLogger(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}आप उत्पन्न कर सकते हैं debug तथा errorसंदेश उसी तरह से जैसे हमने सूचना संदेश उत्पन्न किया है। अब हम सामग्री देखते हैंBeans.xml फ़ाइल
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
<bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld">
<property name = "message" value = "Hello World!"/>
</bean>
</beans>निम्नलिखित की सामग्री है log4j.properties जो लॉग संदेश का उत्पादन करने के लिए Log4J के लिए आवश्यक मानक नियमों को परिभाषित करता है
# Define the root logger with appender file
log4j.rootLogger = DEBUG, FILE
# Define the file appender
log4j.appender.FILE=org.apache.log4j.FileAppender
# Set the name of the file
log4j.appender.FILE.File=C:\\log.out
# Set the immediate flush to true (default)
log4j.appender.FILE.ImmediateFlush=true
# Set the threshold to debug mode
log4j.appender.FILE.Threshold=debug
# Set the append to false, overwrite
log4j.appender.FILE.Append=false
# Define the layout for file appender
log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
log4j.appender.FILE.layout.conversionPattern=%m%nएक बार जब आप स्रोत और बीन विन्यास फाइल बनाने के साथ हो जाते हैं, तो हम एप्लिकेशन चलाते हैं। यदि आपके आवेदन में सब कुछ ठीक है, तो यह निम्नलिखित संदेश को ग्रहण कंसोल में प्रिंट करेगा -
Your Message : Hello World!यदि आप अपनी C: \\ ड्राइव की जांच करते हैं, तो आपको अपनी लॉग फ़ाइल ढूंढनी चाहिए log.out विभिन्न लॉग संदेशों के साथ, जैसे कुछ इस प्रकार है -
<!-- initialization log messages -->
Going to create HelloWord Obj
Returning cached instance of singleton bean 'helloWorld'
Exiting the programजकार्ता कॉमन्स लॉगिंग (JCL) एपीआई
वैकल्पिक रूप से आप उपयोग कर सकते हैं Jakarta Commons Logging (JCL)एपीआई अपने वसंत आवेदन में एक लॉग उत्पन्न करने के लिए। JCL से डाउनलोड किया जा सकता हैhttps://jakarta.apache.org/commons/logging/। इस पैकेज से तकनीकी रूप से हमें जो एकमात्र फ़ाइल चाहिए, वह है कॉमन्स-लॉगिंग-xyzjar फ़ाइल, जिसे आपके क्लासपाथ में उसी तरह से रखा जाना चाहिए, जैसा आपने उपरोक्त उदाहरण में log4j-xyzjar डाला था ।
लॉगिंग कार्यक्षमता का उपयोग करने के लिए आपको org.apache.commons.log.Log ऑब्जेक्ट की आवश्यकता होती है और फिर आप अपने अनुरोध के अनुसार निम्न विधियों में से एक को कॉल कर सकते हैं -
- घातक (वस्तु संदेश)
- त्रुटि (वस्तु संदेश)
- चेतावनी (वस्तु संदेश)
- जानकारी (वस्तु संदेश)
- डीबग (ऑब्जेक्ट संदेश)
- ट्रेस (वस्तु संदेश)
निम्नलिखित MainApp.java का प्रतिस्थापन है, जो JCL API का उपयोग करता है
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.apache.commons.logging. Log;
import org.apache.commons.logging. LogFactory;
public class MainApp {
static Log log = LogFactory.getLog(MainApp.class.getName());
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
log.info("Going to create HelloWord Obj");
HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
obj.getMessage();
log.info("Exiting the program");
}
}आपको यह सुनिश्चित करना होगा कि आपने अपने प्रोजेक्ट में कॉमन्स-लॉगिंग-xyzjar फ़ाइल को शामिल किया है, कार्यक्रम को संकलित करने और चलाने से पहले।
अब उपरोक्त उदाहरण में शेष कॉन्फ़िगरेशन और सामग्री को अपरिवर्तित रखते हुए, यदि आप अपने एप्लिकेशन को संकलित करते हैं और चलाते हैं, तो आपको वैसा ही परिणाम मिलेगा जैसा कि आपको Log4J API का उपयोग करके मिला है।