मावेन में निर्भरता प्रबंधन और निर्भरता के बीच अंतर

Question

बीच क्या अंतर है dependencyManagementऔर dependencies? मैंने अपाचे मावेन वेब साइट पर डॉक्स देखे हैं। ऐसा लगता है कि इसके तहत परिभाषित एक निर्भरता dependencyManagementको संस्करण को निर्दिष्ट किए बिना अपने बाल मॉड्यूल में उपयोग किया जा सकता है।

उदाहरण के लिए:

एक मूल परियोजना (प्रो-पार) के तहत एक निर्भरता को परिभाषित करता है dependencyManagement:

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8</version>
    </dependency>
 </dependencies>
</dependencyManagement>

फिर प्रो-बराबर के बच्चे में, मैं जूनियर का उपयोग कर सकता हूं:

  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
    </dependency>
 </dependencies>

हालांकि, मुझे आश्चर्य है कि क्या पेरेंट पोम में जूनिट को परिभाषित करना आवश्यक है? इसे सीधे आवश्यक मॉड्यूल में परिभाषित क्यों नहीं किया गया?

Answer 1

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

का एक और अत्यंत महत्वपूर्ण उपयोग मामला dependencyManagementपारगमन निर्भरता में प्रयुक्त कलाकृतियों के संस्करणों का नियंत्रण है। बिना उदाहरण के समझाना कठिन है। सौभाग्य से, यह प्रलेखन में सचित्र है।

Comments

तो, इसके लिए चाइल्ड प्रोजेक्ट पोम की निर्भरता घोषित करने की आवश्यकता है, भले ही वे पेरेंट प्रोजेक्ट के पोम में <निर्भरता प्रबंधन> खंड में घोषित किए गए हों? क्या आश्रितों की विरासत के कुछ प्रकार बनाना संभव है?

— जॉनी-बी-गॉड

हां, आपको अभी भी बच्चे पोम में उन्हें परिभाषित करने की जरूरत है कि आप उनका उपयोग कर रहे हैं। वे वास्तव में बाल परियोजनाओं में सिर्फ इसलिए शामिल नहीं हैं क्योंकि वे <dependencyManagement>मूल POM में हैं। <dependencyManagement>यदि आप इसका उपयोग करने का निर्णय लेते हैं, तो प्रत्येक निर्भरता के लिए संस्करण, दायरे और बहिष्करण के प्रबंधन को केंद्रीयकृत निर्भरता में संलग्न करना। निर्भरता प्रबंधन के लिए मावेन की मार्गदर्शिका सभी विवरणों में मिलती है।

— hotshot309

दूसरा पैराग्राफ ( dependencyManagementसकर्मक निर्भरता को भी नियंत्रित करता है) केवल तभी सही होता है जब निर्भरता स्पष्ट रूप से निर्धारित की जाती है: stackoverflow.com/questions/28312975/…

— रॉबर्ट मेट्ज़गर

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

— рüффп

Answer 2

मैं इस प्रश्न के लिए देर से आता हूं, लेकिन मुझे लगता है कि यह स्वीकार किए गए की तुलना में एक स्पष्ट प्रतिक्रिया के लायक है (जो सही है, लेकिन वास्तविक महत्वपूर्ण भाग पर जोर नहीं देता है, जिसे आपको खुद को कम करने की आवश्यकता है)।

मूल POM में, इस <dependencies>और के बीच मुख्य अंतर <dependencyManagement>है:

<dependencies>अनुभाग में निर्दिष्ट कलाकृतियाँ ALWAYS को बाल मॉड्यूल (नों) की निर्भरता के रूप में शामिल किया जाएगा।

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

Comments

लेकिन यह भी एक ओवरहेड का एक सा, उपयोग कर रहा है <dependencyManagement>से अधिक <dependencies>जड़ में .pom? बच्चा pomबहुत छोटा हो सकता है।

— जनेऊ कुहर

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

— 16

@JanezKuhar यह मेरे लिए समझ में आता है कि यदि आप चाइल्ड मॉड्यूल में एक निर्भरता निर्दिष्ट करते हैं, तो यह अभिभावक में किसी को भी पीछे छोड़ देगा, लेकिन मैं मानता हूं कि मुझे याद नहीं है। मुझे मौका मिलने पर मावेन डॉक्स की जांच करनी होगी। हालाँकि यह आसान हो सकता है कि एक साधारण अभिभावक-बच्चे के प्रोजेक्ट को सेटअप करें और सत्यापित करें :)

— dcoder

एक सरल अवधारणा के लिए अच्छी व्याख्या - मावेन के लिए अपने स्वयं के उपकरण को आसानी से समझाने के लिए यह इतना कठिन क्यों प्रतीत होता है?

— jimmy_terra

मुझे Artifacts specified in the <dependencies> section will ALWAYS be included as a dependency of the child module(s)लगता है कि वे माता-पिता में भी शामिल हैं। लगता है कि यह बच्चों के लिए निर्भरता निर्धारित करने के लिए संभव नहीं है, लेकिन माता-पिता के लिए नहीं।

— कैडियस

Answer 3

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

मावेन साइट पर 'ए', 'बी', 'सी' कचरा के सभी पढ़ने और भ्रमित होने के बाद, मैंने उनके उदाहरण को फिर से लिखा। इसलिए यदि आपके पास 2 परियोजनाएं (proj1 और proj2) हैं जो एक सामान्य निर्भरता (बीटाशेयर) को साझा करते हैं तो आप उस निर्भरता को मूल पोम तक ले जा सकते हैं। जब आप इस पर होते हैं, तो आप किसी अन्य निर्भरता (अल्फा और चार्ली) को भी आगे बढ़ा सकते हैं, लेकिन केवल अगर यह आपकी परियोजना के लिए समझ में आता है। तो पूर्व वाक्यों में उल्लिखित स्थिति के लिए, यहाँ मूल पोम में निर्भरता प्रबंधन के साथ समाधान है:

<!-- ParentProj pom -->
<project>
  <dependencyManagement>
    <dependencies>
      <dependency> <!-- not much benefit defining alpha here, as we only use in 1 child, so optional -->
        <groupId>alpha</groupId>
        <artifactId>alpha</artifactId>
        <version>1.0</version>
        <exclusions>
          <exclusion>
            <groupId>zebra</groupId>
            <artifactId>zebra</artifactId>
          </exclusion>
        </exclusions>
      </dependency>
      <dependency>
        <groupId>charlie</groupId> <!-- not much benefit defining charlie here, so optional -->
        <artifactId>charlie</artifactId>
        <version>1.0</version>
        <type>war</type>
        <scope>runtime</scope>
      </dependency>
      <dependency> <!-- defining betaShared here makes a lot of sense -->
        <groupId>betaShared</groupId>
        <artifactId>betaShared</artifactId>
        <version>1.0</version>
        <type>bar</type>
        <scope>runtime</scope>
      </dependency>
    </dependencies>
  </dependencyManagement>
</project>

<!-- Child Proj1 pom -->
<project>
  <dependencies>
    <dependency>
      <groupId>alpha</groupId>
      <artifactId>alpha</artifactId>  <!-- jar type IS DEFAULT, so no need to specify in child projects -->
    </dependency>
    <dependency>
      <groupId>betaShared</groupId>
      <artifactId>betaShared</artifactId>
      <type>bar</type> <!-- This is not a jar dependency, so we must specify type. -->
    </dependency>
  </dependencies>
</project>

<!-- Child Proj2 -->
<project>
  <dependencies>
    <dependency>
      <groupId>charlie</groupId>
      <artifactId>charlie</artifactId>
      <type>war</type> <!-- This is not a jar dependency, so we must specify type. -->
    </dependency>
    <dependency>
      <groupId>betaShared</groupId> 
      <artifactId>betaShared</artifactId> 
      <type>bar</type> <!-- This is not a jar dependency, so we must specify type. -->
    </dependency>
  </dependencies>
</project>

Comments

कुछ हद तक ऑफ-टॉपिक प्रश्न: निर्भरता प्रकार "बार" का क्या अर्थ है? मैंने मावेन प्रलेखन पर एक उदाहरण पोम में देखा, लेकिन परिभाषा नहीं मिल सकी। मैंने मान लिया कि यह "युद्ध" या "जार" का एक टाइपो था, लेकिन मैं इसे आपके जैसे अन्य उदाहरणों में देखता हूं।

— कोई नहीं

कोई नहीं है - इसलिए यह सिर्फ एक और संग्रह प्रकार के लिए एक प्लेसहोल्डर है। जैसे 'फू' का उपयोग करना। या इसका उपयोग किया जा सकता है यदि कोई व्यक्ति एक्सटेंशन 'बार' के साथ एक कस्टम प्रकार बनाता है। और वहाँ बहुत अस्पष्ट संग्रह प्रकार हैं। जैसे सर, जो कि jboss सर्विस आर्काइव है।

— मैट

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

— डेविड ए। ग्रे

खैर, मैं डिपेंडेंसी मैनजमेंट नोड को छोड़ने वाला था, जब तक मेरे साथ ऐसा नहीं हुआ कि इसे छोड़ने से मुझे किसी भी बच्चे POM के लिए एक न्यूनतम संस्करण स्थापित करने की अनुमति मिलती है जो अप्रत्यक्ष रूप से निर्भरता के पेड़ में अपना रास्ता तलाशते हैं। एक उदाहरण के रूप में, javax.cache.cache-apI का पीछा करते हुए, मैंने एक काफी नया संस्करण 1.0.0 (बनाम 0.3.0) खोजा, जिसका उपयोग पूरे समय भी किया जा सकता है।

— डेविड ए। ग्रे

यह व्याख्या pefect है।

— स्मार्ट कोडर

Answer 4

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

यह उपयोगी हो जाता है जब आपके पास कई गुण होते हैं जो आप कई बच्चों की परियोजनाओं के तहत वापस नहीं लेना चाहते हैं।

अंत में, dependencyManagementकई प्रोजेक्ट्स में उपयोग करने के लिए एक कलाकृतियों के मानक संस्करण को परिभाषित करने के लिए उपयोग किया जा सकता है।

Comments

तो, निर्भरता विरासत में नहीं मिली है? वैसे भी चाइल्ड प्रोजेक्ट के पॉम में घोषित किए जाने की आवश्यकता है?

— जॉनी-बी-गोड

हां, आपको उन्हें बच्चों की परियोजनाओं में वैसे भी घोषित करने की आवश्यकता है, लेकिन एक संस्करण को निर्दिष्ट किए बिना।

— पावेल वलसोव

जब आप पेरेंट-चाइल्ड रिलेशनशिप वाले कई जावा प्रोजेक्ट्स में संस्करणों का शासन चाहते हैं तो यह परिदृश्य उपयोगी होता है।

— अनुज कुमार

Answer 5

मेरी राय में अभी भी एक बात पर्याप्त रूप से उजागर नहीं हुई है, और वह है अनचाहे उत्तराधिकार ।

यहाँ एक वृद्धिशील उदाहरण है:

मैं अपने parentपोम में घोषणा करता हूं :

<dependencies>
        <dependency>
            <groupId>com.google.guava</groupId>
            <artifactId>guava</artifactId>
            <version>19.0</version>
        </dependency>
</dependencies>

बूम! मैं अपने में यह है Child A, Child Bऔर Child Cमॉड्यूल:

• इम्प्लीसिल्टी को बच्चे के पोम्स द्वारा विरासत में मिला है
• प्रबंधन के लिए एक एकल स्थान
• चाइल्ड पॉम में किसी चीज को दोबारा इस्तेमाल करने की जरूरत नहीं है
• मैं अभी भी redelcare और ओवरराइड करने के लिए कर सकते हैं version 18.0एक में Child Bअगर मैं करना चाहता हूँ।

लेकिन क्या होगा अगर मैं अंत में Child Cऔर न ही भविष्य Child Dऔर Child Eमॉड्यूल में अमरूद की जरूरत है ?

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

यह वह जगह है जहाँ <dependencyManagement>खेलने में आता है। जब आप इसे अपने पैरेंट पोम में जोड़ते हैं, तो आपके सभी बच्चे मॉड्यूल को देखकर रोक लेते हैं । और इस प्रकार आपको प्रत्येक व्यक्तिगत मॉड्यूल में जाने के लिए मजबूर किया जाता है, जिसे इसकी आवश्यकता नहीं है और इसे फिर से घोषित करें ( Child Aऔर Child B, हालांकि संस्करण के बिना)।

और, जाहिर है, आप ऐसा नहीं करते हैं Child C, और इस प्रकार आपका मॉड्यूल दुबला बना रहता है।

Comments

क्या माता-पिता पोम परियोजना के लिए निर्भरता प्रबंधन व्यवस्था में उल्लिखित निर्भरताएँ समाप्त हो जाएंगी?

— जसप्रीत जॉली

क्या आप सुनिश्चित हैं कि यदि हम <dependencyManagement>मूल पोम में उपयोग करते हैं तो डिफ़ॉल्ट निर्भरता के कारण बच्चे को पोम्स में विरासत में नहीं मिलेगा? चूँकि doc में: maven.apache.org/guides/introduction/… जबकि इसका दूसरा उपयोग बताते हुए <dependencyManagement>ऐसा लगता है कि यह डिफ़ॉल्ट रूप से विरासत में मिलेगा। एक पंक्ति में वे कह रहे हैं कि: "जब मावेन को प्रोजेक्ट बी पर चलाया जाता है, तो कलाकृतियों के संस्करण 1.0 में ए, बी, सी और डी का उपयोग किया जाएगा, भले ही उनके पोम में निर्दिष्ट संस्करण की परवाह किए बिना" बी "का उपयोग न किया गया हो परियोजना B

— चिराग सोनी

इसे स्वयं आज़माएँ

— जून्स

Answer 6

मावेन के साथ <depedencies>और <dependencyManagement>टैग के बीच मतभेदों को रेखांकित करने वाले कुछ उत्तर हैं ।

हालाँकि, संक्षिप्त रूप में नीचे कुछ बिंदु विस्तृत हैं:

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

Answer 7

माफ़ करना मुझे पार्टी में बहुत देर हो गई है।

मुझे का उपयोग कर अंतर को समझाने की कोशिश करते हैं mvn dependency:treeआदेश

नीचे दिए गए उदाहरण पर विचार करें

जनक पोम - मेरी परियोजना

<modules>
    <module>app</module>
    <module>data</module>
</modules>

<dependencies>
    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>19.0</version>
    </dependency>
</dependencies>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>
    </dependencies>
</dependencyManagement>

बाल पोम - डेटा मॉड्यूल

<dependencies>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
</dependencies>

बाल पोम - ऐप मॉड्यूल (कोई अतिरिक्त निर्भरता नहीं है, इसलिए निर्भरता को खाली छोड़ दें)

 <dependencies>
</dependencies>

रनिंग mvn dependency:treeकमांड पर, हमें निम्नलिखित परिणाम मिलते हैं

Scanning for projects...
------------------------------------------------------------------------
Reactor Build Order:

MyProject
app
data

------------------------------------------------------------------------
Building MyProject 1.0-SNAPSHOT
------------------------------------------------------------------------

--- maven-dependency-plugin:2.8:tree (default-cli) @ MyProject ---
com.iamvickyav:MyProject:pom:1.0-SNAPSHOT
\- com.google.guava:guava:jar:19.0:compile

------------------------------------------------------------------------
Building app 1.0-SNAPSHOT
------------------------------------------------------------------------

--- maven-dependency-plugin:2.8:tree (default-cli) @ app ---
com.iamvickyav:app:jar:1.0-SNAPSHOT
\- com.google.guava:guava:jar:19.0:compile

------------------------------------------------------------------------
Building data 1.0-SNAPSHOT
------------------------------------------------------------------------

--- maven-dependency-plugin:2.8:tree (default-cli) @ data ---
com.iamvickyav:data:jar:1.0-SNAPSHOT
+- org.apache.commons:commons-lang3:jar:3.9:compile
\- com.google.guava:guava:jar:19.0:compile

Google अमरूद को प्रत्येक मॉड्यूल (माता-पिता सहित) में निर्भरता के रूप में सूचीबद्ध किया गया है, जबकि अपाचे कॉमन्स को केवल डेटा मॉड्यूल (पैरेंट मॉड्यूल में भी नहीं) पर निर्भरता के रूप में सूचीबद्ध किया गया है

Answer 8

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

Comments

मेरा मानना ​​है कि यह कथन सही नहीं हो सकता है। मावेन के डिपेंडेंसी मैनेजमेंट उदाहरण (# 2) में, वे कहते हैं कि एक संस्करण के साथ माता-पिता के पोम में परिभाषित निर्भरताएं, बच्चे के पोम में निर्दिष्ट संस्करण को ओवरराइड करेंगी: "जब मावेन प्रोजेक्ट पर चलाया जाता है कलाकृतियों के बी संस्करण 1.0, बी, सी , और घ का उपयोग उनके पोम में निर्दिष्ट संस्करण की परवाह किए बिना किया जाएगा। "

— देवदंके २५'१५ को १

@devdanke कम से कम, ग्रहण m2e मुद्दों एक चेतावनी: संस्करण में कामयाब अधिभावी ... के लिए ... ।

— गेरोल्डब्रोज़र मोनिका

Answer 9

मूल POM में, इस <dependencies>और के बीच मुख्य अंतर <dependencyManagement>है:

<dependencies>अनुभाग में निर्दिष्ट कलाकृतियाँ ALWAYS को बाल मॉड्यूल (नों) की निर्भरता के रूप में शामिल किया जाएगा।

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

Answer 10

बस मेरे अपने शब्दों में, आपकी parent-projectसहायता आपको 2 तरह की निर्भरता प्रदान करती है:

• अंतर्निहित निर्भरताएँ : <dependencies>आपके parent-projectद्वारा अनुभाग में परिभाषित सभी निर्भरताएँ सभी को विरासत में मिली हैंchild-projects
• स्पष्ट निर्भरता : आप का चयन करने के लिए अनुमति देता है, निर्भरता अपने में लागू करने के लिए child-projects। इस प्रकार, आप <dependencyManagement>अपने अलग-अलग उपयोग करने जा रहे सभी निर्भरता को घोषित करने के लिए, अनुभाग का उपयोग करते हैं child-projects। सबसे महत्वपूर्ण बात यह है कि, इस खंड में, आप इसे परिभाषित करते हैं <version>ताकि आपको इसे फिर से अपने में घोषित न करना पड़े child-project।

<dependencyManagement>देखने की मेरी बात में (मुझे ठीक कर लें मैं गलत हूँ) बस आप अपनी निर्भरता के संस्करण को केंद्रीकृत की मदद से उपयोगी है। यह एक तरह की सहायक सुविधा की तरह है।

Answer 11

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

Answer 12

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

dependencyManagement

"इस से प्राप्त होने वाली परियोजनाओं के लिए डिफ़ॉल्ट निर्भरता की जानकारी। इस अनुभाग में निर्भरताएं तुरंत हल नहीं की जाती हैं। इसके बजाय, जब एक पीओएम इस से प्राप्त होता है, तो एक मिलान ग्रुपआईडी और आर्टिफ़िशियड द्वारा वर्णित एक निर्भरता की घोषणा करता है, इस अनुभाग में संस्करण और अन्य मान। उस निर्भरता के लिए उपयोग किया जाता है यदि वे पहले से निर्दिष्ट नहीं थे। " [ https://maven.apache.org/ref/3.6.1/maven-model/maven.html ]

इसे अलग पृष्ठ पर उपलब्ध कुछ और जानकारी के साथ पढ़ा जाना चाहिए:

“.. एक निर्भरता प्रबंधन खंड के खिलाफ एक निर्भरता संदर्भ से मेल खाने के लिए जानकारी का न्यूनतम सेट वास्तव में {groupId, विरूपण साक्ष्य, प्रकार, वर्गीकरण} है। कई मामलों में, ये निर्भरताएं जार कलाकृतियों का उल्लेख करेंगी जिनमें कोई क्लासिफायरियर नहीं है। यह हमें {groupId, विरूपण साक्ष्य} के लिए निर्धारित पहचान को शॉर्टहैंड करने की अनुमति देता है, क्योंकि प्रकार फ़ील्ड के लिए डिफ़ॉल्ट जार है, और डिफ़ॉल्ट क्लासिफायरबल अशक्त है। " [ https://maven.apache.org/guides/introduction/introduction-to-d dependency-mechanism.html ]

इस प्रकार, एक निर्भरता तत्व के सभी उप-तत्व (गुंजाइश, बहिष्करण आदि) - GroupId, विरूपण साक्ष्य, प्रकार, क्लासिफायरियर के अलावा, न केवल संस्करण - बिंदु पर लॉकडाउन / डिफ़ॉल्ट के लिए उपलब्ध हैं (और इस प्रकार विरासत में मिला है) इसके बाद) आप एक निर्भरता के भीतर निर्भरता निर्दिष्ट करते हैं। यदि आप प्रकार और क्लासिफायर उप-तत्वों के साथ एक निर्भरता निर्दिष्ट करते हैं (सभी उप-तत्वों की जांच करने के लिए पहला-उद्धृत वेबपृष्ठ देखें) क्रमशः जार और शून्य नहीं है, तो आपको {groupId, विरूपण साक्ष्य, वर्गीकरण, प्रकार} की आवश्यकता होगी संदर्भ (संकल्प) कि निर्भरता प्रबंधन तत्व से उत्पन्न विरासत में किसी भी बिंदु पर निर्भरता। यदि आप क्लासिफायरफ़ायर और प्रकार (जार और नल) के लिए चूक को ओवरराइड करने का इरादा नहीं रखते हैं, तो {groupId, विरूपण साक्ष्य} पर्याप्त होगा। तो डिफ़ॉल्ट उस परिभाषा में एक अच्छा कीवर्ड है; कोई भी उप-तत्व (s), ग्रुपआईड के अलावा,

तो, निर्भरता प्रबंधन के बाहर किसी भी निर्भरता तत्व, चाहे कुछ निर्भरता प्रबंधन तत्व के संदर्भ के रूप में या एक स्टैंडअलोन के रूप में तुरंत हल किया जाता है (यानी स्थानीय रिपॉजिटरी में स्थापित और क्लासपैथ के लिए उपलब्ध)।