ความแตกต่างระหว่างการจัดการการพึ่งพาและการพึ่งพาใน Maven

ความแตกต่างระหว่างdependencyManagementและdependenciesคืออะไร? ฉันได้เห็นเอกสารที่เว็บไซต์ Apache Maven ดูเหมือนว่าการพึ่งพาที่กำหนดไว้ภายใต้dependencyManagementสามารถนำมาใช้ในโมดูลย่อยได้โดยไม่ต้องระบุรุ่น

ตัวอย่างเช่น:

โครงการหลัก (Pro-par) กำหนดการอ้างอิงภายใต้dependencyManagement:

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

จากนั้นในลูกของ Pro-par ฉันสามารถใช้ Junit:

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

อย่างไรก็ตามฉันสงสัยว่าจำเป็นต้องกำหนด junit ใน parent pom หรือไม่? ทำไมไม่กำหนดโดยตรงในโมดูลที่ต้องการ?

การจัดการการพึ่งพาช่วยให้สามารถรวมและเป็นศูนย์กลางการจัดการของเวอร์ชันการพึ่งพาโดยไม่ต้องเพิ่มการพึ่งพาซึ่งสืบทอดมาจากลูกทั้งหมด สิ่งนี้มีประโยชน์อย่างยิ่งเมื่อคุณมีชุดโปรเจ็กต์ (เช่นมากกว่าหนึ่ง) ที่สืบทอดพาเรนต์ร่วม

อีกกรณีการใช้ที่สำคัญอย่างยิ่งของdependencyManagementคือการควบคุมเวอร์ชันของสิ่งประดิษฐ์ที่ใช้ในการอ้างอิงสกรรมกริยา เป็นการยากที่จะอธิบายโดยไม่มีตัวอย่าง โชคดีที่สิ่งนี้แสดงไว้ในเอกสารประกอบ

ฉันช้าไปคำถามนี้ แต่ฉันคิดว่ามันคุ้มค่าการตอบสนองที่ชัดเจนกว่าที่ยอมรับได้ (ซึ่งถูกต้อง แต่ไม่เน้นส่วนสำคัญที่แท้จริงซึ่งคุณต้องสรุปเอง)

ใน POM พาเรนต์ความแตกต่างที่สำคัญระหว่าง<dependencies>และ<dependencyManagement>คือ:

สิ่งประดิษฐ์ที่ระบุไว้ใน<dependencies>ส่วนจะถูกรวมอยู่เสมอเป็นการพึ่งพาของโมดูลย่อย

สิ่งประดิษฐ์ที่ระบุใน<dependencyManagement>ส่วนจะรวมอยู่ในโมดูลย่อยหากมีการระบุไว้ใน<dependencies>ส่วนของโมดูลย่อยเอง ทำไมคุณถามดี เนื่องจากคุณระบุเวอร์ชันและ / หรือขอบเขตในพาเรนต์และคุณสามารถปล่อยทิ้งไว้เมื่อระบุการอ้างอิงใน child POM สิ่งนี้สามารถช่วยให้คุณใช้เวอร์ชันรวมสำหรับการพึ่งพาสำหรับโมดูลย่อยได้โดยไม่ต้องระบุรุ่นในแต่ละโมดูลย่อย

เอกสารบนเว็บไซต์ Maven เป็นที่น่ากลัว สิ่งที่การจัดการการพึ่งพาคือเพียงแค่ย้ายคำจำกัดความการพึ่งพาของคุณ (เวอร์ชันการยกเว้น ฯลฯ ) ไปยัง parent pom จากนั้นใน poms ลูกคุณเพียงแค่ใส่ groupId และ artifactId แค่นั้นแหละ (ยกเว้น parent pom chaining และสิ่งที่คล้ายกัน แต่ก็ไม่ซับซ้อนเหมือนกัน - การพึ่งพาการบริหารจัดการชนะเหนือการพึ่งพาในระดับผู้ปกครอง - แต่ถ้ามีคำถามเกี่ยวกับสิ่งนั้นหรือการนำเข้าเอกสาร Maven นั้นดีกว่านิดหน่อย)

หลังจากอ่าน 'a', 'b', 'c' ขยะบนไซต์ Maven และสับสนฉันก็เขียนตัวอย่างของพวกเขาอีกครั้ง ดังนั้นถ้าคุณมี 2 โปรเจ็กต์ (proj1 และ proj2) ซึ่งใช้การพึ่งพาร่วมกัน (betaShared) คุณสามารถย้ายการพึ่งพานั้นไปจนถึงพาเรนต์ pom ในขณะที่คุณอยู่ที่นี่คุณยังสามารถเลื่อนการพึ่งพาอื่น ๆ (อัลฟาและชาร์ลี) ใด ๆ แต่ถ้ามันเหมาะสมสำหรับโครงการของคุณ ดังนั้นสำหรับสถานการณ์ที่ระบุไว้ในประโยคก่อนหน้านี่คือวิธีการแก้ปัญหาด้วยการพึ่งพาการจัดการในพาเรนต์ pom:

<!-- 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>

มันเหมือนกับที่คุณพูด dependencyManagementใช้เพื่อดึงข้อมูลการพึ่งพาทั้งหมดลงในไฟล์ POM ทั่วไปทำให้การอ้างอิงในไฟล์ POM ง่ายขึ้น

มันจะมีประโยชน์เมื่อคุณมีคุณลักษณะหลายอย่างที่คุณไม่ต้องการพิมพ์ซ้ำในโครงการลูกหลายรายการ

ในที่สุดdependencyManagementสามารถใช้เพื่อกำหนดรุ่นมาตรฐานของสิ่งประดิษฐ์เพื่อใช้ในหลายโครงการ

ยังคงมีสิ่งหนึ่งที่ไม่ได้เป็นไฮไลต์พอในความคิดของฉันและที่เป็นมรดกที่ไม่พึงประสงค์

นี่คือตัวอย่างที่เพิ่มขึ้น:

ฉันประกาศในparentpom ของฉัน:

<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โมดูล?

พวกเขาจะยังคงสืบทอดมันและสิ่งนี้ไม่พึงประสงค์! มันเหมือนกับกลิ่นโค้ดของ Java God Object ที่คุณได้รับบิตที่มีประโยชน์บางอย่างจากคลาสและสิ่งที่ไม่พึงประสงค์มากมายเช่นกัน

นี่คือที่<dependencyManagement>เข้ามาเล่น เมื่อคุณเพิ่มนี้ไปยังผู้ปกครองของคุณ pom ทั้งหมดของโมดูลบุตรหลานของคุณจะไม่เห็นมัน และด้วยเหตุนี้คุณจึงถูกบังคับให้เข้าไปในแต่ละโมดูลที่ต้องการและประกาศอีกครั้ง ( Child AและChild Bโดยไม่ต้องมีรุ่น)

และแน่นอนคุณไม่ได้ทำเพื่อChild Cและโมดูลของคุณยังคงผอม

มีคำตอบไม่กี่ข้อที่สรุปความแตกต่างระหว่าง<depedencies>และ<dependencyManagement>แท็กด้วย maven

อย่างไรก็ตามมีเพียงไม่กี่จุดที่อธิบายด้านล่างอย่างกระชับ:

1. <dependencyManagement>จะช่วยให้การรวมการอ้างอิงทั้งหมด (ใช้ในระดับเด็ก pom) ใช้ในโมดูลที่แตกต่างกัน - ความคมชัด , การจัดการรุ่นพึ่งพากลาง
2. <dependencyManagement>อนุญาตให้อัพเกรด / ลดระดับการพึ่งพาได้ง่ายขึ้นอยู่กับความต้องการในสถานการณ์อื่น ๆ สิ่งนี้จำเป็นต้องใช้ในระดับ pom ของเด็กทุกคน - ความสอดคล้อง
3. การพึ่งพาที่มีให้ใน<dependencies>แท็กนั้นจะถูกนำเข้าเสมอในขณะที่การพึ่งพาที่ให้ไว้<dependencyManagement>ใน parent pom จะถูกนำเข้าเฉพาะเมื่อ child pom มีรายการที่เกี่ยวข้องใน<dependencies>แท็ก

ขออภัยฉันมาช้าไปงานเลี้ยง

ให้ฉันพยายามอธิบายความแตกต่างโดยใช้mvn dependency:treeคำสั่ง

ลองพิจารณาตัวอย่างด้านล่าง

Parent POM - โครงการของฉัน

<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>

Child POM - โมดูลข้อมูล

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

Child POM - โมดูลแอป (ไม่มีการพึ่งพาเป็นพิเศษดังนั้นปล่อยให้การอ้างอิงว่างเปล่า)

 <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 ฝรั่งถูกระบุว่าเป็นการพึ่งพาในทุกโมดูล (รวมถึงพาเรนต์) ในขณะที่apache คอมมอนส์นั้นถูกระบุว่าเป็นการพึ่งพาในโมดูลข้อมูลเท่านั้น (ไม่ใช่แม้แต่ในพาเรนต์โมดูล)

หากมีการกำหนดการพึ่งพาในองค์ประกอบการพึ่งพาการจัดการ pom ระดับบนสุดโครงการลูกไม่จำเป็นต้องแสดงรุ่นของการพึ่งพาอย่างชัดเจน หากโครงการลูกไม่ได้กำหนดรุ่นก็จะแทนที่รุ่นที่ระบุไว้ในส่วนการพึ่งพาการจัดการ POM ระดับบนสุด นั่นคือเวอร์ชันการพึ่งพาการจัดการจะถูกใช้เฉพาะเมื่อเด็กไม่ได้ประกาศรุ่นโดยตรง

ใน POM พาเรนต์ความแตกต่างที่สำคัญระหว่าง <dependencies>และ<dependencyManagement>คือ:

สิ่งประดิษฐ์ที่ระบุไว้ใน<dependencies>ส่วนจะถูกรวมอยู่เสมอเป็นการพึ่งพาของโมดูลย่อย

สิ่งประดิษฐ์ที่ระบุในส่วนจะรวมอยู่ในโมดูลย่อยหากมีการระบุไว้ในส่วนของโมดูลย่อยเอง ทำไมคุณถามดี เนื่องจากคุณระบุเวอร์ชันและ / หรือขอบเขตในพาเรนต์และคุณสามารถปล่อยทิ้งไว้เมื่อระบุการอ้างอิงใน child POM สิ่งนี้สามารถช่วยให้คุณใช้เวอร์ชันรวมสำหรับการพึ่งพาสำหรับโมดูลย่อยได้โดยไม่ต้องระบุรุ่นในแต่ละโมดูลย่อย

ในคำพูดของฉันเองคุณparent-projectช่วยให้คุณมีการพึ่งพา 2 แบบ:

• การอ้างอิงโดยนัย : การอ้างอิงทั้งหมดที่กำหนดไว้ใน<dependencies>ส่วนในของคุณparent-projectได้รับการสืบทอดโดยchild-projects
• การอ้างอิงอย่างชัดเจน : child-projectsช่วยให้คุณสามารถเลือกการอ้างอิงเพื่อใช้ในของคุณ ดังนั้นคุณจะใช้ส่วนที่จะประกาศการอ้างอิงทั้งหมดที่คุณจะใช้ในการที่แตกต่างกันของคุณ<dependencyManagement> child-projectsสิ่งที่สำคัญที่สุดคือว่าในส่วนนี้คุณกำหนดเพื่อที่คุณจะได้ไม่ต้องแจ้งให้ทราบอีกครั้งในของคุณ<version>child-project

<dependencyManagement>ในมุมมองของฉัน (ถูกต้องฉันหากฉันผิด) เป็นเพียงมีประโยชน์โดยช่วยให้คุณรวบรวมรุ่นของการอ้างอิงของคุณ มันเป็นเหมือนคุณสมบัติตัวช่วย

ใน Eclipse dependencyManagementมีหนึ่งคุณลักษณะที่มากขึ้นใน เมื่อdependenciesมีการใช้งานโดยไม่มีการอ้างอิงที่ไม่มีการอ้างอิงจะสังเกตเห็นในไฟล์ pom หากdependencyManagementใช้การอ้างอิงที่ไม่ได้แก้จะยังคงไม่มีการสังเกตในไฟล์ pom และข้อผิดพลาดจะปรากฏเฉพาะในไฟล์ java (นำเข้าและเช่น ... )

ความแตกต่างระหว่างทั้งสองได้รับสิ่งที่ดีที่สุดในสิ่งที่ดูเหมือนว่าคำจำกัดความที่จำเป็นและเพียงพอขององค์ประกอบการพึ่งพาการจัดการที่มีอยู่ในเอกสารเว็บไซต์ Maven:

dependencyManagement

"ข้อมูลการพึ่งพาเริ่มต้นสำหรับโครงการที่สืบทอดมาจากที่นี้การอ้างอิงในส่วนนี้จะไม่ได้รับการแก้ไขในทันที แต่เมื่อ POM ที่ได้มาจากที่นี้ประกาศการพึ่งพาที่อธิบายไว้โดย groupId และ artifactId ที่ตรงกันรุ่นและค่าอื่น ๆ จากส่วนนี้ ใช้สำหรับการอ้างอิงนั้นหากไม่ได้ระบุไว้ " [ https://maven.apache.org/ref/3.6.1/maven-model/maven.html ]

ควรอ่านพร้อมกับข้อมูลเพิ่มเติมที่มีอยู่ในหน้าอื่น:

“ .. ชุดข้อมูลขั้นต่ำสำหรับการจับคู่การอ้างอิงการอ้างอิงกับส่วนการพึ่งพาการจัดการคือจริงๆแล้ว {groupId, artifactId, type, classifier} ในหลายกรณีการอ้างอิงเหล่านี้จะอ้างถึงสิ่งประดิษฐ์ jar ที่ไม่มีตัวจําแนก สิ่งนี้ช่วยให้เราสามารถระบุตัวตนของชุดข้อมูลเป็น {groupId ,ifactId} ได้เนื่องจากค่าเริ่มต้นสำหรับฟิลด์ประเภทคือ jar และตัวแยกประเภทเริ่มต้นเป็นโมฆะ” [ https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html ]

ดังนั้นองค์ประกอบย่อยทั้งหมด (ขอบเขตการยกเว้น ฯลฯ ) ขององค์ประกอบการพึ่งพา - นอกเหนือจาก groupId, artifactId, ประเภท, ลักษณนามไม่ใช่แค่รุ่น - มีให้สำหรับการล็อค / ค่าเริ่มต้นที่จุด (และสืบทอดมาจาก เป็นต้นไป) คุณระบุการพึ่งพาภายใน dependencyElement หากคุณระบุการพึ่งพากับองค์ประกอบย่อยประเภทและตัวแยกประเภท (ดูหน้าเว็บที่อ้างถึงครั้งแรกเพื่อตรวจสอบองค์ประกอบย่อยทั้งหมด) ว่าไม่ใช่ jar และไม่เป็นโมฆะตามลำดับคุณจะต้อง {groupId ,ifactId, ตัวแยกประเภท,} เพื่ออ้างอิง (แก้ไข) การพึ่งพานั้น ณ จุดใด ๆ ในการสืบทอดที่มาจากองค์ประกอบการพึ่งพาการจัดการ อื่น {groupId ,ifactId} จะพอเพียงถ้าคุณไม่ต้องการแทนที่ค่าเริ่มต้นสำหรับลักษณนามและประเภท (jar และ null ตามลำดับ) ดังนั้นค่าเริ่มต้นคือคำหลักที่ดีในคำนิยามนั้น องค์ประกอบย่อยใด ๆ (นอกเหนือจาก groupId,

ดังนั้นองค์ประกอบการพึ่งพาใด ๆ ที่อยู่นอกการพึ่งพาการจัดการไม่ว่าจะเป็นการอ้างอิงถึงองค์ประกอบการพึ่งพาการจัดการบางส่วนหรือเป็นแบบสแตนด์อโลนได้รับการแก้ไขทันที (เช่นติดตั้งไปยังพื้นที่เก็บข้อมูลในท้องถิ่นและพร้อมสำหรับ classpaths)