maven 2 - मैवेन में निर्भरता प्रबंधन और निर्भरताओं के बीच मतभेद




maven-2 dependencies (7)

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>

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


अभी भी एक चीज है जो मेरी राय में पर्याप्त नहीं है, और यह अवांछित विरासत है

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

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

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

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

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

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

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

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

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


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

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

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


मूल पीओएम में, <dependencies> और <dependencyManagement> बीच मुख्य अंतर यह है:

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

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


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

मेवेन साइट पर 'ए', 'बी', 'सी' कचरा पढ़ने और उलझन में आने के बाद, मैंने उनका उदाहरण दोबारा लिखा। तो यदि आपके पास 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>

यदि आपके पास सभी बाल मॉड्यूल में परिभाषित जुनीट परीक्षण के मामले हैं और आप एसटीएस या ग्रहण का उपयोग कर रहे हैं तो केवल ग्रहण परिभाषित करने से परीक्षण मामलों के लिए त्रुटियां मिलेंगी।

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


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


<depedencies> Depedencies <depedencies> / <dependencyManagement> मैवेन के साथ टैग के बीच मतभेदों के कुछ जवाब हैं।

हालांकि, संक्षेप में नीचे दिए गए कुछ बिंदु नीचे दिए गए हैं:

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




pom.xml