दिलचस्प पोस्ट
MongoDB में $ खोलना ऑपरेटर क्या है? आउटपुट कैश प्रति उपयोगकर्ता विंडसर – कंटेनर से क्षणिक वस्तुओं खींच रहा है कमजोर लिंकिंग – जांच करें कि कोई वर्ग मौजूद है या नहीं और उस वर्ग का उपयोग करें jquery .live ('click') vs.click () कक्षा अमूर्त नहीं है और सार विधि को ओवरराइड नहीं करता है एक JTextField / JTextComponent में सीमित चयन? संख्या का वर्ग #define का उपयोग करके परिभाषित किया जा रहा है एसवीजी डोनट का टुकड़ा पथ तत्व (कुंडलाकार क्षेत्र) के रूप में UITableViewCell में आलसी लोड छवियां Jquery का उपयोग करके एक चयन के चयनित विकल्प का पाठ कैसे प्राप्त करें? मेटप्ललिब स्कैटर प्लॉट में एक लॉगरिदमिक कलरबार सेट इन्वर्नल कॉलबैक केवल एक बार चलाता है पुनरावर्ती फ़ंक्शन कॉल के बिना क्रमबद्धता एंड्रॉइड परिवर्तन क्षितिजक प्रगति पट्टी रंग

वसंत में @Component, @Repository और @Service Annotations के बीच क्या अंतर है?

@Component , @Repository और @Service एनोटेशन को स्प्रिंग में एक दूसरे शब्दों में इस्तेमाल किया जा सकता है या क्या वे एक नोटेशन डिवाइस के रूप में कार्य करने के अलावा कोई विशेष कार्यक्षमता प्रदान करते हैं?

दूसरे शब्दों में, अगर मेरे पास एक सर्विस क्लास है और मैं @ सेवा से @Service के एनोटेशन को @Service @Component , तो क्या यह अभी भी इसी तरह व्यवहार करेगा?

या क्या एनोटेशन क्लास के व्यवहार और कार्यक्षमता को भी प्रभावित करता है?

Solutions Collecting From Web of "वसंत में @Component, @Repository और @Service Annotations के बीच क्या अंतर है?"

स्प्रिंग दस्तावेज़ीकरण से :

स्प्रिंग 2.0 और बाद में, @ रेजोजिटरी एनोटेशन किसी भी वर्ग के लिए एक मार्कर है जो एक रिपॉजिटरी के भूमिका या स्टीरियोटाइप (जिसे डेटा एक्सेस ऑब्जेक्ट या डीएओ भी कहा जाता है) को पूरा करता है। इस मार्कर के उपयोग में अपवादों का स्वचालित अनुवाद है।

स्प्रिंग 2.5 आगे की स्टीरियोटाइप एनोटेशन प्रस्तुत करता है: @Component, @Service, और @Controller @Component किसी भी स्प्रिंग-प्रबंधित घटक के लिए एक जेनेरिक स्टीरियोटाइप है @Repository, @Service, और @Controller, अधिक विशिष्ट उपयोग के मामलों के लिए @Component के विशेषज्ञ हैं, उदाहरण के लिए, क्रमशः, सेवा और प्रस्तुति परतों में क्रमशः,

इसलिए, आप अपने घटक वर्गों को @ कंप्लेंट के साथ एनोटेट कर सकते हैं, लेकिन उनके बजाय @ रपोझिटरी, सेवा, या @ नियंत्रक के साथ अपनी टिप्पणियां करके, आपकी कक्षाएं उपकरण द्वारा प्रसंस्करण या पहलुओं के साथ संबद्ध करने के लिए अधिक उपयुक्त हैं। उदाहरण के लिए, ये स्टीरियोटाइप एनोटेशन बिन्दुओं के लिए आदर्श लक्ष्य बनाते हैं।

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

 | Annotation | Meaning | +------------+-----------------------------------------------------+ | @Component | generic stereotype for any Spring-managed component | | @Repository| stereotype for persistence layer | | @Service | stereotype for service layer | | @Controller| stereotype for presentation layer (spring-mvc) | 

वे लगभग समान हैं – उनमें से सभी का अर्थ है कि वर्ग एक स्प्रिंग बीन है। @Service , @Repository और @Component एस विशेष हैं आप उनके साथ विशिष्ट कार्य करने के लिए चुन सकते हैं। उदाहरण के लिए:

  • @Controller सेम स्प्रिंग-एमवीसी द्वारा उपयोग किया जाता है
  • @Repository बीन्स दृढ़ता अपवाद अनुवाद के लिए योग्य हैं

एक और बात यह है कि आप घटकों को अलग-अलग परतों के लिए आवंटित करते हैं।

@Component है कि @Component ऑफ़र यह है कि आप इसके साथ अन्य एनोटेशन को एनोटेट कर सकते हैं, और फिर उन्हें @Service रूप में उसी तरह का उपयोग कर @Service

उदाहरण के लिए हाल ही में मैंने बनाया:

 @Component @Scope("prototype") public @interface ScheduledJob {..} 

इसलिए सभी @ScheduledJob साथ एनोटेट किए @ScheduledJob हैं जो स्प्रिंग सेम हैं और इसके अलावा क्वार्ट्ज जॉब के रूप में पंजीकृत हैं आपको सिर्फ विशिष्ट एनोटेशन को संभालते हुए कोड प्रदान करना होगा

@Component समतुल्य है

 <bean> 

@ सेवा, @ नियंत्रक, @ रिपोजिटरी = {@Component + कुछ और विशेष कार्यक्षमता}

इसका मतलब है कि सेवा, नियंत्रक और रिपॉजिटरी कार्यात्मक रूप से समान हैं।

आपके एनोटेशन का उपयोग आपके आवेदन में "परतें" को अलग करने के लिए किया जाता है,

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

अब आप पूछ सकते हैं कि उन्हें अलग क्यों करें: (मुझे लगता है कि आपको एओपी-पहलू उन्मुख प्रोग्रामिंग पता है)

मान लें कि आप केवल डीएओ परत की गतिविधि पर नज़र रखने के लिए चाहते हैं आप एक एस्पेक्ट (ए क्लास) क्लास लिखेंगे जो आपके डीएओ के प्रत्येक विधि के पहले और बाद में लॉगिंग करता है, आप एओपी का उपयोग कर सकते हैं क्योंकि आपके पास तीन अलग परतें हैं और मिश्रित नहीं हैं

तो आप डीएओ "आसपास", "पहले" या "बाद" डीएओ पद्धतियों के प्रवेश कर सकते हैं। आप ऐसा कर सकते हैं क्योंकि आपके पास पहली जगह में डीएओ था आपने जो कुछ हासिल किया है, वह चिंताओं या कार्यों का पृथक्करण है

कल्पना कीजिए कि अगर केवल एक टिप्पणी @ नियंत्रक है, तो इस घटक को डिस्पैचिंग, बिजनेस लॉजिक और डेटाबेस को सभी मिश्रित, इतना गंदे कोड तक पहुंचाएगा!

उपर्युक्त ऊपर एक बहुत ही सामान्य परिदृश्य है, यहां तीन एनोटेशन का उपयोग करने के कई और अधिक उपयोग के मामले हैं।

जैसा कि बहुत से उत्तर पहले ही बताते हैं कि इन टिप्पणियों के लिए किस प्रकार उपयोग किया जाता है, हम यहां उनमें कुछ मामूली अंतर पर ध्यान देंगे।

पहले समानता

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


@Component, @Repository, @Controller और @Service के बीच मतभेद

@Component

यह एक सामान्य प्रयोजन वाला स्टीरियोटाइप एनोटेशन है जो दर्शाता है कि वर्ग एक वसंत घटक है।

@Component के बारे में विशेष क्या है
<context:component-scan> केवल @Component स्कैन करता है और @Repository @Service , @Service और @Repository के लिए सामान्य रूप में नहीं दिखता। वे स्कैन किए गए हैं क्योंकि वे खुद @Component साथ एनोटेट किए गए हैं

बस @Service , @Service और @Repository एनोटेशन परिभाषाओं पर एक नज़र डालें:

 @Component public @interface Service { …. } 

 @Component public @interface Repository { …. } 

 @Component public @interface Controller { … } 

इस प्रकार, यह कहना गलत नहीं है कि @Service , @Service और @Repository विशेष प्रकार के @Component एनोटेशन हैं <context:component-scan> उन्हें उठाता है और उनकी निम्नलिखित कक्षाओं को बीन्स के रूप में पंजीकृत करता है, जैसे कि वे @Component साथ एनोटेट किए गए थे।

वे स्कैन किए गए हैं क्योंकि वे स्वयं को @Component एनोटेशन के साथ एनोटेट किया @Component । अगर हम अपनी स्वयं की कस्टम एनोटेशन को परिभाषित करते हैं और इसे @Component साथ एनोटेट करते हैं, तो यह <context:component-scan> साथ स्कैन भी मिल जाएगा <context:component-scan>


@Repository

यह इंगित करने के लिए है कि क्लास डेटा रिपॉजिटरी को परिभाषित करता है।

@ रिपोजिटरी के बारे में विशेष क्या है?

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

 <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/> 

यह बीन पोस्ट प्रोसेसर किसी @Repository के लिए किसी सलाहकार को जोड़ता है जो @Repository साथ एनोटेट किया @Repository ताकि किसी भी प्लेटफार्म-विशिष्ट अपवाद को पकड़ा जाए और फिर स्प्रिंग की अनचेक किए गए डेटा एक्सेस अपवादों में से एक के रूप में पुनर्स्थापित किया जाए।


@Controller

@ नियंत्रक एनोटेशन इंगित करता है कि एक विशेष वर्ग एक नियंत्रक की भूमिका निभाता है। @ @Controller एनोटेशन एनोटेटेड क्लास के लिए एक स्टीरियोटाइप के रूप में कार्य करता है, जो इसकी भूमिका का संकेत देता है।

@ नियंत्रक के बारे में विशेष क्या है?

हम इस एनोटेशन को @Service या @Repository @Service जैसे किसी भी अन्य के साथ स्विच नहीं कर सकते हैं, भले ही वे एक जैसी @Service । डिस्पैचर @ @Controller साथ एनोटेट की गई कक्षाओं को स्कैन करता है और उनके भीतर @ @RequestMapping एनोटेशन का पता लगाता है। हम @RequestMapping @Controller एनोटेटेड कक्षाओं पर केवल @RequestMapping @Controller उपयोग कर सकते हैं।


@सर्विस

@Services को व्यवसायिक तर्क और कॉल पद्धति को रिपॉज़िटरी परत में रखना है।

सेवा के बारे में विशेष क्या है?

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


और क्या?

उपरोक्त के समान, भविष्य में स्प्रिंग अपने @Repository आधार पर @Service , @Repository और @Repository @Service लिए विशेष कार्यकलापों को जोड़ना चुन सकता है। इसलिए सम्मेलन का सम्मान करना और परतों के साथ लाइन में उनका उपयोग करना हमेशा अच्छा विचार है

स्प्रिंग @Component , @Service @Component , @Service , और @Repository में स्टैरियोटाइप एनोटेशन हैं जिनका उपयोग इसके लिए किया जाता है:

@Controller: जहां आपके प्रस्तुति पृष्ठ से अनुरोध मानचित्रण किया जाता है अर्थात प्रस्तुति स्तर किसी भी अन्य फाइल में नहीं जाता है, वह सीधे @Controller वर्ग के लिए जाता है और अनुरोधित पथ को @RequestMapping एनोटेशन में @RequestMapping जो आवश्यक होने पर विधि कॉल करने से पहले लिखा गया था।

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

@Repository : यह अनुप्रयोग के स्थायित्व परत (डेटा एक्सेस परत) है जो डेटाबेस से डेटा प्राप्त करने के लिए इस्तेमाल किया जाता था। अर्थात सभी डेटाबेस संबंधित कार्यों को रिपॉजिटरी द्वारा किया जाता है

@Component – घटक स्टीरियोटाइप के साथ अपने अन्य घटकों (उदाहरण के लिए REST संसाधन वर्गों) की व्याख्या करें

यह इंगित करता है कि एक एनोटेटेड क्लास एक " घटक " है एनोटेशन-आधारित कॉन्फ़िगरेशन और क्लासपाथ स्कैनिंग का उपयोग करते समय ऐसे वर्गों को ऑटो-डिटेक्शन के लिए उम्मीदवार के रूप में माना जाता है।

अन्य वर्ग-स्तरीय एनोटेशन को एक घटक के रूप में भी पहचानने के रूप में माना जा सकता है, विशेष रूप से एक विशेष प्रकार का घटक: उदा। @ रिपज़ोटरी एनोटेशन या एस्पेक्ज की @ एपेट एनोटेशन।

यहां छवि विवरण दर्ज करें

स्प्रिंग 2.5 आगे की स्टीरियोटाइप एनोटेशन प्रस्तुत करता है: @Component, @Service और @Controller। @Component किसी भी स्प्रिंग-प्रबंधित घटक के लिए सामान्य रूढ़िवादी के रूप में कार्य करता है; जबकि, @Repository, @Service, और @Controller अधिक विशिष्ट उपयोग के मामलों (उदाहरण के लिए, दृढ़ता, सेवा, और प्रस्तुति परतों में क्रमशः) के लिए @ घटक के विशेषताओं के रूप में कार्य करता है। इसका क्या मतलब यह है कि आप अपने घटक वर्गों को @ कम्पेनेंट के साथ एनोटेट कर सकते हैं, लेकिन उनके बजाय @ रपोझिटरी, सेवा, या @ कंट्रोलर के साथ उनकी टिप्पणियां करके, आपकी कक्षाएं उपकरण द्वारा प्रसंस्करण या पहलुओं के साथ संबद्ध करने के लिए अधिक उपयुक्त हैं। उदाहरण के लिए, ये स्टीरियोटाइप एनोटेशन बिन्दुओं के लिए आदर्श लक्ष्य बनाते हैं। बेशक, यह भी संभव है कि @Repository, @Service, और @Controller स्प्रिंग फ़्रेमवर्क के भविष्य के रिलीज में अतिरिक्त सिमेंटिक्स ले सकते हैं। इस प्रकार, यदि आप अपने सेवा स्तर के लिए @ कम्पेनेंट या @ सेवा का उपयोग करने के बीच कोई फैसला कर रहे हैं, तो @ सेवा स्पष्ट रूप से बेहतर विकल्प है। इसी प्रकार, जैसा कि ऊपर बताया गया है, @ रिपोजिटरी पहले से आपकी निरंतरता परत में स्वचालित अपवाद अनुवाद के लिए मार्कर के रूप में समर्थित है।

 @Component – Indicates a auto scan component. @Repository – Indicates DAO component in the persistence layer. @Service – Indicates a Service component in the business layer. @Controller – Indicates a controller component in the presentation layer. 

संदर्भ: – http://static.springsource.org/spring/docs/3.0.0.M3/reference/html/ch04s12.html

 @Component – Indicates a auto scan component. @Repository – Indicates DAO component in the persistence layer. @Service – Indicates a Service component in the business layer. @Controller – Indicates a controller component in the presentation layer. 

आप यह देखेंगे कि सभी @Repository , @Service या @Component को @Component साथ एनोटेट किया @Component तो, क्या हम ऑटो स्कैनिंग के सभी घटकों के लिए @Component उपयोग कर सकते हैं? हां, आप कर सकते हैं, और स्प्रिंग स्वतः @ कम्पेनेंट एनोटेट के साथ अपने सभी घटकों को स्कैन करेगा।

यह ठीक काम कर रहा है, लेकिन पठनीयता के लिए कोई अच्छा अभ्यास नहीं है, आपको अपने कोड को पढ़ने में अधिक आसान बनाने के लिए एक निर्दिष्ट परत के लिए @Service @Repository , @Service या @Service @Repository घोषणा करना चाहिए।

@Service उपयोग और @Repository एनोटेशन डेटाबेस कनेक्शन के परिप्रेक्ष्य से महत्वपूर्ण हैं।

  1. अपने सभी वेब सेवा प्रकार डीबी कनेक्शन के लिए @Service सेवा का उपयोग करें
  2. अपने सभी संग्रहित @Repository डीबी कनेक्शन के लिए @Repository उपयोग करें

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

@Component, @Service और @Repository के बीच अंतर

इन रूढ़िताओं के बीच मुख्य अंतर ये है कि उनका उपयोग विभिन्न वर्गीकरण के लिए किया जाता है।

एक multitier आवेदन में, हमारे पास प्रस्तुति, सेवा, व्यवसाय, डेटा एक्सेस इत्यादि जैसे विभिन्न परतें होंगी। जब एक स्प्रिंग द्वारा ऑटो-डिटेक्शन के लिए एक क्लास का एनोटेट किया जाना है, तो हमें नीचे दिए गए संबंधित स्टीरियोटाइप का उपयोग करना चाहिए।

@Component – सामान्य और आवेदन भर में इस्तेमाल किया जा सकता है
@Service सेवा – सेवा स्तर स्तर पर एनोटेट कक्षाएं
@Repository – दृढ़ता वाले स्तर पर @Repository क्लासेस, जो डेटाबेस रिपॉजिटरी के रूप में कार्य करेगा।

यदि तकनीकी रूप से वे एक समान होने जा रहे हैं तो हमें इन्हें विभिन्न परतों के स्तर पर उपयोग करने की आवश्यकता क्यों है? सभी परतों पर उसी का उपयोग क्यों नहीं करें उदाहरण के लिए, यदि हम सभी परतों में @Service का उपयोग करते हैं, तो सभी बीन्स को तत्काल और कोई भी समस्याएं नहीं मिलेंगी। उदाहरण के लिए @Repository विचार करें, एक मामूली अंतर है

पोस्टप्रोसेसर स्वचालित रूप से सभी अपवाद अनुवादकों ( @Repository इंटरफ़ेस के कार्यान्वयन) के लिए @Repository और @Repository एनोटेशन के साथ चिह्नित सभी बीन्स की सलाह देता है ताकि खोजी अनुवादक फंसे अपवादों पर उचित अनुवाद को रोक सकें और लागू कर सकें।

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

उपरोक्त के अलावा, स्कैन-ऑटो-डिटेक्शन के @Component , @Service @ @Component , @Service @ @Component , @Service @ @Component लिए निर्भरता इंजेक्शन समान हैं।

@Repository @Service और @Controller @Component की विशेषज्ञता को उस आधार पर अधिक विशिष्ट उपयोग के लिए कार्य करता है, जो @ सेवा को @Component पर बदल सकते हैं लेकिन इस मामले में आप विशेषज्ञता खो देते हैं।

 1. **@Repository** - Automatic exception translation in your persistence layer. 2. **@Service** - It indicates that the annotated class is providing a business service to other layers within the application. 

ये सभी एनोटेशन स्टीरियो प्रकार के एनोटेशन प्रकार हैं, इन तीन टिप्पणियों के बीच का अंतर है

  • यदि हम @ कम्प्पुन्ट को जोड़ते हैं तो यह बताता है कि क्लास की भूमिका एक घटक वर्ग है, इसका मतलब यह है कि यह एक तर्क है जिसमें कोई तर्क है, लेकिन यह नहीं बताता कि क्या एक क्लास में एक विशेष व्यवसाय या दृढ़ता या नियंत्रक तर्क है ताकि हम इसका उपयोग न करें सीधे इस @ कन्टैंटेंट एनोटेशन
  • अगर हम सेवा की टिप्पणी को जोड़ते हैं तो यह बताता है कि क्लास की एक भूमिका व्यापारिक तर्क को लेकर है
  • यदि हम वर्ग के शीर्ष पर रेजोजीटरी जोड़ते हैं तो यह बताता है कि एक क्लास में दृढ़ता तर्क मौजूद है
  • यहां @ कम्पेनेंट @ सर्विस, @ रिपॉजिटरी और @ कंट्रोलर एनोटेशन के लिए एक बेस एनोटेशन है

उदाहरण के लिए

 package com.spring.anno; @Service public class TestBean { public void m1() { //business code } } package com.spring.anno; @Repository public class TestBean { public void update() { //persistence code } } 
  • जब भी हम @Service या @Repositroy या @Component एनोटेशन डिफ़ॉल्ट रूप से @Component हैं, तो @Component एनोटेशन कक्षा के शीर्ष पर अस्तित्व में है

एक multitier आवेदन में, हमारे पास प्रस्तुति, सेवा, व्यवसाय, डेटा एक्सेस इत्यादि जैसे विभिन्न परतें होंगी। जब एक स्प्रिंग द्वारा ऑटो-डिटेक्शन के लिए एक क्लास का एनोटेट किया जाना है, तो हमें नीचे दिए गए संबंधित स्टीरियोटाइप का उपयोग करना चाहिए।

  • @Component – सामान्य और आवेदन भर में इस्तेमाल किया जा सकता है
  • @ सेवा – सेवा स्तर स्तर पर एनोटेट कक्षाएं
  • @ नियंत्रक – प्रस्तुति स्तर स्तर पर एनोटेट कक्षाएं, मुख्यतः स्प्रिंग एमवीसी में इस्तेमाल की जाती हैं
  • @ रिपोजिटरी – दृढ़ता वाले स्तर पर एनोॉटेट क्लासेस, जो डेटाबेस रिपॉजिटरी के रूप में कार्य करेगा।

इन रूढ़िताओं के बीच 1.Major अंतर वे विभिन्न वर्गीकरण के लिए उपयोग किया जाता है।

2.एक multitier आवेदन में, हमारे पास प्रस्तुति, सेवा, व्यवसाय, डेटा एक्सेस इत्यादि जैसे विभिन्न परतें होंगी। जब स्प्रिंग द्वारा ऑटो-डिटेक्शन के लिए एक क्लास का एनोटेट किया जाना है, तो हमें नीचे दिए गए संबंधित स्टीरियोटाइप का उपयोग करना चाहिए।

  • @Component – सामान्य और आवेदन भर में इस्तेमाल किया जा सकता है
  • @Service सेवा – सेवा स्तर स्तर पर एनोटेट कक्षाएं
  • @ नियंत्रक – प्रस्तुति स्तर स्तर पर एनोटेट कक्षाएं, मुख्यतः स्प्रिंग एमवीसी में इस्तेमाल की जाती हैं
  • @Repository – दृढ़ता वाले स्तर पर @Repository क्लासेस, जो डेटाबेस रिपॉजिटरी के रूप में कार्य करेगा। यदि तकनीकी रूप से वे एक समान होने जा रहे हैं तो हमें इन्हें विभिन्न परतों के स्तर पर उपयोग करने की आवश्यकता क्यों है? सभी परतों पर उसी का उपयोग क्यों नहीं करें उदाहरण के लिए, यदि हम सभी परतों में @ सेवा का उपयोग करते हैं, तो सभी बीन्स को तत्काल और कोई भी समस्याएं नहीं मिलेंगी। उदाहरण के लिए रपोजिटरी का विचार करें, एक मामूली अंतर है

पोस्टप्रोसेसर स्वचालित रूप से सभी अपवाद अनुवादकों (निरंतरता एक्सप्शन ट्रांसपरेटर इंटरफ़ेस के कार्यान्वयन) के लिए देखता है और @Repository एनोटेशन के साथ चिह्नित सभी बीन्स की सलाह देता है ताकि खोजी अनुवादक फंसे अपवादों पर उचित अनुवाद को रोक सकें और लागू कर सकें।

  1. उपर्युक्त के समान, भविष्य में स्प्रिंग @Service , @Repository और @Repository उनके लेयरिंग कन्वेंशन के आधार पर मूल्य जोड़ना चुन सकते हैं। उस अतिरिक्त सुविधा के लिए, सम्मेलन का सम्मान करना और परतों के साथ लाइन में उनका उपयोग करना बेहतर होता है।
  2. उपरोक्त के अलावा, स्कैन-ऑटो-डिटेक्शन के @Component , @Service @ @Component , @Service @ @Component , @Service @ @Component लिए निर्भरता इंजेक्शन समान हैं।
  3. स्प्रिंग दस्तावेज के अनुसार: @Repository एनोटेशन किसी भी वर्ग के लिए एक मार्कर है जो एक रिपॉजिटरी (जिसे डेटा एक्सेस ऑब्जेक्ट या डीएओ के रूप में भी जाना जाता है) की भूमिका या स्टीरियोटाइप को पूरा करता है। इस मार्कर के प्रयोगों में सेक्शन 20.2.2, "अपवाद अनुवाद" में वर्णित अपवादों का स्वचालित अनुवाद है। स्प्रिंग आगे की स्टीरियोटाइप एनोटेशन प्रदान करता है: @Component, @Service, और @Controller @Component किसी भी स्प्रिंग-प्रबंधित घटक के लिए एक जेनेरिक स्टीरियोटाइप है @Repository, @Service, और @Controller, अधिक विशिष्ट उपयोग के मामलों के लिए @ क्यूपेंन्ट के pecializations हैं, उदाहरण के लिए, क्रमशः, सेवा, और प्रस्तुति परतों में क्रमशः, इसलिए, आप अपने घटक वर्गों को @ कंप्लेंट के साथ एनोटेट कर सकते हैं, लेकिन उनके बजाय @ रपोझिटरी, सेवा, या @ नियंत्रक के साथ अपनी टिप्पणियां करके, आपकी कक्षाएं उपकरण द्वारा प्रसंस्करण या पहलुओं के साथ संबद्ध करने के लिए अधिक उपयुक्त हैं। उदाहरण के लिए, ये स्टीरियोटाइप एनोटेशन बिन्दुओं के लिए आदर्श लक्ष्य बनाते हैं। यह भी संभव है कि @Repository, @Service, और @Controller स्प्रिंग फ़्रेमवर्क के भविष्य के रिलीज में अतिरिक्त शब्दों को ले सकते हैं। इस प्रकार, यदि आप अपने सेवा स्तर के लिए @ कम्पेनेंट या @ सेवा का उपयोग कर रहे हैं, तो @ सेवा स्पष्ट रूप से बेहतर विकल्प है। इसी प्रकार, जैसा कि ऊपर बताया गया है, @ रिपोजिटरी पहले से आपकी निरंतरता परत में स्वचालित अपवाद अनुवाद के लिए मार्कर के रूप में समर्थित है।

वसंत @ कम्पेनेंट, @सेवा, @ रिपोजिटरी और @कंट्रोलर एनोटेशन स्प्रिंग फ्रेमवर्क में क्लासपाथ स्कैन का उपयोग करके स्वचालित बीन डिटेक्शन के लिए उपयोग किया जाता है।

@Component एक सामान्य टिप्पणी है @ सेवा का अंतर, @ रिपोजिटरी @ कंटेंट के साथ नियंत्रक, वे @ कॉम्पोनेंट के विशेष मामले हैं और विशेष प्रयोजनों के लिए उपयोग किए जाते हैं अंतर केवल वर्गीकरण ही है

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

स्प्रिंग चार अलग-अलग प्रकार के ऑटो घटक स्कैन एनोटेशन प्रदान करता है, वे @Component , @Service , @Repository और @Repository । तकनीकी तौर पर, उनके बीच कोई अंतर नहीं है, लेकिन प्रत्येक ऑटो घटक स्कैन एनोटेशन का उपयोग विशेष प्रयोजन के लिए और परिभाषित परत में किया जाना चाहिए।

@Component : यह एक बुनियादी ऑटो घटक स्कैन एनोटेशन है, यह इंगित करता है कि एनोटेटेड श्रेणी एक ऑटो स्कैन घटक है।

@Controller नियंत्रक: एनोटेड वर्ग इंगित करता है कि यह एक नियंत्रक घटकों है, और मुख्य रूप से प्रस्तुति स्तर पर प्रयोग किया जाता है।

@Service : यह इंगित करता है कि एनोटेटेड क्लास व्यवसाय स्तर में एक सेवा घटक है।

@Repository : आपको इस एनोटेशन का उपयोग दृढ़ता परत में करने की आवश्यकता है, यह डेटाबेस रिपॉजिटरी जैसी काम करता है।

किसी भी व्यक्ति को अपने वर्ग की टिप्पणी के दौरान @ @Component का अधिक विशिष्ट रूप चुनना चाहिए क्योंकि इस टिप्पणी में आगे चलने वाला विशिष्ट व्यवहार हो सकता है।

स्प्रिंग 4 में, नवीनतम संस्करण:

@Repository एनोटेशन किसी भी वर्ग के लिए एक मार्कर है जो किसी रिपॉजिटरी की भूमिका या स्टीरियोटाइप को पूरा करता है (जिसे डेटा एक्सेस ऑब्जेक्ट या डीएओ के रूप में भी जाना जाता है)। इस मार्कर के प्रयोगों में सेक्शन 20.2.2, "अपवाद अनुवाद" में वर्णित अपवादों का स्वचालित अनुवाद है।

स्प्रिंग आगे की स्टीरियोटाइप एनोटेशन प्रदान करता है: @Component, @Service, और @Controller @Component किसी भी स्प्रिंग-प्रबंधित घटक के लिए एक जेनेरिक स्टीरियोटाइप है @Repository, @Service, और @Controller, अधिक विशिष्ट उपयोग के मामलों के लिए @Component के विशेषज्ञ हैं, उदाहरण के लिए, क्रमशः, सेवा और प्रस्तुति परतों में क्रमशः, इसलिए, आप अपने घटक वर्गों को @ कंप्लेंट के साथ एनोटेट कर सकते हैं, लेकिन उनके बजाय @ रपोझिटरी, सेवा, या @ नियंत्रक के साथ अपनी टिप्पणियां करके, आपकी कक्षाएं उपकरण द्वारा प्रसंस्करण या पहलुओं के साथ संबद्ध करने के लिए अधिक उपयुक्त हैं। उदाहरण के लिए, ये स्टीरियोटाइप एनोटेशन बिन्दुओं के लिए आदर्श लक्ष्य बनाते हैं। यह भी संभव है कि @Repository, @Service, और @Controller स्प्रिंग फ़्रेमवर्क के भविष्य के रिलीज में अतिरिक्त शब्दों को ले सकते हैं। इस प्रकार, यदि आप अपने सेवा स्तर के लिए @ कम्पेनेंट या @ सेवा का उपयोग कर रहे हैं, तो @ सेवा स्पष्ट रूप से बेहतर विकल्प है। इसी प्रकार, जैसा कि ऊपर बताया गया है, @ रिपोजिटरी पहले से आपकी निरंतरता परत में स्वचालित अपवाद अनुवाद के लिए मार्कर के रूप में समर्थित है।

यहां तक ​​कि अगर हम @ कम्पेनेंट या @ रिपोजिटरी या @ सेवा विनिमय करते हैं

यह वही व्यवहार करेगा, लेकिन एक पहलू यह है कि अगर हम घटक या @ सेवा का उपयोग करते हैं तो वे रिपॉजिटरी के बजाय डीएओ से संबंधित कुछ विशिष्ट अपवादों को पकड़ नहीं पाएंगे

हम इसका जवाब जावा मानक के अनुसार कर सकते हैं

JSR-330 जिक्र करते हुए, जो अब वसंत द्वारा समर्थित है, आप केवल बीन को परिभाषित करने के लिए @Named=@Component @Named (कुछ कैसे @Named=@Component ) का उपयोग कर सकते हैं। इसलिए इस मानक के अनुसार ऐसा लगता है कि स्टीरियो प्रकार ( @Repository , @Service @Repository , @Service ) को परिभाषित करने के लिए श्रेणियों की बीन्स में कोई फायदा नहीं है।

लेकिन वसंत इन रूढ़िओ को परिभाषित करते हैं

  1. मदद डेवलपर्स सक्षम के लिए एक बेहतर श्रेणी परिभाषित। यह श्रेणीकरण कुछ मामलों में सहायक हो सकता है। (उदाहरण के लिए जब आप aspect oriented उपयोग कर रहे हैं, ये point cuts लिए अच्छा उम्मीदवार हो सकता है)
  2. वर्तमान में केवल @Repository एनोटेशन आपकी सेम में कुछ कार्यक्षमता जोड़ देगा (आपके बीन दृढ़ता परत में कुछ स्वचालित अपवाद अनुवाद)
  3. यदि आप वसंत एमवीसी का प्रयोग कर रहे हैं, तो @RequestMapping को केवल उन कक्षाओं में जोड़ा जा सकता है, जो @Controller द्वारा एनोटेट किए जाते हैं

@ घटक, @ सेवा, @ नियंत्रक, @ रिपॉजिटरी के बीच कोई अंतर नहीं है। @Component, हमारे एमवीसी के घटक का प्रतिनिधित्व करने के लिए जेनेरिक एनोटेशन है। लेकिन हमारे एमवीसी अनुप्रयोग के हिस्से के रूप में कई घटक होंगे जैसे सर्विस लेयर घटकों, दृढ़ता परत घटकों और प्रस्तुति परत घटकों। इसलिए उन्हें अंतर करने के लिए वसंत लोग ने अन्य तीन टिप्पणियां भी दी हैं।

दृढ़ता परत घटकों का प्रतिनिधित्व करने के लिए: @Repository

सेवा स्तर घटकों का प्रतिनिधित्व करने के लिए: @ सेवा

प्रस्तुति परत घटकों का प्रतिनिधित्व करने के लिए: @ नियंत्रक

या फिर आप उन सभी के लिए @Component का उपयोग कर सकते हैं।

तकनीकी रूप से @ नियंत्रक, @ सेवा, रेजोजीटरी सभी समान हैं वे सभी @Components फैलता है

वसंत स्रोत कोड से:

यह इंगित करता है कि एक एनोटेटेड क्लास एक "घटक" है एनोटेशन-आधारित कॉन्फ़िगरेशन और क्लासपाथ स्कैनिंग का उपयोग करते समय ऐसे वर्गों को ऑटो-डिटेक्शन के लिए उम्मीदवार के रूप में माना जाता है।

हम प्रत्येक और हर बीन्स के लिए सीधे @Component का उपयोग कर सकते हैं, लेकिन बड़े आवेदन की बेहतर समझ और रखरखाव के लिए हम @ नियंत्रक, सेवा, @ रेजोजीटरी का उपयोग करते हैं।

प्रत्येक एनोटेशन का उद्देश्य:

1) कंट्रोलर -> इसके साथ एनोटेट किए गए क्लासेस, क्लाइंट साइड से अनुरोध प्राप्त करना है। पहला अनुरोध डिस्पैचर सर्विसलेट के पास आता है, जहां से वह अनुरोध को @RequestMapping एनोटेशन के मूल्य का उपयोग करके विशेष नियंत्रक के पास भेजता है।

2) @ सेवा -> इसके साथ एनोटेट किए गए क्लासेस, डेटा को हेरफेर करना है, जो हमें ग्राहक से प्राप्त होता है या डेटाबेस से प्राप्त होता है। डेटा के साथ सभी हेरफेर इस परत में किया जाना चाहिए।

3) @ रिपोजिटरी -> इसके साथ एनोटेट किए गए क्लासेस, डेटाबेस के साथ जुड़ने के उद्देश्य हैं। इसे डीएओ (डेटा एक्सेस ऑब्जेक्ट) परत के रूप में भी माना जा सकता है यह परत सीआरयूडी (निर्माण, पुनः प्राप्त, अपडेट, हटाएं) के संचालन के लिए ही सीमित होना चाहिए। अगर किसी भी हेर-फेर की आवश्यकता है, तो डाटा को सेवा परत पर वापस भेजना चाहिए।

यदि हम उनके स्थान का आदान-प्रदान करते हैं (@ नियंत्रक के स्थान पर @ रिपोजिटरी का उपयोग करें), हमारा आवेदन ठीक काम करेगा।

The main purpose of using three different @annotations is to provide better Modularity to the Enterprise application.

A @Service to quote spring documentation,

Indicates that an annotated class is a "Service", originally defined by Domain-Driven Design (Evans, 2003) as "an operation offered as an interface that stands alone in the model, with no encapsulated state." May also indicate that a class is a "Business Service Facade" (in the Core J2EE patterns sense), or something similar. This annotation is a general-purpose stereotype and individual teams may narrow their semantics and use as appropriate.

If you look at domain driven design by eric evans,

A SERVICE is an operation offered as an interface that stands alone in the model, without encapsulating state, as ENTITIES and VALUE OBJECTS do. SERVICES are a common pattern in technical frameworks, but they can also apply in the domain layer. The name service emphasizes the relationship with other objects. Unlike ENTITIES and VALUE OBJECTS, it is defined purely in terms of what it can do for a client. A SERVICE tends to be named for an activity, rather than an entity—a verb rather than a noun. A SERVICE can still have an abstract, intentional definition; it just has a different flavor than the definition of an object. A SERVICE should still have a defined responsibility, and that responsibility and the interface fulfilling it should be defined as part of the domain model. Operation names should come from the UBIQUITOUS LANGUAGE or be introduced into it. Parameters and results should be domain objects. SERVICES should be used judiciously and not allowed to strip the ENTITIES and VALUE OBJECTS of all their behavior. But when an operation is actually an important domain concept, a SERVICE forms a natural part of a MODEL-DRIVEN DESIGN. Declared in the model as a SERVICE, rather than as a phony object that doesn't actually represent anything, the standalone operation will not mislead anyone.

and a Repository as per Eric Evans,

A REPOSITORY represents all objects of a certain type as a conceptual set (usually emulated). It acts like a collection, except with more elaborate querying capability. Objects of the appropriate type are added and removed, and the machinery behind the REPOSITORY inserts them or deletes them from the database. This definition gathers a cohesive set of responsibilities for providing access to the roots of AGGREGATES from early life cycle through the end.

@Component is the top level generic annotation which makes the annotated bean to be scanned and available in the DI container

@Repository is specialized annotation and it brings the feature of converting all the unchecked exceptions from the DAO classes

@Service is specialized annotation. it do not bring any new feature as of now but it clarifies the intent of the bean

@Controller is specialized annotation which makes the bean MVC aware and allows the use of further annotation like @RequestMapping and all such

Here are more details

Annotate other components with @Component, for example REST Resource classes.

 @Component public class AdressComp{ ....... ...//some code here } 

@Component is a generic stereotype for any Spring managed component.

@Controller, @Service and @Repository are Specializations of @Component for specific use cases.

@Component in Spring

"Component Specialization"

Refer this Spring Annotations

@Component : you annotate a class @Component, it tells hibernate that it is a Bean.

@Repository : you annotate a class @Repository, it tells hibernate it is a DAO class and treat it as DAO class. Means it makes the unchecked exceptions (thrown from DAO methods) eligible for translation into Spring DataAccessException.

@Service : This tells hibernate it is a Service class where you will have @Transactional etc Service layer annotations so hibernate treats it as a Service component.

Plus @Service is advance of @Component. Assume the bean class name is CustomerService, since you did not choose XML bean configuration way so you annotated the bean with @Component to indicate it as a Bean. So while getting the bean object CustomerService cust = (CustomerService)context.getBean("customerService"); By default, Spring will lower case the first character of the component – from 'CustomerService' to 'customerService'. And you can retrieve this component with name 'customerService'. But if you use @Service annotation for the bean class you can provide a specific bean name by

 @Service("AAA") public class CustomerService{ 

and you can get the bean object by

 CustomerService cust = (CustomerService)context.getBean("AAA");