Лучше ли полагаться на транзитивные зависимости или явно объявлять их?

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

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.

Это сильный показатель того, что ваш проект напрямую зависит также от сторонней библиотеки.

Я думаю, это в основном основано на мнении, но я все равно добавлю свой 2р.

Я всегда так делал, задавая себе вопрос: какой минимальный объем знаний должен иметь мой код , чтобы делать то, что должен делать?

Если мой код использует только код из 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библиотеку ...