Apa perbedaan antara dependencyManagement
dan ketergantungan
?
Saya telah melihat dokumen di Apache Maven situs web.
Tampaknya bahwa ketergantungan didefinisikan di bawah dependencyManagement
dapat digunakan untuk anak modul tanpa menentukan versi.
Misalnya:
Induk proyek (Pro-par) mendefinisikan ketergantungan bawah dependencyManagement
:
<dependencyManagement>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8</version>
</dependency>
</dependencies>
</dependencyManagement>
Kemudian pada anak dari Pro-par, saya dapat menggunakan junit:
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
</dependency>
</dependencies>
Namun, saya bertanya-tanya jika hal ini diperlukan untuk menentukan junit di induk pom? Mengapa tidak mendefinisikan secara langsung di butuhkan module?
I'm terlambat untuk pertanyaan ini, tetapi saya pikir itu's bernilai lebih jelas respon dari yang diterima (mana yang benar, tapi doesn't menekankan sebenarnya bagian penting yang anda butuhkan untuk menyimpulkan sendiri).
Di induk POM, perbedaan utama antara <dependensi>
dan <dependencyManagement>
adalah ini:
Artefak yang ditentukan dalam <dependensi>
bagian akan SELALU disertakan sebagai ketergantungan anak modul(s).
Artefak yang ditentukan dalam <dependencyManagement>
bagian, hanya akan disertakan pada anak modul jika mereka juga ditentukan dalam <dependensi>
bagian dari anak modul itu sendiri. Mengapa lebih baik anda bertanya? karena anda menentukan versi dan/atau ruang lingkup pada orang tua, dan anda dapat meninggalkan mereka ketika menentukan dependensi pada anak POM. Hal ini dapat membantu anda menggunakan unified versi untuk dependensi untuk anak modul, tanpa menentukan versi dalam masing-masing anak modul.
Ketergantungan Manajemen memungkinkan untuk melakukan konsolidasi dan sentralisasi pengelolaan ketergantungan versi tanpa menambahkan dependensi yang diwarisi oleh semua anak-anak. Hal ini terutama berguna ketika anda memiliki satu set proyek (yaitu lebih dari satu) yang mewarisi bersama orang tua.
Lain sangat penting menggunakan kasus dependencyManagement
adalah kontrol versi artefak yang digunakan dalam ketergantungan transitif. Ini adalah sulit untuk menjelaskan tanpa contoh. Untungnya, hal ini digambarkan dalam dokumentasi.
The dokumentasi pada Maven situs ini mengerikan. Apa yang dependencyManagement tidak hanya memindahkan ketergantungan definisi (versi, pengecualian, dll) sampai dengan orang tua pom, maka pada anak pom anda hanya perlu menempatkan groupId dan artifactId. Yang's (kecuali untuk orang tua pom chaining dan sejenisnya, tapi yang's tidak benar-benar rumit baik - dependencyManagement menang atas ketergantungan pada orang tua tingkat - tetapi jika memiliki pertanyaan tentang itu atau impor, Maven dokumentasi adalah sedikit lebih baik).
Setelah membaca semua 'a', 'b', 'c' sampah pada Maven situs dan semakin bingung, saya kembali menulis contoh mereka. Jadi jika anda memiliki 2 proyek (proj1 dan proj2) yang berbagi umum ketergantungan (betaShared) anda bisa memindahkan ketergantungan yang hingga orang tua pom. Sementara anda berada di itu, anda dapat juga bergerak naik yang lain dependensi (alpha dan charlie) tetapi hanya jika itu masuk akal untuk proyek anda. Jadi untuk situasi yang diuraikan dalam sebelum kalimat, di sini adalah solusi dengan dependencyManagement di induk 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>
It's seperti yang anda katakan; `dependencyManagement syi'ah digunakan untuk menarik semua ketergantungan informasi umum POM file, menyederhanakan referensi pada anak POM file.
Hal ini menjadi berguna ketika anda memiliki beberapa atribut yang anda don't ingin mengetik ulang di bawah beberapa anak-anak proyek-proyek.
Akhirnya, dependencyManagement
dapat digunakan untuk menentukan versi standar dari sebuah artefak yang dapat digunakan untuk beberapa proyek.
Ada's masih salah satu hal yang tidak cukup disorot, dalam pendapat saya, dan itu adalah warisan yang tidak diinginkan.
Berikut ini's inkremental contoh:
Saya menyatakan saya orang tua
pom:
<dependencies>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>19.0</version>
</dependency>
</dependencies>
boom! Aku punya Anak
, Anak B
dan Anak C
modul:
versi 18.0
di Anak B
jika saya ingin.Tapi bagaimana jika aku berakhir dengan tidak membutuhkan jambu di Anak C
, dan tidak juga di masa depan Anak D
dan Anak E
modul?
Mereka masih akan mewarisinya, dan ini yang tidak diinginkan! Ini hanya seperti Java Allah kode Objek bau, di mana anda mewarisi beberapa bit yang berguna dari kelas, dan tonn dari hal yang tidak diinginkan juga.
Ini adalah di mana <dependencyManagement>
datang ke dalam bermain. Ketika anda menambahkan ini ke orang tua pom, semua anak anda modul BERHENTI melihat ini. Dan dengan demikian anda paksa untuk pergi ke masing-masing individu modul yang TIDAK perlu itu dan menyatakan hal itu lagi (Anak
dan Anak B
, tanpa versi sekalipun).
Dan, yang jelas, anda don't melakukan itu untuk Anak C
, dan dengan demikian modul anda tetap ramping.
Ada beberapa jawaban yang menguraikan perbedaan antara <pilih>
dan <dependencyManagement>
kategori dengan maven.
Namun, beberapa poin yang diuraikan di bawah ini secara ringkas cara:
<dependencyManagement>
memungkinkan untuk mengkonsolidasikan semua dependensi (digunakan pada anak pom level) yang digunakan di seluruh modul yang berbeda -- kejelasan, central ketergantungan versi manajemen<dependencyManagement>
memungkinkan untuk dengan mudah meng-upgrade/downgrade dependensi berdasarkan kebutuhan lain, skenario ini harus dilakukan pada setiap anak pom tingkat -- konsistensi<dependensi>
tag ini selalu diimpor, sementara ketergantungan yang disediakan di <dependencyManagement>
di orang tua pom akan diimpor hanya jika anak pom memiliki masing-masing masuk dalam <dependensi>
tag.Maaf saya sangat terlambat ke pesta.
Biarkan saya mencoba untuk menjelaskan perbedaan menggunakan mvn ketergantungan:pohon
perintah
Perhatikan contoh di bawah ini
Orang tua POM - Proyek Saya
<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>
Anak-anak POM - data modul
<dependencies>
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-lang3</artifactId>
</dependency>
</dependencies>
Anak-anak POM - aplikasi modul (tidak memiliki tambahan ketergantungan, sehingga meninggalkan ketergantungan kosong)
<dependencies>
</dependencies>
Untuk menjalankan mvn ketergantungan:pohon
perintah, kita mendapatkan hasil berikut
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 jambu terdaftar sebagai ketergantungan dalam setiap modul (termasuk orang tua), sedangkan apache commons terdaftar sebagai ketergantungan hanya di data module (bahkan tidak dalam induk modul)
Jika ketergantungan didefinisikan dalam bagian atas-tingkat pom's dependencyManagement elemen, anak proyek tidak harus secara eksplisit daftar versi ketergantungan. jika anak proyek tidak menentukan versi, itu akan menimpa versi yang tercantum di atas-tingkat POM dependencyManagement bagian. Artinya, dependencyManagement versi ini hanya digunakan ketika anak tidak menyatakan versi ini diatas.
Di induk POM, perbedaan utama antara <dependensi>
dan <dependencyManagement>
ini adalah:
Artefak yang ditentukan dalam <dependensi>
bagian akan SELALU disertakan sebagai ketergantungan anak modul(s).
Artefak yang ditentukan dalam
Di Eclipse, ada satu fitur yang lebih di dependencyManagement
. Ketika ketergantungan
digunakan tanpa itu, tidak kita temukan dependensi melihat di pom file. Jika dependencyManagement
digunakan, yang belum terpecahkan dependensi tetap diperhatikan di pom file dan kesalahan hanya muncul di file java. (impor dan seperti...)
Perbedaan antara keduanya adalah yang terbaik membawa apa yang tampaknya perlu dan cukup definisi dependencyManagement elemen yang tersedia di Maven web docs:
dependencyManagement
"Default ketergantungan informasi untuk proyek-proyek yang mewarisi dari yang satu ini. Ketergantungan pada bagian ini tidak segera diselesaikan. Sebaliknya, ketika sebuah POM berasal dari yang satu ini menyatakan ketergantungan dijelaskan oleh pencocokan groupId dan artifactId, versi dan nilai-nilai lain dari bagian ini digunakan untuk itu ketergantungan jika mereka tidak sudah ditentukan." [ https://maven.apache.org/ref/3.6.1/maven-model/maven.html ]
Ini harus dibaca bersama dengan beberapa informasi lebih lanjut tersedia pada halaman yang berbeda:
"..minimal set informasi untuk pencocokan ketergantungan referensi terhadap dependencyManagement bagian adalah benar-benar {groupId, artifactId, jenis, classifier}. Dalam banyak kasus, dependensi ini akan merujuk ke jar artefak dengan tidak classifier. Hal ini memungkinkan kita untuk singkatan identitas set untuk {groupId, artifactId}, karena default untuk bidang jenis jar, dan default classifier adalah null." [https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html ]
Dengan demikian, semua sub-elemen (ruang lingkup, pengecualian dll.,) dari ketergantungan elemen--lain-lain dari groupId, artifactId, jenis, classifier, tidak hanya versi--tersedia untuk lockdown/default pada titik (dan dengan demikian mewarisi dari sana dan seterusnya) yang anda tentukan ketergantungan hanya dependencyElement. Jika anda akan ditentukan ketergantungan dengan jenis dan klasifikasi sub elemen (lihat pertama-dikutip laman web untuk periksa semua sub-elemen) tidak jar dan tidak null masing-masing, anda akan perlu {groupId, artifactId, classifier, type} untuk referensi (menyelesaikan) bahwa ketergantungan pada setiap titik di suatu warisan yang berasal dari dependencyManagement elemen. Yang lain, {groupId, artifactId} akan cukup jika anda tidak berniat untuk mengganti default untuk classifier dan jenis (jar dan null masing-masing). Jadi default adalah sebuah kata kunci dalam definisi tersebut; setiap sub-elemen(s) (lain dari groupId, artifactId, classifier dan jenis, tentu saja) secara eksplisit diberikan nilai(s) pada titik referensi anda ketergantungan override default di dependencyManagement elemen.
Jadi, setiap ketergantungan elemen di luar dependencyManagement, apakah sebagai referensi untuk beberapa dependencyManagement elemen atau mandiri segera diselesaikan (yaitu, diinstal ke repositori lokal dan tersedia untuk classpaths).