Est-il préférable de s'appuyer sur des dépendances transitives ou de les déclarer explicitement?

J'ai une structure de projet comme celle-ci:

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

My Projectnécessite Other Team's Projectde fonctionner, et les deux My Projectet Other Team's Projectnécessitent Third Party Dependencyde fonctionner. Nous utilisons un système de gestion des dépendances pour les gérer.

Du point de vue de la conception, est-il préférable d'avoir My Projectrecours de manière transitoire Third Party Dependency? Ou est-il préférable pour les deux My Projectet Other Team's Projectpour les deux déclarer explicitement qu'ils utilisent Third Party Dependency?

Quelques autres choses:

• Les deux projets doivent avoir la même version de Third Party Dependency.
• Il n'est pas garanti que si Other Team's Projectest mis à jour, My Projectil sera testé pour s'assurer que rien ne casse, car ils sont gérés par différentes équipes.

Imaginez ce qui se passe si l'autre équipe refactorise son projet pour faire la même chose sans utiliser la bibliothèque tierce et supprime sa dépendance. Ou ils passent à une autre bibliothèque tierce pour faire la même chose. Votre code fonctionnera-t-il toujours?

Si c'est le cas, votre code dépend uniquement de l'autre projet, sinon votre code dépend également de la bibliothèque tierce.

Les deux projets doivent avoir la même version de Third Party Dependency.

C'est un indicateur fort que votre projet dépend aussi directement de la bibliothèque tierce.

C'est principalement basé sur l'opinion, je pense, mais je vais quand même mettre mon 2p.

La façon dont je l'ai toujours fait est de me demander quel est le minimum de connaissances dont mon code a besoin pour faire ce qu'il est censé faire?

Si mon code utilise uniquement le code de Other team's library, je n'inclurai Other team's libraryque comme dépendance.

Si mon code utilise également le code de Third-party library, je l'inclurai également.

Disons que j'avais les classes suivantes de My Library, Other Libraryet Third-party Library(je vais utiliser Java pour l'exemple de code)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

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

dans le Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

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

dans le Third-party library

package thirdparty;

public class Baz {

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

Parce que mon code Foone dépend que du code de otherlibrary, c'est tout ce que j'inclurais, car c'est tout ce qui m'importe. Peu m'importe comment otherlibrary.Bar#doBarfait quoi que ce soit, je veux juste qu'il le fasse.

Si cependant, nous avons changé le otherlibrary.Bar#doBarpour accepter un Bazpour faire quelque chose avec, comme

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

Je devrais alors changer mylibrary.Foo#doFoopour quelque chose comme

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

    bar.doBar(baz);
}

Parce que je suis maintenant intéressé par comment Bar#doBarva faire son truc, et que mon code doit savoir Bazfaire ce que je veux qu'il fasse, je dois être explicite sur les bibliothèques que j'inclus.

Si mon code doit connaître les éléments de la thirdpartybibliothèque, je dois l' inclure comme dépendance.

Bien que l'auteur de Bardevrait peut-être cacher plus de ces détails, je n'ai pas besoin d'inclure la thirdpartybibliothèque ...