Приборкання класів «функції корисних функцій»

У нашій кодовій базі Java я постійно бачу таку схему:

/**
 This is a stateless utility class
 that groups useful foo-related operations, often with side effects.
*/
public class FooUtil {
  public int foo(...) {...}
  public void bar(...) {...}
}

/**
 This class does applied foo-related things.
*/
class FooSomething {
  int DoBusinessWithFoo(FooUtil fooUtil, ...) {
    if (fooUtil.foo(...)) fooUtil.bar(...);
  }
}

Мене хвилює те, що я маю проходити екземпляр FooUtilскрізь, бо тестування.

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

Я вважаю, що найкращим моїм ставкою є використання ін'єкцій (і я це роблю), але це додає власний набір клопотів. Крім того, проходження декількох екземплярів утиліти збільшує розмір списків параметрів методу.

Чи є спосіб вирішити це краще, що я не бачу?

Оновлення: оскільки класи утиліти без стану, я, ймовірно, можу додати статичний однотонний INSTANCEчлен або статичний getInstance()метод, зберігаючи можливість оновлення базового статичного поля класу для тестування. Не здається надто чистою теж.

Перш за все дозвольте сказати, що існують різні підходи до програмування для різних проблем. Для своєї роботи я віддаю перевагу сильному дизайну ОО для організації та обслуговування, і моя відповідь це відображає це. Функціональний підхід мав би зовсім іншу відповідь.

Я схильний вважати, що більшість класів корисних програм створені тому, що об'єкт, на якому повинні бути методи, не існує. Це майже завжди відбувається з одного з двох випадків, або хтось передає колекції навколо, або хтось передає боби навколо (це часто називають POJO, але я вважаю, що купа сетерів та геттерів найкраще описується як квасоля).

Коли у вас є колекція, яку ви обминаєте, повинен бути код, який хоче бути частиною цієї колекції, і це в кінцевому підсумку розповсюджується по всій вашій системі і в кінцевому підсумку збирається в корисні класи.

Моя пропозиція - перегорнути свої колекції (або боби) з будь-якими іншими тісно пов’язаними даними в нові класи та помістити "корисний" код у фактичні об'єкти.

Ви можете розширити колекцію та додати туди методи, але таким чином ви втратите контроль над станом свого об’єкта - я пропоную вам інкапсулювати його повністю та лише розкрити необхідні методи ділової логіки (подумайте "Не запитуйте у ваших об'єктів їх даних, дайте своїм об’єктам команди та дозвольте їм діяти на їхніх приватних даних ", важливий орендар OO та той, коли, думаючи про це, вимагає підходу, який я тут пропоную).

Це "обгортання" корисно для будь-яких об'єктів бібліотеки загального призначення, що містять дані, але ви не можете додати код - Введення коду до даних, якими вони маніпулюють, є ще однією важливою концепцією в дизайні ОО.

Існує багато стилів кодування, де ця концепція обгортання була б поганою ідеєю - хто хоче написати цілий клас під час виконання одноразового сценарію чи тесту? Але я думаю, що капсулювання будь-яких основних типів / колекцій, яким ви не можете додати код, є обов'язковим для ОО.

Ви можете використовувати шаблон постачальника і виконання вашого FooSomethingз FooUtilProviderоб'єктом (може бути в конструкторі, тільки один раз).

FooUtilProviderматиме тільки один метод: FooUtils get();. Потім клас використовуватиме будь-який FooUtilsпримірник, який він надає.

Тепер це один крок від використання рамки введення залежностей, коли вам доведеться лише двічі провести провід для коінтейнера DI: для виробничого коду та для набору тестів. Ви просто прив'язуєте FooUtilsінтерфейс до або, RealFooUtilsабо MockedFooUtilsінше відбувається автоматично. Кожен об'єкт, від якого залежить, FooUtilsProviderотримує належну версію FooUtils.