Ist es besser, sich auf transitive Abhängigkeiten zu verlassen oder diese explizit zu deklarieren?

Ich habe eine Projektstruktur wie diese:

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

My Projecterfordert Other Team's Projectzu funktionieren, und beide My Projectund Other Team's Projecterfordern Third Party Dependencyzu funktionieren. Wir verwenden ein Abhängigkeitsmanagementsystem, um diese zu verwalten.

Ist es aus gestalterischer Sicht besser, sich My Projecttransitiv darauf zu verlassen Third Party Dependency? Oder ist es besser für beide My Projectund Other Team's Projectfür beide ausdrücklich zu erklären, dass sie verwenden Third Party Dependency?

Ein paar andere Dinge:

• Beide Projekte müssen dieselbe Version von haben Third Party Dependency.
• Es kann nicht garantiert werden, dass bei einer Other Team's ProjectAktualisierung My Projectgeprüft wird, ob nichts kaputt geht, da sie von verschiedenen Teams verwaltet werden.

Stellen Sie sich vor, was passiert, wenn das andere Team sein Projekt überarbeitet, um dasselbe zu tun, ohne die Bibliothek eines Drittanbieters zu verwenden, und ihre Abhängigkeit entfernt. Oder sie wechseln zu einer anderen Bibliothek eines Drittanbieters, um dasselbe zu tun. Funktioniert Ihr Code noch?

Wenn dies der Fall ist, hängt Ihr Code nur vom anderen Projekt ab. Wenn nicht, hängt Ihr Code auch von der Bibliothek eines Drittanbieters ab.

Beide Projekte müssen dieselbe Version von haben Third Party Dependency.

Dies ist ein starker Indikator dafür, dass Ihr Projekt auch direkt von der Bibliothek eines Drittanbieters abhängt.

Ich denke, dies ist größtenteils meinungsbasiert, aber ich werde trotzdem meine 2p einsetzen.

Ich habe es immer so gemacht, indem ich mich gefragt habe, wie viel Wissen mein Code mindestens benötigt , um das zu tun, was er tun soll.

Wenn mein Code nur Code von verwendet Other team's library, werde ich nur Other team's libraryals Abhängigkeit einschließen .

Wenn mein Code auch Code von verwendet Third-party library, werde ich ihn ebenfalls einschließen.

Angenommen, ich hatte die folgenden Klassen von My Library, Other Libraryund Third-party Library(ich verwende Java für den Beispielcode)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

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

In dem Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

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

In dem Third-party library

package thirdparty;

public class Baz {

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

Da mein Code Foonur vom Code abhängt otherlibrary, ist das alles, was ich einschließen würde, denn das ist alles, was mich interessiert. Es ist mir egal, wie otherlibrary.Bar#doBares funktioniert, ich möchte nur, dass es es tut.

Wenn wir jedoch das geändert haben otherlibrary.Bar#doBar, um ein Bazzu akzeptieren , um etwas damit zu tun, wie

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

Ich müsste dann mylibrary.Foo#doFoozu so etwas wechseln

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

    bar.doBar(baz);
}

Weil ich jetzt bin interessiert , wie Bar#doBarwird seine Sache zu tun, und mein Code muss wissen , über Bazzu tun , was ich will , es zu tun, muss ich über die Bibliotheken explizit sein I enthalten.

Wenn mein Code muss über solche Sachen in der wissen - thirdpartyBibliothek, dann ich muss es als eine Abhängigkeit enthalten.

Obwohl der Autor von vielleicht Barmehr dieser Details verstecken sollte, muss ich die thirdpartyBibliothek nicht einschließen ...