JBoss फ्यूज - त्वरित गाइड

इस अध्याय में, हम एंटरप्राइज सर्विस बस की अनिवार्यता के साथ शुरुआत करेंगे। नीचे दिए गए ईएसबी के बारे में विस्तृत विवरण के साथ-साथ इसके फायदे, नुकसान और आसान समझ के लिए कुछ आरेख हैं।

ईएसबी क्या है?

ESB का मतलब एंटरप्राइज सर्विस बस है। ईएसबी अपने सरलतम रूप में एक मिडलवेयर है जो संचार के लिए कई अनुप्रयोगों के लिए सूचना राजमार्ग के रूप में कार्य करता है।

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

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

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

एकीकरण समस्या

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

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

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

ईएसबी क्यों?

निम्नलिखित कुछ बिंदु हैं जो बताते हैं कि एंटरप्राइज सर्विस बस क्यों आवश्यक है।

• ESB का उद्देश्य विभिन्न संगत अनुप्रयोगों के साथ एकीकरण की समस्या को आसान बनाना है।

• यह एक मिडलवेयर के रूप में कार्य करता है, जो आपके सभी अनुप्रयोगों के मध्यस्थ के रूप में कार्य करता है और उनके बीच संदेश मार्ग की सुविधा प्रदान करता है।

• हर एप्लिकेशन को सीधे हर दूसरे एप्लिकेशन के साथ इंटरफेस करने के बजाय, अब प्रत्येक एप्लिकेशन के पास ESB का केवल एक इंटरफेस है।

• ESB संदेशों को एक सामान्य प्रारूप से / में अनुवाद करने और उन्हें उनके गंतव्य तक पहुंचाने के लिए जिम्मेदार है।

• इस दृष्टिकोण में प्रमुख बचत एक वरदान के रूप में आती है यदि आपको अपने किसी भी मौजूदा एप्लिकेशन को बदलना है। नए इंटरफेस की एक पूरी गुच्छा लिखने के बजाय, अब आपके पास केवल एक इंटरफ़ेस है जो आपके संबंध में (आपके आवेदन और ईएसबी के बीच) चिंतित है।

SOA और ESB

एसओए और ईएसबी का आमतौर पर एक दूसरे के साथ इस्तेमाल किया जाता है, लेकिन वे पूरी तरह से अलग हैं।

SOA एक डिज़ाइन पैटर्न है जो एप्लिकेशन को संचार प्रोटोकॉल के माध्यम से नेटवर्क पर एक सेवा के रूप में अपनी कार्यक्षमता को उजागर करने की अनुमति देता है, जबकि ESB एक मॉडल है जो असमान प्रणालियों के बीच संचार की सुविधा देता है, लेकिन SOA को लागू करते समय ESB को रीढ़ के रूप में उपयोग किया जा सकता है।

जेबॉस फ्यूज रेडहैट द्वारा एक ओपन सोर्स ईएसबी समाधान है। यह सामुदायिक परियोजना, अपाचे सर्विसेमिक्स पर आधारित एक उद्यम समाधान है।

फ्यूज का एकीकरण

JBoss फ्यूज एक हल्का और लचीला एकीकरण मंच है जो उद्यम अनुप्रयोगों के तेजी से एकीकरण की अनुमति देता है।

फ्यूज को शुरू में प्रगतिशील सॉफ्टवेयर इंक द्वारा विकसित किया गया था जिसे 2012 में रेडहैट द्वारा अधिग्रहित किया गया था। JBoss Fuse 6.1.0.redhat-379 GA फ्यूज का एक स्थिर संस्करण है जिसे उनकी आधिकारिक वेबसाइट से डाउनलोड किया जा सकता है।

आर्किटेक्चर

फ्यूज एक ही उत्पाद के रूप में विभिन्न तकनीकों को एक साथ जोड़ती है।

अवयव

अपाचे CXF

Apache CXF एक ओपन सोर्स वेब सर्विसेज डेवलपमेंट फ्रेमवर्क है जो SOAP और रेस्ट वेब सेवाओं के विकास का समर्थन करता है।

अपाचे ऊंट

Apache ऊंट एक EIP आधारित एकीकरण ढांचा है। ईआईपी या एंटरप्राइज इंटीग्रेशन पैटर्न एंटरप्राइज़ इंटीग्रेशन में आवर्ती समस्याओं के समाधान की पहचान करते हैं। पूर्ण एकीकरण समाधान बॉक्स पैटर्न के इन पूर्व-परिभाषित आउट के संयोजन के साथ मौसम के अनुसार प्राप्त किया जा सकता है।

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

Apache AMQ

Apache AMQ एक JMS है जो JMS मानकों के अनुसार विश्वसनीय संदेश प्रणाली प्रदान करता है। यह न केवल जेएमएस विनिर्देश का समर्थन करता है, बल्कि कुछ रोमांचक और उपयोगी सुविधाएँ भी प्रदान करता है जो जेएमएस विनिर्देशों में शामिल नहीं हैं।

अपाचे करफ

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

कपड़ा

फैब्रिक एक बड़े और वितरित वातावरण में कलाकृतियों की तैनाती का प्रबंधन करने का आसान तरीका प्रदान करता है। यह सभी कई फ्यूज उदाहरणों के लिए केंद्रीकृत प्रबंधन प्रदान करता है।

फ़्यूज़ स्थापित करना

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

फ़्यूज़ स्थापित करना चार चरणों वाली प्रक्रिया है -

डाउनलोड

निम्नलिखित लिंक से फ्यूज 6.1.0 जीए डाउनलोड करें। http://www.jboss.org/

खोलना

अन्य सभी JBoss उत्पादों की तरह, फ़्यूज़ भी एक प्लेटफ़ॉर्म स्वतंत्र ज़िप है।

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

Note - भले ही फ्यूज अनजिप हो जाए और दूसरे JBoss उत्पादों की तरह शुरू हो जाए, लेकिन इंस्टॉलेशन पूरा होने के बाद फ्यूज इंस्टॉलेशन को एक स्थान से दूसरे स्थान पर ले जाने की अनुशंसा नहीं की जाती है।

कॉन्फ़िगर

आपके द्वारा फ़्यूज़ को अनज़िप करने के बाद, आपको निकाली गई निर्देशिका के अंदर निम्नलिखित निर्देशिकाएँ मिलेंगी -

• bin
• etc
• deploy
• lib
• licenses
• extras
• quickstarts

जिनमें से हम केवल दो निर्देशिकाओं का उपयोग करने जा रहे हैं bin और etc।

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

पर्यावरण चर सेट करें

• निम्नलिखित पर्यावरण चर सेट करें - JAVA_HOME

• चर को जावा इंस्टॉलेशन डायरेक्टरी की ओर इंगित करना चाहिए - M2_HOME

• चर को Maven संस्थापन निर्देशिका को इंगित करना चाहिए - PATH

• जावा और मावेन निष्पादनयोग्य को शामिल करने के लिए पथ चर सेट करें।

खिड़कियाँ

खिड़कियों पर, सेटिंग्स नीचे दिए गए निर्देशों का पालन करके किया जा सकता है -

प्रारंभ → मेरा कंप्यूटर → राइट क्लिक → गुण → उन्नत सिस्टम सेटिंग्स → पर्यावरण चर।

यूनिक्स और क्लोन

प्रत्येक उपयोगकर्ता के लिए में एक bash प्रोफ़ाइल है *nixऑपरेटिंग सिस्टम। हम इस फ़ाइल को बदलकर मौजूदा सिस्टम वैरिएबल को जोड़ या संपादित कर सकते हैं।

$ vi ~/.bash_proflle

Note- इस फ़ाइल में कोई भी परिवर्तन स्थायी हैं। यह मूल बदलने से पहले मौजूदा फ़ाइल का बैकअप लेने के लिए अत्यधिक अनुशंसित है।

मूल विन्यास

हम JBoss फ्यूज के मूल विन्यास के बारे में चर्चा करेंगे और इसके लिए हमें निम्नलिखित कमांड के साथ शुरुआत करनी होगी Edit $FUSE_INSTALLATION_DIR/etc/

• में user.properties

  • #admin=admin,admin

  • इसे हम चाहते हैं कि उपयोगकर्ता नाम के साथ पहले व्यवस्थापक के अनुसार बदल दिया जाए, पासवर्ड के साथ दूसरा व्यवस्थापक, तीसरे को रखा जा सकता है क्योंकि यह एक भूमिका को इंगित करता है और # हटाना न भूलें

  • उदाहरण के लिए - FuseAdmin = FusePAss, व्यवस्थापक

  

  • में System.properties

    • karafName = जड़

      • यह उस नाम को इंगित करता है जिसे आप करफ उदाहरण देना चाहते हैं।

      • हम इसे कुछ भी नाम दे सकते हैं जिसे हम Cont1 की तरह चाहते हैं।

      • सुनिश्चित करें कि यह नाम जो आप दे रहे हैं वह अद्वितीय नाम है और पहले से ही फ्यूज के किसी अन्य उदाहरण द्वारा उपयोग नहीं किया जा रहा है।

  • में org.ops4j.pax.web.cfg

    • Org.osgi.service.http.port = 8181

    • यह गुण पोर्ट को इंगित करता है जिसका उपयोग फ्यूज द्वारा प्रदान किए गए ब्राउज़र-आधारित इंटरफ़ेस HAWTIO तक पहुंचने के लिए किया जाना है

    • HAWTIO फ्यूज के लिए एक इन-बिल्ट ब्राउज़र इंटरफ़ेस है जो 6.0 पर से उपलब्ध है

  • में org.ops4j.pax.url.mvn.cfg

    • org.ops4j.pax.url.mvn.localRepository = D: / भंडार

    • यह प्रॉपर्टी हमारे मावेन के स्थानीय रिपॉजिटरी के लिए रास्ता बताती है जहां से फ्यूज अपनी कलाकृतियों को स्थापित करेगा।

    • org.ops4j.pax.url.mvn.settings = D: /Maven/conf/settings.xml

    • यह संपत्ति सेटिंग्स को इंगित करती है। Mml से कलाकृतियों को प्राप्त करने के लिए फ्यूज का उपयोग करना चाहिए।

  मावेन का विन्यास

  फ़्यूज़ को स्थापित करने के लिए मावेन एक शर्त है। यदि आप नहीं जानते कि मावेन का संदर्भ क्या हैhttp://www.tutorialspoint.com/maven/

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

  $ FUSE_INSTALLATION_DIR / etc / संपादित करेंorg.ops4j.paxurl.mvn.cfg

  निम्नलिखित दो गुणों को अद्यतन करें -

  • org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
  • org.ops4j.pax.url.mvn.localRepository = $ local_repo

  Note - कृपया बदलें $local_repo Mavens settings.xml में उल्लिखित आपके स्थानीय भंडार के वास्तविक पथ के साथ।

  Daud

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

  फ्यूज शुरू करने के दो तरीके हैं -

  • का उपयोग करते हुए ./fuse

    • यह आपको उसी विंडो पर सभी प्रगति और लॉग देखने की अनुमति देगा जिसमें आपने फ्यूज शुरू किया था।

    • यह आपको करफ कंसोल को उसी टर्मिनल में देगा जैसा कि नीचे दिखाया गया है।

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

  • का उपयोग करते हुए ./start

    • यह स्क्रीन पर कोई लॉग नहीं दिखाएगा यहां तक ​​कि प्रगति भी नहीं, लेकिन यह बैकग्राउंड में फ्यूज शुरू कर देगा और जब उपयोगकर्ता सत्र से बाहर निकलेगा या टर्मिनल बंद करेगा तो फ्यूज सेवा बंद नहीं होगी।

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

    • यदि आप पृष्ठभूमि में चल रहे फ्यूज से कनेक्ट करना चाहते हैं, तो आप उपयोग कर सकते हैं client स्क्रिप्ट जो एक ही फ़ोल्डर में स्थित है।

    • आपको निम्न स्क्रीनशॉट में दिखाए अनुसार प्रदर्शन प्राप्त करना चाहिए।

    • क्लाइंट स्क्रिप्ट से बाहर निकलने से फ्यूज सेवा बंद नहीं होगी। यह फ्यूज कंसोल को बंद कर देगा।

  

  HAWTIO

  फ्यूज भी FMC (फ्यूज मैनेजमेंट कंसोल) का उपयोग करके इसे पूर्ण GUI एक्सेस प्रदान करता है। आप नीचे URL पर GUI पा सकते हैंhttp://localhost:8181।

  

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

  इस अध्याय में, हम अपाचे करफ के बारे में चर्चा करेंगे और इसे अपने लाभ और अन्य महत्वपूर्ण विशेषताओं के साथ एक हल्के OSGi कंटेनर के रूप में क्यों कहा जाता है।

  JVM समस्या

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

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

  OSGi

  OSGi तकनीक विशिष्टताओं का एक समूह है जो जावा के लिए एक गतिशील घटक प्रणाली को परिभाषित करता है। ये विनिर्देश एक विकास मॉडल की अनुमति देते हैं जहां अनुप्रयोग (गतिशील) कई अलग (पुन: प्रयोज्य) घटकों से बने होते हैं।

  OSGi के लाभ

  • Reduced Complexity - आवेदन सहयोगी घटकों के रूप में बनाया गया है जो एक दूसरे से उनके कार्यान्वयन के विवरण को छिपाते हैं जिसके परिणामस्वरूप जटिलता कम हो जाती है।

  • Reusability - कई घटक एक कंटेनर में तैनात एक ही घटक का लाभ उठा सकते हैं।

  • Deployment - OSGi कंटेनर के पुनरारंभ के बिना अपने जीवनचक्र प्रबंधन API के साथ फ्लाई पर घटकों के स्टार्ट, स्टॉप और अपडेट के लिए समर्थन प्रदान करता है।

  बंडलों बनाम सुविधाएँ

  निम्नलिखित बंडलों और सुविधाओं के बीच तुलना है।

  बंडल

  बंडल्स OSGi के बराबर हैं जो JVM के लिए जार हैं। बंडल्स एक कलाकृतियों हैं जो एक OSGi कंटेनर में तैनात हैं। बंडल ऐसे घटक होते हैं जो एक अनुप्रयोग बनाने के लिए एक साथ या स्वतंत्र रूप से काम करते हैं।

  इन बंडलों को कंटेनर को पुनरारंभ किए बिना रनटाइम पर स्थापित, अनइंस्टॉल, अपडेट, प्रारंभ या रोका जा सकता है।

  विशेषताएं

  सुविधाएँ एक साथ कई बंडलों को तैनात करने का एक तरीका है। कभी-कभी समूह में बंडलों को तैनात करने के लिए यह अधिक समझ में आता है। सुविधाएँ हमें केवल एक कमांड के साथ बंडलों के एक समूह को तैनात करने की अनुमति देती हैं।

  एक और कंटेनर क्यों?

  Apache Karaf एक OSGi आधारित रनटाइम है, यह वह जगह है जहाँ हमारे एप्लिकेशन बंडल चलते हैं। फ्यूज अपाचे करफ को अपने रनटाइम के रूप में उपयोग करता है जिसमें बंडलों को चलाते हैं और व्यवसाय की कार्यक्षमता प्रदान करने के लिए सहयोग करते हैं।

  Karaf फेलिक्स और विषुव पर बनाया गया है जो OSGi फ्रेमवर्क हैं।

  करफ आर्किटेक्चर

  

  Apache Karaf निम्नलिखित अतिरिक्त कार्यक्षमताओं को मूल OSGi रनटाइम में जोड़ता है।

  गर्म तैनाती

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

  लॉगिंग

  Karaf सभी बंडलों के लिए लॉग जनरेट करके केंद्रीकृत लॉगिंग प्रदान करता है $Fuse_home/data/log। हम लकड़हारा कॉन्फ़िगरेशन को संपादित कर सकते हैंorg.ops4j.pax.logging.cfg में $Fuse_home/etc directory।

  व्यवस्थापक कंसोल

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

  

  एसएसएच एक्सेस

  करफ एसएसएच के साथ इस एडमिन कंसोल को रिमोट एक्सेस की अनुमति देता है। मान्य क्रेडेंशियल्स वाला कोई भी व्यक्ति SSH टर्मिनल पर karaf admin कंसोल से जुड़ सकता है।

  इस अध्याय में, हम चर्चा करेंगे कि अपाचे कैमल क्या है और यह कुछ उदाहरणों के साथ, समापन बिंदुओं के बीच प्रभावी रूप से डेटा कैसे रूट करता है।

  क्या है अपाचे ऊंट?

  अपाचे कैमल एक ओपन सोर्स इंटीग्रेशन फ्रेमवर्क है जिसे 2007 की शुरुआत में शुरू किया गया था।

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

  ऊंट को रूटिंग और मध्यस्थता इंजन के रूप में भी जाना जाता है क्योंकि यह प्रभावी रूप से एंडपॉइंट के बीच डेटा को रूट करता है, जबकि डेटा फॉर्मेट, एंडपॉइंट कनेक्टिविटी और कई और अधिक परिवर्तन जैसे भारी भार उठाता है।

  मूल उदाहरण

  अपाचे ऊंट का उपयोग करने के लिए आवश्यक शर्तें हैं -

  • Java
  • Maven
  • Redhat JBoss फ्यूज 6.1-GA-379

  अनुप्रयोग के बुनियादी कंकाल बनाएँ

  mvn:archetype generate 
  –DgroupId = com.tutorialpoint.app 
  –DartifactId = camel-first-app 
  –DarchetypeGroupId = org.apache.camel.archetypes
  –DarchetypeArtifactId = camel-archetype-spring 
  –DinteractiveMode = false -X

  यह निम्नलिखित निर्देशिका संरचना उत्पन्न करना चाहिए।

  

  यह हमारे कैमल एप्लिकेशन का एक मूल कंकाल है जो उत्पन्न हो रहा है।

  ऊंट-संदर्भ संपादित करें। xml

  संपादित करें camel-first-app → src → main → resources → META-INF\spring\camel-context.xml नीचे के रूप में मैच करने के लिए

  <?xml version = "1.0" encoding = "UTF-8"?>
  <!-- Configures the Camel Context-->
  <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.xsd
     http://camel.apache.org/schema/spring
     http://camel.apache.org/schema/spring/camel-spring.xsd">
  
     <camelContext xmlns = "http://camel.apache.org/schema/spring">
        <!-- here is a sample which processes the input file
           (leaving them in place - see the 'noop' flag) 
           then performs content based routing on the message using XPath -->
  			
        <route>
           <from uri = "file:///d:/src/data?noop=false"/>
           <choice>
              <when>
                 <xpath>/person/city = 'London'</xpath>
                 <log message = "UK message"/>
                 <to uri = "file:///d:/target/messages/uk"/>
              </when>
  				
              <otherwise>
                 <log message = "Other message"/>
                 <to uri = "file:///d:/target/messages/others"/>
              </otherwise>
  				
           </choice>
  			
        </route>
     </camelContext>
  </beans>

  Pom.xml संपादित करें

  <Plugins> </ plugins> के अंदर निम्न कोड जोड़ें

  <plugin>
     <groupId>org.apache.felix</groupId>
     <artifactId>maven-bundle-plugin</artifactId>
     <version>2.3.4</version>
     <extensions>true</extensions>
  	
     <configuration>
        <instructions>
           <Bundle-SymbolicName>
              ${project.artifactId}
           </Bundle-SymbolicName>
           <Import-Package>*</Import-Package>
        </instructions>
     </configuration>
  	
  </plugin>

  से पैकेजिंग प्रकार बदलें jar → bundle।

  <packaging>bundle</packaging>

  निम्नलिखित कमांड का उपयोग करके परियोजना का निर्माण करें -

  mvn clean install

  फ्यूज में प्रोजेक्ट स्थापित करें

  उपयोग कर फ्यूज शुरू करें Fuse.bat/start.bat। यदि आप फ्यूज का उपयोग शुरू करते हैंstart.bat, उपयोग client.batफ्यूज से जुड़ने के लिए। आपको निम्न स्क्रीनशॉट में दिखाए अनुसार UI प्राप्त करना चाहिए।

  

  यह Karaf और फ्यूज कमांड तक पहुंचने के लिए CLI है।

  install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

  अगर आपका प्रोजेक्ट चल रहा है तो टेस्ट करें

  अब आपका आवेदन फ़्यूज़ में स्थापित होना चाहिए। अंदर डेटा निर्देशिका की प्रतिलिपि बनाएँcamel-first-app और इसे अंदर रखें D:/src/ और यह शहर = लंदन में होने वाले संदेश की प्रतिलिपि बनाना चाहिए D:/target/merssages/uk।

  में इनपुट फ़ाइल रखें D:/src/data

  Input

  Message1.xml

  <?xml version = "1.0" encoding = "UTF-8"?>
  <person user = "james">
     <firstName>James</firstName>
     <lastName>Strachan</lastName>
     <city>London</city>
  </person>

  Message2.xml

  <?xml version = "1.0" encoding = "UTF-8"?>
  <person user = "hiram">
     <firstName>Hiram</firstName>
     <lastName>Chirino</lastName>
     <city>Tampa</city>
  </person>

  Output

  डी में: / लक्ष्य / संदेश / ब्रिटेन

  <?xml version = "1.0" encoding = "UTF-8"?>
  <person user = "james">
     <firstName>James</firstName>
     <lastName>Strachan</lastName>
     <city>London</city>
  </person>

  डी में: / लक्ष्य / संदेश / अन्य

  <?xml version = "1.0" encoding = "UTF-8"?>
  <person user = "hiram">
     <firstName>Hiram</firstName>
     <lastName>Chirino</lastName>
     <city>Tampa</city>
  </person>

  इस अध्याय में, हम विभिन्न ऊंट अवधारणाओं को समझेंगे। शुरुआत करने के लिए मुख्य अवधारणाओं को समझने के लिए एक मूल उदाहरण लेते हुए शुरू करते हैं।

  CamelContext

  हर ऊंट के आवेदन में कम से कम एक CamelContext होगा। यह वह स्थान है जहाँ हम ऊँट मार्ग जोड़ते हैं। यह समान हैApplicationContext वसंत ऋतु का।

  ऊंट के संदर्भ को एक कंटेनर के रूप में माना जा सकता है जो सभी चीजों को एक साथ रखता है। एक ऊंट के संदर्भ में इसके अंदर कई मार्ग हो सकते हैं।

  मार्गों

  CamelContext में एक या अधिक मार्ग हो सकते हैं। मार्ग एकीकरण तर्क हैं जो परिभाषित करते हैं कि ऊंट संदर्भ में डेटा एक छोर से दूसरे तक कैसे प्रवाहित होगा।

  endpoint

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

  अवयव

  अवयव कैमल में विस्तार के बिंदु हैं। घटक प्रौद्योगिकी, डेटा प्रारूप, ट्रांसफार्मर आदि के लिए एक इंटरफ़ेस हो सकते हैं। वे एंडपॉइंट के लिए एक कारखाने के रूप में भी कार्य कर सकते हैं।

  

  EIP

  ईआईपी का मतलब एंटरप्राइज इंटीग्रेशन पैटर्न है। ये एक आवर्ती समस्या के लिए पहचाने जाने वाले और प्रसिद्ध समाधान हैं। ऊंट अधिकांश एंटरप्राइज़ एकीकरण पैटर्न का समर्थन करता है।

  सामग्री आधारित राउटर

  CBR पैटर्न हमें इनपुट फ़ाइल की सामग्री के अनुसार डेटा रूट करने की अनुमति देते हैं।

  

  इस पैटर्न का उपयोग तब किया जाता है जब हमें इनपुट के शरीर की सामग्री के आधार पर मूल्यों को रूट करना होता है।

  निम्नलिखित उदाहरण से डेटा पढ़ेंगे D:/data/inputनिर्देशिका। पढ़ने के बाद, यह डेटा टैग के अंदर मूल्य टैग के लिए जाँच करेगा। यदि मान टैग में हैvalue1, इसे भेजा जाएगा D:/value1, अगर इसमें शामिल है value2, इसे भेजा जाएगा D:/value2 और यदि इन दोनों में से कोई भी नहीं है, तो इसे दूसरों को भेजा जाएगा।

  <CamelContext xmlns = "http://camel.apache.org/schema/spring">
     <route>
        <from uri = "file:///D:/data/input"/>
        <choice>
           <when>
              <xpath>/data/value = 'value1'</xpath>
              <to uri = "file:///D:/value1"/>
           </when> 
           <when>
              <xpath>/data/value = 'value2'</xpath>
              <to uri = "file:///D:/value2"/>
           </when>  
  			
           <otherwise>
              <to uri = "file:///D:/others "/>
           </otherwise>
  			
        </choice>
     </route>
  </camelContext>

  Input

  डी: /data/input/message1.xml

  <data>
     <value>value1</value>
  </data>

  डी: /data/input/message2.xml

  <data>
     <value>value2</value>
  </data>

  Output

  डी: / मान 1 /

  <data>
     <value>value1</value>
  </data>

  डी: / मान 2 /

  <data>
     <value>value2</value>
  </data>

  फाड़नेवाला

  फाड़नेवाला पैटर्न का उपयोग इनपुट डेटा को छोटे विखंडू में विभाजित करने के लिए किया जाता है।

  

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

  <CamelContext xmlns = "http://camel.apache.org/schema/spring">
     <route>
        <from uri = "file:///D:/inbox"/>
        <split streaming = "true">
           <tokenize token = "order" xml = "true"/>
           <to uri = "activemq:queue:order"/>
        </split>
     </route>
  </CamelContext>

  Input

  डी: /inbox/message.xml

  <order>
     <data>
        <value>value1</value>
     </data>
  </order>
  
  <order>
     <data>
        <value>value2</value>
     </data>
  </order>
  
  <order>
     <data>
        <value>value3</value>
     </data>
  </order>

  Output

  यदि आप एएमक्यू की जांच करते हैं, तो आपको 3 संदेश पोस्ट किए जाएंगे।

  <order>
     <data>
        <value>value4</value>
     </data>
  </order>

  प्राप्तकर्ताओं की सूची

  प्राप्तकर्ता सूची पैटर्न का उपयोग तब किया जाता है जब प्राप्तकर्ता की एक सूची को संदेश निकाय से ही पुनर्प्राप्त करने की आवश्यकता होती है।

  

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

  <CamelContext xmlns = "http://camel.apache.org/schema/spring">
     <route>
        <from uri = "jms:xmlOrders" />
        <recipientList>
           <xpath>/order/customer</xpath>
        </recipientList>
     </route>
  </camelContext>

  अन्य ई.आई.पी.

  ऊंट पहचाने गए लगभग सभी ईआईपी को सहायता प्रदान करता है। आमतौर पर इस्तेमाल किए जाने वाले कुछ ईआईपी नीचे दिए गए हैं।

  • Log - पूरा संदेश या उसके भाग को लॉग करने के लिए

  • Message Filter - संदेशों की सामग्री को फ़िल्टर करना

  • Re-Sequencer - अनुक्रम में सभी टोकन प्राप्त करने के लिए

  • Wiretap - यात्रा संदेशों का निरीक्षण करने के लिए

  ईआईपी की पूरी सूची और उनके उपयोग को कैमल के आधिकारिक दस्तावेज में पाया जा सकता है http://camel.apache.org/eip.html

  कैमल में अपवाद हैंडलिंग

  Using Error Handler - ऊंटनी में अपवादों को संभालने का यह सबसे आसान तरीका है।

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

  <bean id = "loggingErrorHandler" class = "org.apache.camel.builder.LoggingErrorHandler">
     <property name = "logName" value = "mylogger.name"/>
     <property name = "level" value = "DEBUG"/>
  </bean>
  
  <camelContext errorHandlerRef = ” loggingErrorHandler” >
     …
  </camelContext>

  अंत में पकड़ने की कोशिश का उपयोग करना

  कैमल जावा स्टाइल को भी सपोर्ट करता है Try Catch Finally block त्रुटि से निपटने के लिए।

  जावा की तरह, इसके तीन ब्लॉक हैं -

  • doTry ब्लॉक में वह कोड होता है जो अपवाद उत्पन्न कर सकता है।

  • doCatch ब्लॉक में कोड होता है जिसे अपवाद के मामले में निष्पादित किया जाना चाहिए।

  • doFinallyब्लॉक में कोड होता है जिसे अपवाद के बावजूद निष्पादित किया जाना चाहिए। अपवाद को उठाया गया था या नहीं, यह हमेशा किसी भी मामले में निष्पादित किया जाएगा।

  Note- नकली परीक्षण घटक है और अन्य उद्देश्यों के लिए अनुशंसित नहीं है। यह ऊंट का घटक है जो परीक्षण संचालित विकास में जेएमओके घटक की तरह ही परीक्षण के लिए उपयोग किया जाता है।

  <route>
     <from uri = "direct:start"/>
     <doTry>
        <process ref = "someProcesorThatmayFail"/>
        <to uri = "mock:result"/>
  		
        <doCatch>
           <exception>java.io.IOException</exception>
           <exception>java.lang.IllegalStateException</exception>
           <to uri = "mock:catch"/>
        </doCatch>
  		
        <doFinally>
           <to uri = "mock:finally"/>
        </doFinally>
  		
     </doTry>
  </route>

  उपरोक्त उदाहरण में, हम अपवादों की एक सूची दे सकते हैं जिन्हें कैच ब्लॉक द्वारा नियंत्रित करने की आवश्यकता है।

  फ्यूज में बंडिंग की तैनाती

  उपयोग कर फ्यूज शुरू करें Fuse.bat/start.bat।

  यदि आप start.bat का उपयोग करके फ़्यूज़ प्रारंभ करते हैं, तो फ़्यूज़ से कनेक्ट करने के लिए client.bat का उपयोग करें। आपको निम्न स्क्रीनशॉट में दिखाए अनुसार UI प्राप्त करना चाहिए।

  

  यह Karaf और फ्यूज कमांड तक पहुंचने के लिए CLI है।

  install –s mvn:group.id /artifact.id/version 
  e.g. install –s mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

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

  Apache CXF क्या है?

  Apache CXF एक वेब सेवा विकास ढांचा है जिसका उपयोग SOAP और रेस्ट वेब सेवाओं को विकसित करने के लिए किया जा सकता है। सीएक्सएफ पूरी तरह से अनुपालन हैJAX-RS and JAX-Ws मानक।

  यह अब सबसे अधिक व्यापक रूप से उपयोग किया जाने वाला वेब सेवा विकास ढांचा है। एक्सएक्स 2 पर सीएक्सएफ ने सीखा और सुधार किया है जो अब धीरे-धीरे सीएक्सएफ द्वारा प्रतिस्थापित किया जा रहा है।

  एक्सएक्स 2 बनाम सीएक्सएफ

  	CXF	Axis2
  सुधार	सीएक्सएफ अब के रूप में सबसे अधिक इस्तेमाल किया जाने वाला ढांचा है। यह Axis2 पर बहुत सुधार है	एक्सिस 2 को धीरे-धीरे सीएक्सएफ द्वारा प्रतिस्थापित किया जा रहा है। सीएक्सएफ की तुलना में इसे अधिक कोड की आवश्यकता होती है
  कोड आवश्यक है	एक्सिस 2 की तुलना में सीएक्सएफ को कम कोड की आवश्यकता होती है	Axis2 को तुलनात्मक रूप से अधिक कोड की आवश्यकता होती है
  मानक अनुपालन	CSF JAX-RS और JAX-WS के साथ पूरी तरह से अनुरूप है	Axis2 JAX-RS और JAX-WS के साथ पूरी तरह से अनुरूप नहीं है
  वसंत के साथ संगत	हाँ	नहीं
  सामने के सिरों का पृथक्करण	JAX-WS कोड से फ्रंट-एंड की साफ जुदाई	कोई साफ जुदाई प्रदान नहीं की जाती है

  साबुन

  SOAP का अर्थ है सिंपल ऑब्जेक्ट एक्सेस प्रोटोकॉल। यह दो प्रणालियों के बीच वेब सेवाओं पर संरचित जानकारी के आदान-प्रदान के लिए एक प्रोटोकॉल है। यह ज्यादातर डेटा को संरचित करने के लिए XML पर निर्भर करता है और संदेश वार्ता और प्रसारण के लिए HTTP या SMTP का उपयोग करता है।

  SOAP वेब सेवाएँ विकसित करने के लिए दो दृष्टिकोण हैं -

  • Code first - इस दृष्टिकोण में, कोड से WSDL उत्पन्न होता है।

  • Contract first - पहले अनुबंध में, कोड WSDL से उत्पन्न होता है।

  सीएक्सएफ का उपयोग कर एसओएपी विकास

  मावेन को कॉन्फ़िगर करें

  निम्नलिखित प्रोफाइल को अपनी सेटिंग में जोड़ें। Maven का xml।

  <profiles>
     <profile>
        <id>Jboss-Fuse</id>
  		
        <activation>
           <activeByDefault>true</activeByDefault>
        </activation>
  		
        <repositories>
           <repository>
              <id>fusesource</id>
              <url>http://repo.fusesource.com/nexus/content/groups/public/</url>
              <snapshots>
                 <enabled>false</enabled>
              </snapshots>
              <releases>
                 <enabled>true</enabled>
              </releases>
           </repository>
        </repositories>
  		
     </profile>
  </profiles>

  कंकाल बनाएँ

  mvn archetype:generate
  -DarchetypeGroupId = org.apache.servicemix.tooling 
  -DarchetypeArtifactId = servicemix-cxf-code-first-osgi-bundle 
  -DarchetypeVersion=2012.01.0.redhat-60024 
  -DgroupId = org.fusesource.example 
  -DartifactId = cxf-basic 
  -Dversion = 1.0-SNAPSHOT

  Build Web Service Project।

  mvn clean install

  Install web-service into Fuse using the following command।

  JBossFuse:karaf@root>install -s mvn:org.fusesource.example/cxf-basic/1.0-SNAPSH

  Check if bundle has registered SOQP web-service

  यूआरएल खोलें http://localhost:8181/cxf

  

  वेब-सेवा को निम्नानुसार सूचीबद्ध किया जाना चाहिए।

  Testing Web-Service

  mvn -Pclient

  INFO - सेवा बनाना {http://ws.totorials.com/} क्लास कॉम से व्यक्ति सेवा

  torials.ws.Person
  Invoking getPerson...
  getPerson._getPerson_personId = Guillaume
  getPerson._getPerson_ssn = 000-000-0000
  getPerson._getPerson_name = Guillaume
  [INFO] ------------------------------------------------------------------------
  [INFO] BUILD SUCCESS
  [INFO] ------------------------------------------------------------------------
  [INFO] Total time: 30.668 s
  [INFO] Finished at: 2016-02-15T21:01:20+05:30
  [INFO] Final Memory: 10M/37M
  [INFO] ------------------------------------------------------------------------

  शुरू करने के लिए, REST प्रतिनिधि राज्य अंतरण के लिए खड़ा है। यह वेब सेवाओं को राज्य-कम, कैचएबल, क्लाइंट-सर्वर प्रोटोकॉल के आधार पर विकसित करने का एक तरीका है, जो ज्यादातर मामलों में HTTP है।

  अन्य वेब सेवाएँ नेटवर्क से डेटा को पोस्ट करने, पाने, हटाने के लिए HTTP अनुरोधों का उपयोग करती हैं।

  सीएक्सएफ का उपयोग करके अन्य विकास

  एक सरल मावेन क्विक-स्टार्ट प्रोजेक्ट बनाएं

  mvn archetype:generate 
  -DgroupId = com.tuts.abhinav 
  -DartifactId = rest-service
  -DarchetypeArtifactId = maven-archetype-quickstart 
  -DinteractiveMode = false

  निर्भरता जोड़ें

  <dependency>
     <groupId>org.apache.servicemix.specs</groupId>
     <artifactId>org.apache.servicemix.specs.jsr311-api-1.1.1</artifactId>
     <version>1.9.0</version>
     <scope>provided</scope>
  </dependency>
  
  <dependency>
     <groupId>org.apache.servicemix</groupId>
     <artifactId>servicemix-http</artifactId>
     <version>2013.01</version>
  </dependency>
  
  <dependency>
     <groupId>log4j</groupId>
     <artifactId>log4j</artifactId>
     <version>1.2.16</version>
  </dependency>

  निर्माण निर्देश जोड़ें

  <build>
     <defaultGoal>install</defaultGoal>
     <plugins>
        <plugin>
           <groupId>org.apache.felix</groupId>
           <artifalctId>maven-bundle-plugin</artifactId>
           <version>2.3.4</version>
           <extensions>true</extensions>
  			
           <configuration>
              <instructions>
                 <Bundle-SymbolicName>rest-example-database-post-method
                    </Bundle-SymbolicName>
                 <Import-Package>* </Import-Package>
              </instructions>
           </configuration>
  			
        </plugin>
     </plugins>
  </build>

  फ्यूज प्लगिन रिपोजिटरीज जोड़ें

  <pluginRepositories>
     <pluginRepository>
        <id>fusesource.m2</id>
        <name>FuseSource Community Release Repository</name>
        <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
        <snapshots>
           <enabled>false</enabled>
        </snapshots>
  		
        <releases>
           <enabled>true</enabled>
        </releases>
     </pluginRepository>
  <pluginRepositories>

  रिपोजिटरी जोड़ें

  <repositories>
     <repository>
        <id>fusesource.m2</id>
        <name>FuseSource Community Release Repository</name>
        <url>http://repo.fusesource.com/nexus/content/repositories/releases</url>
        <snapshots>
           <enabled>false</enabled>
        </snapshots>
  		
        <releases>
           <enabled>true</enabled>
        </releases>
  		
     </repository>
  	
     <repository>
        <id>fusesource.ea</id>
        <name>FuseSource Community Early Access Release Repository</name>
        <url>http://repo.fusesource.com/nexus/content/groups/ea</url>
        <snapshots>
           <enabled>false</enabled>
        </snapshots>
        <releases>
           <enabled>true</enabled>
        </releases>
     </repository>
  	
  </repositories>

  सेवा वर्ग बनाएँ

  Com / tuts / के तहत वर्ग UserService.java बनाएँ

  package com.tuts;
  
  import javax.ws.rs.GET;
  import javax.ws.rs.Path;
  import javax.ws.rs.Produces;
  import javax.ws.rs.core.MediaType;
  
  @Path("/UserService_1")
  public class UserService {
     @GET
     @Path("/get_data")
     @Produces(MediaType.APPLICATION_JSON)
  	
     public String getUser() {
        String reponse = "This is standard response from REST";
        return reponse;
     }
  }

  Blueprint.xml बनाएं

  / Src / main / Resources / OSGI-INF / खाका Blueprint.xml के तहत खाका बनाएँ

  <?xml version = "1.0" encoding = "UTF-8"?>
  <blueprint xmlns = "http://www.osgi.org/xmlns/blueprint/v1.0.0"
     xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance" 
     xmlns:jaxrs = "http://cxf.apache.org/blueprint/jaxrs"
     xsi:schemaLocation = "http://www.osgi.org/xmlns/blueprint/v1.0.0 
     http://www.osgi.org/xmlns/blueprint/v1.0.0/blueprint.xsd
     http://cxf.apache.org/blueprint/jaxrs 
     http://cxf.apache.org/schemas/blueprint/jaxrs.xsd">
  	
     <jaxrs:server id = "service" address = "/users">
        <jaxrs:serviceBeans>
           <ref component-id = "userService" />
        </jaxrs:serviceBeans>
     </jaxrs:server>
  	
     <bean id = "userService" class = "com.tuts.UserService" />
  </blueprint>

  फ्यूज में रेस्ट सर्विस स्थापित करें

  install -s mvn:com.tuts.abhinav/rest-service/1.0-SNAPSHOT

  जांचें कि क्या बंडल में एक पंजीकृत वेब-सेवा है

  यूआरएल खोलें http://localhost:8181/cxf

  

  वेब सेवा का परीक्षण करें

  यूआरएल खोलें http://localhost:8181/cxf/users12/UserService_1/get_data

  

  इस अध्याय में, हमें ActiveMQ के बारे में पता चलेगा और यह कैसे संदेशों के ब्रोकर के रूप में कार्य करता है ताकि एप्लिकेशन एक-दूसरे के साथ संवाद कर सकें।

  AMQ क्या है?

  ActiveMQ जावा में लिखा गया एक ओपन सोर्स मैसेज ब्रोकर है। यह पूरी तरह से JMS 1.1 मानकों के अनुरूप है।

  जेएमएस एक विनिर्देश है जो संदेश आधारित प्रणाली के विकास की अनुमति देता है। ActiveMQ संदेशों के ब्रोकर के रूप में कार्य करता है जो अनुप्रयोगों के बीच बैठता है और उन्हें अतुल्यकालिक और विश्वसनीय तरीके से संवाद करने की अनुमति देता है।

  

  मैसेजिंग के प्रकार

  बेहतर समझ के लिए नीचे दो तरह के संदेश विकल्प दिए गए हैं।

  बिंदु से बिंदु

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

  यदि कोई उपभोक्ता नहीं हैं, तो ब्रोकर संदेशों को तब तक पकड़ कर रखेगा जब तक कि उसे उपभोक्ता नहीं मिल जाता। इस प्रकार के संचार को भी कहा जाता हैQueue based communicationजहां निर्माता एक कतार में संदेश भेजता है और कतार से केवल एक उपभोक्ता को एक संदेश मिलता है। यदि एक से अधिक उपभोक्ता हैं, तो उन्हें अगला संदेश मिल सकता है, लेकिन उन्हें अन्य उपभोक्ता के समान संदेश नहीं मिलेगा।

  

  प्रकाशित करें / सदस्यता लें

  इस प्रकार के संचार में, ब्रोकर सभी सक्रिय उपभोक्ताओं को संदेशों की एक ही प्रति भेजता है। इस प्रकार के संचार के रूप में भी जाना जाता हैTopic based communicationजहां ब्रोकर सभी सक्रिय उपभोक्ता को वही संदेश भेजता है जो विशेष विषय के लिए सदस्यता लेता है। यह मॉडल एक तरफ़ा संचार का समर्थन करता है जहाँ प्रेषित संदेशों का कोई सत्यापन अपेक्षित नहीं है।

  

  कतार और विषय बनाना

  फ्यूज ActiveMQ के साथ बंडल में आता है। हम एफएमसी कंसोल (एएमक्यू के साथ काम करने के लिए ब्राउज़र आधारित इंटरफ़ेस) का उपयोग करके एक्टिवएमक्यू का उपयोग कर सकते हैं।

  FMC का उपयोग करके लॉगिन करें localhost:8181 और चुनें ActiveMQ टैब।

  
  • + बनाएं पर क्लिक करें
  • कतार / विषय नाम दर्ज करें
  • रेडियो बटन से कतार / विषय का चयन करें
  • Create Queue / Create विषय पर क्लिक करें
  

  अब आप को देखने में सक्षम होना चाहिए TestQ रूट के तहत बनाया गया → कतार →

  

  बनाए गए विषय की जांच करने के लिए रूट का अनुसरण करें → विषय।

  कतार की सामग्री को ब्राउज़ / हटाना

  • FMC का उपयोग करके लॉगिन करें localhost:8181

  • ActiveMQ टैब का चयन करें

  • रूट → कतार → टेस्टक्यू <वह कतार चुनें जिसे आप ब्राउज़ करना चाहते हैं> → ब्राउज़ करें

  
  • इस संदेश की सामग्री की जाँच करने के लिए, उस विशेष संदेश पर क्लिक करें।
  

  • आप शीर्ष दाएं कोने पर दिखाए गए डिलीट बटन पर क्लिक करके किसी विशेष संदेश को हटा सकते हैं

  इस अध्याय में, हम सीखेंगे कि कैमल के साथ ActiveMQ कैसे काम करता है।

  ActiveMQ घटक में कॉन्फ़िगर करना

  हमारे कोड में ActiveMQ कतार या विषय का उपयोग करने से पहले हमें ActiveMQComponent को कॉन्फ़िगर करना होगा। ActiveMQComponent का न्यूनतम कॉन्फ़िगरेशन निम्न कार्यक्रम में दिखाया गया है -

  <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
     <property name = "brokerURL" value = "tcp://localhost:61616"/>
     <property name = "userName" value = "admin"/>
     <property name = "password" value = "admin"/>
  </bean>

  • brokerURL - AMQ ब्रोकर के लिए होस्ट और पोर्ट निर्दिष्ट करता है।

  • username - AMQ ब्रोकर से कनेक्ट करने के लिए उपयोग करने के लिए उपयोगकर्ता नाम निर्दिष्ट करता है।

  • password - AMQ ब्रोकर से कनेक्ट करने के लिए पासवर्ड निर्दिष्ट करता है।

  कतार से जुड़ना

  अब जब हमने ActiveMQComponent को कॉन्फ़िगर किया है, तो हम इसे अपने CamelContext में समापन बिंदु के रूप में उपयोग कर सकते हैं।

  हम निम्नलिखित प्रारूप में AMQ समापन बिंदु का उपयोग करेंगे -

  Activemq:[queue|topic]:[queueName|topicName]

  AMQ को संदेश लिखना

  <?xml version = "1.0" encoding="UTF-8"?>
  <!-- Configures the Camel Context-->
  <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.xsd
     http://camel.apache.org/schema/spring
     http://camel.apache.org/schema/spring/camel-spring.xsd">

  इस बंडल को फ्यूज कंटेनर में तैनात करने के बाद, आपको उन संदेशों को एएमक्यू में पोस्ट करने में सक्षम होना चाहिए जिन्हें फाइलों के रूप में रखा गया था D:/src/data।

  Input

  डी: /src/data/input.txt

  Test me

  Output

  

  एएमक्यू से पढ़ना

  <?xml version = "1.0" encoding = "UTF-8"?>
  <!-- Configures the Camel Context-->
  
  <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.xsd
     http://camel.apache.org/schema/spring
     http://camel.apache.org/schema/spring/camel-spring.xsd">
  	
     <camelContext xmlns = "http://camel.apache.org/schema/spring">
        <!-- here is a sample which processes the input files
           (leaving them in place - see the 'noop' flag)
            then performs content based routing on the message using XPath -->
  			 
        <route>
           <from uri = "activemq:queue:TestQ"/>
           <to uri = "file:///d:/src"/>
        </route>
     </camelContext>
  	
     <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
        <property name = "brokerURL" value = "tcp://localhost:61616"/>
        <property name = "userName" value = "admin"/>
        <property name = "password" value = "admin"/>
     </bean>
  	
  </beans>

  Input

  इस बंडल को तैनात करने के बाद, आपको डी: / src में उत्पन्न होने वाली एक फ़ाइल देखनी चाहिए और संदेशों का उपभोग करना चाहिए। साथ ही उपभोक्ता को उस कतार के लिए दिखाया जाना चाहिए।

  

  Output

  डी: / src

  Test me

  टॉपिक के लिए लेखन

  <?xml version = "1.0" encoding = "UTF-8"?>
  <!-- Configures the Camel Context-->
  <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.xsd
     http://camel.apache.org/schema/spring 
     http://camel.apache.org/schema/spring/camel-spring.xsd">
  	
     <camelContext xmlns = "http://camel.apache.org/schema/spring">
        <!-- here is a sample which processes the input files
           (leaving them in place - see the 'noop' flag)
            then performs content based routing on the message using XPath -->
  			 
        <route>
           <from uri = "file:///d:/src"/>
           <to uri = "activemq:topic:TestTopic” />
        </route>
     </camelContext>
  	
     <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
        <property name = "brokerURL" value = "tcp://localhost:61616"/>
        <property name = "userName" value = "admin"/>
        <property name = "password" value = "admin"/>
     </bean>
  	
  </beans>

विषय से पढ़ना

<?xml version = "1.0" encoding = "UTF-8"?>
<!-- Configures the Camel Context-->
<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.xsd
   http://camel.apache.org/schema/spring 
   http://camel.apache.org/schema/spring/camel-spring.xsd">
	
   <camelContext xmlns = "http://camel.apache.org/schema/spring">
      <!-- here is a sample which processes the input files
         (leaving them in place - see the 'noop' flag)
         then performs content based routing on the message using XPath -->
			
      <route>
         <from uri = "activemq:topic:TestTopic"/>
         <to uri = "file:///d:/src2"/>
      </route>
   </camelContext>
	
   <bean id = "activemq" class = "org.apache.activemq.camel.component.ActiveMQComponent">
      <property name = "brokerURL" value="tcp://localhost:61616"/>
      <property name = "userName" value = "admin"/>
      <property name = "password" value = "admin"/>
   </bean>
	
</beans>

Input

डी: /src/file1.xml

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

Output

डी: / src /

<order>
   <data>
      <value>value1</value>
   </data>
</order>

<order>
   <data>
      <value>value2</value>
   </data>
</order>

<order>
   <data>
      <value>value3</value>
   </data>
</order>

फैब्रिक क्या है?

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

फैब्रिक क्यों?

फैब्रिक में निम्नलिखित विशेष क्षमताएं हैं जो इसे वितरित वातावरण में उपयोग के लिए एक आदर्श उम्मीदवार बनाती है।

• कपड़े में सभी कंटेनरों की स्थिति की निगरानी करना।
• दूरस्थ कंटेनरों को शुरू करना और रोकना।
• किसी विशेष एप्लिकेशन को चलाने के लिए दूरस्थ कंटेनर प्रदान करता है।
• अनुप्रयोगों को अपग्रेड करना और लाइव सिस्टम में पैच को रोल आउट करना।
• सिस्टम पर बढ़े हुए भार से निपटने के लिए उदाहरण के लिए नए कंटेनरों के साथ शुरू और प्रावधान करना।

फैब्रिक सेटअप

कपड़ा बनाना

सामान्य फ्यूज कंटेनर को निम्न कमांड का उपयोग करके फैब्रिक में बदला जा सकता है

fabric: create --clean --zookeeper-password myZooPass

अन्य कंटेनर को फैब्रिक से जोड़ना -

fabric:join --zookeeper-password myZooPass <fabric_host>:2181 Cont1

Note - कृपया वास्तविक कपड़े के नाम के साथ <fabric_host> बदलें, जिस पर कपड़ा चल रहा है।

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

प्रोफाइल

एक प्रोफ़ाइल में निम्नलिखित जानकारी है -

• बंडलों को लगाया जाए
• स्थापित करने के लिए सुविधाएँ
• विन्यास लागू किया जाना है

एक प्रोफाइल कई सर्वरों पर बंडलों, सुविधाओं और कॉन्फ़िगरेशन के एक ही सेट को स्थापित करने के लिए कपड़े के वातावरण में एक रास्ता प्रदान करता है।

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

प्रोफाइल बनाना

• FMC में लॉगिन करें localhost:8181

• रनटाइम → प्रबंधित करें

• प्रोफ़ाइल मेनू के नीचे बाएं हाथ की ओर क्लिक करें +

वह नाम दर्ज करें जिसे आप प्रोफ़ाइल को देना चाहते हैं और बनाएँ पर क्लिक करें।

इसके बाद, प्रोफ़ाइल बनाई जानी चाहिए।

कंटेनर में प्रोफ़ाइल लागू करना

रनटाइम → कंटेनर → रूट (इच्छित कंटेनर का चयन करें)

क्लिक Addजो एक पॉप-अप बॉक्स को ले जाएगा। उस प्रोफ़ाइल को खोजें जिसे आप चाहते हैं और फिर क्लिक करेंAdd।

प्रोफ़ाइल को सूची में दिखाया जाना चाहिए जैसा कि निम्नलिखित स्क्रीनशॉट में दिखाया गया है।

एक बंडल तैनात करना

एक बंडल तैनात करने के लिए, निम्नलिखित पथ का उपयोग करें -

रनटाइम → कंटेनर → रूट (इच्छित कंटेनर का चयन करें) → First_profile (प्रोफ़ाइल का चयन करें)

बंडल टैब पर क्लिक करें। निम्नलिखित प्रारूप में बंडल पथ सेट करें और फिर क्लिक करें+।

mvn:group.id/artifact.id/version

उदाहरण के लिए: mvn:com.tutorialpoint.app/camel-firt-app/1.0-SNAPSHOT

प्रोफ़ाइल में एक बंडल जोड़ा जाएगा और उन सभी कंटेनरों पर तैनात किया जाएगा, जिन्हें प्रोफ़ाइल असाइन किया गया है।

एक बंडल को अन-परिनियोजित करना

बंडल को अन-परिनियोजित करने के लिए, निम्नलिखित पथ का उपयोग करें -

रनटाइम → कंटेनर → रूट (इच्छित कंटेनर का चयन करें) → First_profile (प्रोफ़ाइल चुनें)

बंडल टैब पर क्लिक करें और उस बंडल को खोजें जिसे आप हटाना चाहते हैं और फिर क्लिक करें X। बंडल को उन सभी कंटेनरों से हटा दिया जाएगा जिनमें प्रोफ़ाइल लागू है।

एक बाल कंटेनर बढ़ते लोड को प्रबंधित करने का सबसे आसान तरीका प्रदान करता है। जब सिस्टम यातायात में अचानक लोड का अनुभव कर रहा है और एक भी कंटेनर लोड का सामना करने में सक्षम नहीं है, तो हम आसानी से एक नया कंटेनर बनाने के बजाय, बाल कंटेनरों का एक सेट बना सकते हैं और उनके बीच लोड वितरित कर सकते हैं।

एक बाल कंटेनर बनाना

FMC का उपयोग करके लॉगिन करें localhost:8181

अब, पथ का अनुसरण करें: रनटाइम → कंटेनर → + बनाएँ (दाएं हाथ की ओर बटन)

बच्चे का नाम, माता-पिता कंटेनर जैसे उदाहरण आदि दर्ज करें।

क्लिक Create And Start Container

एक बाल कंटेनर का प्रबंधन

एक बाल कंटेनर केवल एक सामान्य कंटेनर के रूप में कार्य करता है।

बाल कंटेनर रोकना

बाल कंटेनर को रोकने के लिए, पथ का अनुसरण करें: रनटाइम → कंटेनर → चाइल्ड 1

बाल कंटेनर को रोकने के लिए स्टॉप पर क्लिक करें।

बाल कंटेनर शुरू करना

बाल कंटेनर शुरू करने के लिए, पथ का अनुसरण करें: रनटाइम → कंटेनर → चाइल्ड 1

बाल कंटेनर शुरू करने के लिए स्टार्ट पर क्लिक करें।

इस अध्याय में, हम कुछ ज्ञात मुद्दों पर चर्चा करेंगे, जिनका फ्यूज के साथ काम करते समय आप सामना कर सकते हैं। हम इन मुद्दों पर भी चर्चा कर सकते हैं।

कोड परिवर्तन प्रतिबिंबित नहीं होते हैं

क्लाइंट स्क्रिप्ट का उपयोग करके फ़्यूज़ इंस्टेंस से कनेक्ट करें। निम्नलिखित कमांड का उपयोग करके उस बंडल को खोजें जिसके लिए आप किसी समस्या का सामना कर रहे हैं।

JBossFuse:karaf@root > list|grep <Bundle Description>
For Example:
JBossFuse:karaf@root > list|grep Camel
[ 255] [Active ] [ ] [ ] [ 60] Fabric8 :: Camel Component (1.0.0.redhat-379)
[ 266] [Active ] [ ] [Started] [ 60] A Camel Spring Route (1.0.0.SNAPSHOT)

Note - ऊपर कमांड के आउटपुट से बंडल के लिए बंडल आईडी और नीचे कमांड का उपयोग करें।

JBossFuse:karaf@root > update <bundle id>
JBossFuse:karaf@root > update 266

बंडल डाउनलोड नहीं किया जा रहा है

यह निम्नलिखित दो कारणों से हो सकता है -

• मावेन रिपॉजिटरी निर्दिष्ट नहीं है
• बंडल रिपॉजिटरी में मौजूद नहीं है

मावेन रिपोजिटरी निर्दिष्ट नहीं है

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

$ FUSE_INSTALLATION_DIR / etc / संपादित करेंorg.ops4j.paxurl.mvn.cfg

निम्नलिखित दो गुणों को अद्यतन करें -

• org.ops4j.pax.url.mvn.settings = $ M2_HOME / conf /settings.xml
• org.ops4j.pax.url.mvn.localRepository = $ local_repo

Note - Mavens settings.xml में उल्लिखित अपनी स्थानीय रिपॉजिटरी के वास्तविक पथ के साथ $ local_repo बदलें

बंडल रिपोजिटरी में मौजूद नहीं है

यदि मावन सेटिंग्स जगह में हैं लेकिन फिर भी यदि आप बंडल को डाउनलोड करते समय समस्याओं का सामना करते हैं, तो सुनिश्चित करें कि बंडल हैं JAR मावेन रिपोजिटरी में सही स्थान पर मौजूद है।

उदाहरण के लिए, यदि निम्नलिखित बंडल डाउनलोड करते समय त्रुटियों को फेंक रहा है -

mvn:com.tutorialpoint.app/camel-first-app/1.0-SNAPSHOT

अगर वास्तविक JAR मौजूद है तो हमें $ M2_REPO / com / tutorialpoint / app / camel-first-app / 1.0-SNAPSHOT में जांचना होगा।

Note - $ M2_REPO को मावेन रिपॉजिटरी के वास्तविक पथ से बदलना होगा जिसे हमने उपयोग करने के लिए कॉन्फ़िगर किया है।

एफएमसी में प्रवेश करने में सक्षम नहीं (ब्राउज़र आधारित जीयूआई)

Users not Created - यदि आप निम्नलिखित यूआई प्राप्त कर रहे हैं, लेकिन "लॉग इन, फॉरबिडन में विफल" कहकर एक संदेश के साथ लॉगिन करने में सक्षम नहीं हैं।

जांचें कि आपने उपयोगकर्ताओं को इसमें जोड़ा है या नहीं $FUSE_INSTALLATION_HOME/etc/users.properties

उपयोगकर्ताओं को जोड़ने का सही प्रारूप है -

Username = Password,Role

HAWTIO पोर्ट अलग है

यदि आप भी ब्राउज़र में UI: 8181 पर UI प्राप्त नहीं कर पा रहे हैं, तो जांचें कि क्या आपने URL में सही पोर्ट का उल्लेख किया है।

$FUSE_INSTALLATION_HOME/etc/org.ops4j.pax.web.cfg

आप जिस पोर्ट तक पहुंचना चाहते हैं, उसका उपयोग करने के लिए फ़ाइल में निम्नलिखित संपत्ति संपादित करें।

org.osgi.service.http.port=8181

AMQ ब्रोकर काम नहीं कर रहा है

सुनिश्चित करें कि 61616 पोर्ट खुला है और वर्तमान में दूसरे पोर्ट द्वारा उपयोग नहीं किया जा रहा है। यदि आप उसी के लिए डिफ़ॉल्ट 61616 पोर्ट बदलना चाहते हैं, तो आप इसे संपादित कर सकते हैं$FUSE_INSTALLATION_HOME/etc/System.properties

activemq.port = 61616