Чи краще покладатися на транзитивні залежності чи прямо заявляти про них?

У мене така структура проекту:

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

My Projectвимагає Other Team's Projectфункціонування, і те, My Projectі Other Team's Projectвимагає Third Party Dependencyфункціонування. Ми використовуємо систему управління залежностями для управління ними.

З точки зору дизайну, чи краще на це My Projectпокладатися транзитивно Third Party Dependency? Або краще і обом, My Projectі Other Team's Projectобом прямо заявити, що вони використовують Third Party Dependency?

Ще кілька речей:

• Обидва проекти повинні мати однакову версію Third Party Dependency.
• Не гарантується, що в разі Other Team's Projectоновлення My Projectтестування буде гарантовано, що нічого не порушиться, оскільки ними керують різні команди.

Уявіть, що станеться, якщо інша команда відмовиться від свого проекту зробити те саме, не використовуючи сторонні бібліотеки, і вони усунуть свою залежність. Або вони переходять до іншої сторонньої бібліотеки, щоб зробити те саме. Чи буде ваш код все-таки працювати?

Якщо це робити, ваш код залежить лише від іншого проекту, якщо ні, то ваш код також залежить від сторонньої бібліотеки.

Обидва проекти повинні мати однакову версію Third Party Dependency.

Це сильний показник того, що ваш проект безпосередньо залежить і від сторонньої бібліотеки.

В основному, на мою думку, це ґрунтується на думці, але я все-таки вкладу свій 2p.

Я завжди робив це, запитуючи себе, який мінімальний обсяг знань повинен мати мій код для того, щоб його робити?

Якщо мій код використовує лише код від Other team's library, я включатиму лише Other team's libraryяк залежність.

Якщо в моєму коді також використовується код Third-party library, я його також включатиму.

Скажімо , я мав такі класи з My Library, Other Libraryі Third-party Library(я буду використовувати Java для коду прикладу)

package mylibrary;

import otherlibrary.Bar;

public class Foo {

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

В Other Library

package otherlibrary;

import thirdparty.Baz;

public class Bar {

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

В Third-party library

package thirdparty;

public class Baz {

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

Оскільки мій код Fooзалежить тільки від коду від otherlibrary, це все, що я б включив, тому що це все, що мені важливо. Мені все одно, як otherlibrary.Bar#doBarвсе, що робиться, я просто хочу, щоб він це зробив.

Якщо ж ми змінили, otherlibrary.Bar#doBarщоб прийняти Bazщось робити, наприклад

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

Тоді мені потрібно було б змінити mylibrary.Foo#doFooщось на зразок

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

    bar.doBar(baz);
}

Оскільки мене зараз цікавить, як Bar#doBarвін буде робити свою справу, і мій код повинен знати про те, Bazщоб робити те, що я хочу, це мені потрібно чітко пояснювати бібліотеки, які я включаю.

Якщо мій код повинен знати про речі в thirdpartyбібліотеці, я повинен включати його як залежність.

Хоча, можливо, автор Barповинен приховати більше цих деталей, тому мені не потрібно включати thirdpartyбібліотеку ...