Czy lepiej polegać na zależnościach przechodnich lub jawnie je deklarować?

Mam taką strukturę projektu:

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

My ProjectWymaga Other Team's Projectdo funkcji, a zarówno My Projecti Other Team's Projectwymagają Third Party Dependencydo funkcji. Do zarządzania nimi używamy systemu zarządzania zależnościami.

Czy z punktu widzenia projektowania lepiej My Projectpolegać na transporcie Third Party Dependency? Czy może lepiej dla obu My Projecti Other Team's Projectdla obu jawnie zadeklarować, że używają Third Party Dependency?

Kilka innych rzeczy:

• Oba projekty muszą mieć tę samą wersję Third Party Dependency.
• Nie ma gwarancji, że jeśli Other Team's Projectzostanie zaktualizowany, My Projectzostanie przetestowany, aby upewnić się, że nic się nie zepsuje, ponieważ są zarządzane przez różne zespoły.

Wyobraź sobie, co się stanie, jeśli drugi zespół refaktoryzuje swój projekt, aby zrobić to samo bez korzystania z biblioteki strony trzeciej i usunie swoją zależność. Lub przechodzą do innej biblioteki innej firmy, aby zrobić to samo. Czy Twój kod nadal będzie działał?

Jeśli tak, twój kod zależy tylko od innego projektu, jeśli nie, twój kod zależy również od biblioteki innej firmy.

Oba projekty muszą mieć tę samą wersję Third Party Dependency.

To silny wskaźnik, że twój projekt zależy bezpośrednio również od biblioteki innej firmy.

Myślę, że jest to w większości oparte na opiniach, ale i tak dodam 2p.

Zawsze tak robiłem, zadając sobie pytanie, jaka jest minimalna ilość wiedzy, jaką mój kod musi mieć, aby robić to, co powinien?

Jeśli mój kod używa tylko kodu z Other team's library, to podam tylko Other team's libraryjako zależność.

Jeśli mój kod również używa kodu z Third-party library, to również go dołączę.

Powiedzmy, że miałem z następujących klas My Library, Other Libraryoraz Third-party Library(użyję kodu Java na przykład)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

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

w Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

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

w Third-party library

package thirdparty;

public class Baz {

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

Ponieważ mój kod Foozależy tylko od kodu otherlibrary, to wszystko, co bym zawarł, ponieważ to wszystko, na czym mi zależy. Nie obchodzi mnie, jak otherlibrary.Bar#doBarto robi, po prostu chcę, żeby to zrobiło.

Jeśli jednak zmieniliśmy otherlibrary.Bar#doBaropcję akceptowania, Bazaby zrobić coś z, na przykład

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

Musiałbym wtedy zmienić mylibrary.Foo#doFoona coś takiego

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

    bar.doBar(baz);
}

Ponieważ jestem teraz zainteresowany tym, jak Bar#doBarto zrobię, a mój kod musi wiedzieć, Bazjak zrobić to, co chcę, muszę jasno powiedzieć o bibliotekach, które dołączam.

Jeśli mój kod musi wiedzieć o rzeczach w thirdpartybibliotece, to musi obejmować go jako zależność.

Chociaż być może autor Barpowinien ukryć więcej tych szczegółów, więc nie muszę dołączać thirdpartybiblioteki ...