Apakah lebih baik mengandalkan ketergantungan transitif atau secara eksplisit mendeklarasikannya?

Saya memiliki struktur proyek seperti ini:

My Project
  - Other Team's Project
     -Third Party Dependency

My Projectmembutuhkan Other Team's Projectfungsi, dan kedua My Projectdan Other Team's Projectmemerlukan Third Party Dependencyfungsi. Kami menggunakan sistem manajemen ketergantungan untuk mengelolanya.

Dari perspektif desain, apakah lebih baik untuk My Projectmengandalkan secara transitif Third Party Dependency? Atau lebih baik untuk keduanya My Projectdan Other Team's Projectsecara eksplisit menyatakan bahwa mereka menggunakan Third Party Dependency?

Beberapa hal lain:

• Kedua proyek harus memiliki versi yang sama Third Party Dependency.
• Tidak dijamin bahwa jika Other Team's Projectdiperbarui My Projectakan diuji untuk memastikan tidak ada yang rusak, karena dikelola oleh tim yang berbeda.

Bayangkan apa yang terjadi jika tim lain refactor proyeknya untuk melakukan hal yang sama tanpa menggunakan perpustakaan pihak ketiga dan mereka menghilangkan ketergantungan mereka. Atau mereka beralih ke perpustakaan pihak ketiga lain untuk melakukan hal yang sama. Apakah kode Anda masih berfungsi?

Jika itu kode Anda hanya tergantung pada proyek lain, jika tidak kode Anda tergantung pada perpustakaan pihak ketiga juga.

Kedua proyek harus memiliki versi yang sama Third Party Dependency.

Itu adalah indikator kuat bahwa proyek Anda secara langsung tergantung pada perpustakaan pihak ketiga juga.

Ini sebagian besar berdasarkan pendapat saya pikir, tapi saya akan tetap menggunakan 2p saya.

Cara saya selalu melakukannya adalah dengan bertanya pada diri sendiri, berapa jumlah minimum pengetahuan yang harus dimiliki kode saya untuk melakukan apa yang seharusnya dilakukan?

Jika kode saya hanya menggunakan kode dari Other team's library, maka saya hanya akan menyertakan Other team's librarysebagai ketergantungan.

Jika kode saya juga menggunakan kode dari Third-party library, maka saya akan memasukkannya juga.

Katakanlah saya memiliki kelas berikut dari My Library, Other Library, dan Third-party Library(saya akan menggunakan Java untuk kode contoh)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

    public void doFoo() {
        Bar bar = new Bar();
        bar.doBar();
    }
}

Dalam Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

    public void doBar() {
        Baz baz = new Baz();
        baz.doSomething();
    }
}

Dalam Third-party library

package thirdparty;

public class Baz {

    public void doBaz() {
        System.out.println("baz");
    }
}

Karena kode saya Foohanya bergantung pada kode otherlibrary, itu saja yang akan saya sertakan, karena hanya itu yang saya pedulikan. Saya tidak peduli bagaimana caranya otherlibrary.Bar#doBar, saya hanya ingin melakukannya.

Namun jika, kami mengubah otherlibrary.Bar#doBaruntuk menerima Bazuntuk melakukan sesuatu dengan, seperti

public void doBar(Baz baz) {
    baz.doBaz();
}

Saya kemudian perlu mengubah mylibrary.Foo#doFooke sesuatu seperti

public void doFoo() {
    Bar bar = new Bar();
    Baz baz = new Baz();

    bar.doBar(baz);
}

Karena saya sekarang tertarik pada bagaimana Bar#doBarakan melakukan hal itu, dan kode saya perlu tahu tentang Bazmelakukan apa yang saya inginkan, saya perlu secara eksplisit tentang perpustakaan yang saya sertakan.

Jika kode saya harus tahu tentang hal-hal dalam thirdpartyperpustakaan, maka saya harus memasukkannya sebagai ketergantungan.

Meskipun mungkin penulis Barharus menyembunyikan lebih banyak detail itu jadi saya tidak perlu memasukkan thirdpartyperpustakaan ...