È meglio fare affidamento su dipendenze transitive o dichiararle esplicitamente?

Ho una struttura di progetto come questa:

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

My Projectrichiede Other Team's Projectdi funzionare, ed entrambi My Projecte Other Team's Projectrichiede Third Party Dependencydi funzionare. Stiamo usando un sistema di gestione delle dipendenze per gestirli.

Dal punto di vista del design, è meglio My Projectaffidarsi in modo transitorio Third Party Dependency? O è meglio per entrambi My Projected Other Team's Projectentrambi dichiarare esplicitamente che usano Third Party Dependency?

Alcune altre cose:

• Entrambi i progetti devono avere la stessa versione di Third Party Dependency.
• Non è garantito che, se Other Team's Projectaggiornato, My Projectverrà testato per garantire che nulla si rompa, poiché sono gestiti da team diversi.

Immagina cosa succede se l'altra squadra rifatta il suo progetto per fare la stessa cosa senza usare la libreria di terze parti e rimuovono la loro dipendenza. Oppure passano a un'altra libreria di terze parti per fare la stessa cosa. Il tuo codice funzionerà ancora?

Se lo fa il tuo codice dipende solo dall'altro progetto, altrimenti il ​​tuo codice dipende anche dalla libreria di terze parti.

Entrambi i progetti devono avere la stessa versione di Third Party Dependency.

Questo è un forte indicatore del fatto che il tuo progetto dipende direttamente anche dalla libreria di terze parti.

Questo è principalmente basato sull'opinione, penso, ma inserirò comunque il mio 2p.

Il modo in cui l'ho sempre fatto è chiedermi: qual è la quantità minima di conoscenza che il mio codice deve avere per fare ciò che dovrebbe fare?

Se il mio codice utilizza solo il codice da Other team's library, includerò solo Other team's librarycome dipendenza.

Se il mio codice anche utilizza codice da Third-party library, allora sarò includerlo pure.

Diciamo che ho avuto le seguenti classi di My Library, Other Librarye Third-party Library(userò Java per il codice di esempio)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

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

Nel Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

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

Nel Third-party library

package thirdparty;

public class Baz {

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

Poiché il mio codice Foodipende solo dal codice di otherlibrary, questo è tutto ciò che vorrei includere, perché è tutto ciò che mi interessa. Non mi interessa come otherlibrary.Bar#doBarfa qualunque cosa faccia, voglio solo che lo faccia.

Se tuttavia, abbiamo cambiato il otherlibrary.Bar#doBarper accettare un Bazper fare qualcosa con, come

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

Avrei quindi bisogno di passare mylibrary.Foo#doFooa qualcosa di simile

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

    bar.doBar(baz);
}

Dato che ora sono interessato a come Bar#doBarfare, e il mio codice deve sapere Bazcosa fare per fare ciò che voglio, devo essere esplicito sulle librerie che includo.

Se il mio codice deve sapere di cose all'interno della thirdpartylibreria, quindi mi devo includerlo come una dipendenza.

Anche se forse l'autore di Bardovrebbe nascondere più di quei dettagli, quindi non ho bisogno di includere la thirdpartybiblioteca ...