---
title: "app() - це не впровадження залежностей: від 18 викликів до нуля"
url: https://laravelukraine.com/blog/app-ce-ne-vprovadzennia-zaleznostei-vid-18-viklikiv-do-nulia
date: 2026-11-02
source: https://dev.to/tegos/app-is-not-dependency-injection-18-calls-down-to-zero-k90
---

# app() - це не впровадження залежностей: від 18 викликів до нуля

*Переклад статті Івана Михавка [app() Is Not Dependency Injection: 18 Calls Down to Zero](https://dev.to/tegos/app-is-not-dependency-injection-18-calls-down-to-zero-k90).*

Я постійно чую «у нас скрізь DI» від Laravel-розробників, чий код повний `app(SomeService::class)`. Об'єкт будує контейнер, тож це схоже на впровадження залежностей. Але ні. Це Service Locator, і я роками кажу про це на код-рев'ю.

І все одно, коли я пройшовся git-історією проєкту, над яким працюю, то на піку нарахував 18 таких викликів. Знати, що це антипатерн, і не писати його - дві різні речі. Ось як цей розрив закрився.

### «Але ж у нас скрізь DI»

Ось про що я. Обидва фрагменти нижче отримують залежність із контейнера. Перший - з нашої кодової бази 2024 року:

```php
// app/Models/User.php, 2024: Service Locator, клас сам просить залежність
public function getCart(): Cart
{
  /** @var CartService $cartService */
  $cartService = app(CartService::class);

  return $cartService->getCartEntity($this);
}
```

Другий - так сьогодні виглядає дія (Action) кошика в нашій основній гілці:

```php
// app/Actions/Cart/CartIndexAction.php, сьогодні: впровадження залежностей, клас отримує залежність
final readonly class CartIndexAction implements Actionable
{
  public function __construct(
    private CartItemDtoFactory $cartItemDtoFactory
  )
  {
  }

  public function handle(CartItemParamDTO $cartItemParamDTO, int $userId, ?int $managerId = null): Collection
  {
    $cartItemDTOs = $this->cartItemDtoFactory->fetchForDisplay($userId, $managerId, $cartItemParamDTO->itemUuids);

    return $cartItemDTOs->values();
  }
}
```

Два коротких визначення, щоб ми сперечалися про одне й те саме. При впровадженні залежностей (Dependency Injection) клас отримує свої залежності ззовні, через конструктор або параметр методу, і йому байдуже, хто їх створив. При Service Locator (дослівно «локатор сервісів») клас сам просить їх у спільного реєстру, посеред власного коду. У Laravel цей реєстр - контейнер, а `app()` - той самий запит до нього.

В обох випадках залежність створює контейнер. Різниця в тому, **хто про кого знає**. У першому випадку `User` знає про контейнер і ховає свою залежність у тілі методу. У другому клас гадки не має, звідки береться `CartItemDtoFactory`, а конструктор розповідає все, що йому потрібно.

У цьому й уся ціна Service Locator. Сигнатура класу бреше про його залежності, відсутня прив'язка дає збій під час виконання, а не під час створення об'єкта, а надто довгий конструктор - корисний сигнал тривоги, який `app()` просто ховає.

Документація Laravel схиляється до того самого. Вона показує `app()` і `App::make()` для коду, у якого під рукою немає змінної `$app`, а потім, про підказки типів у конструкторі, каже:

> На практиці саме так контейнер має розв'язувати більшість ваших об'єктів.

Одне застереження щодо меж, перш ніж перейти до цифр. Фасади й хелпери на кшталт `config()` чи `Cache::` теж тягнуть усе з контейнера, і дехто так само називає їх Service Locator. Я їх не рахував. Це окрема суперечка. Ця стаття - лише про явне розв'язання власних класів проєкту в стилі `app(Foo::class)`.

### Що показують чотири роки git-історії

Я порахував виклики `app(Foo::class)`, `app()->make()`, `App::make()` і `resolve(Foo::class)` у каталозі `app/` основної гілки в кількох точках часу:

| Дата | Виклики Service Locator | PHP-файлів в `app/` |
|---|---|---|
| 2022-07 | 5 | 117 |
| 2023-01 | 12 | 235 |
| 2023-07 | 18 | 371 |
| 2024-01 | 18 | 428 |
| 2024-07 | 16 | 548 |
| 2025-01 | 11 | 856 |
| 2025-07 | 3 | 965 |
| 2026-01 | 1 | 1052 |
| 2026-05 | 0 | 1058 |
| 2026-10 | 0 | 1166 |

Від піку в 18 викликів до 0, поки `app/` виріс із 371 до понад 1000 файлів.

**Усі чотири варіанти написання жили в одній кодовій базі.** Ніхто ніколи не вирішував «тут ми використовуємо Service Locator». Так просто склалося.

Найгірший метод, який я знайшов, у сервісі пошуку з 2024 року, розв'язував чотири сервіси поспіль:

```php
// app/Services/Search/SearchResultService.php, 2024
/** @var PriceService $priceService */
$priceService = App::make(PriceService::class);
/** @var CurrencyService $currencyService */
$currencyService = App::make(CurrencyService::class);
// ...
/** @var CartService $cartService */
$cartService = App::make(CartService::class);
/** @var WarehouseService $warehouseService */
$warehouseService = App::make(WarehouseService::class);
```

Чотири залежності, і жодної з них не згадано в конструкторі.

Чимала частина спаду - взагалі не рефакторинг. Із 18 викликів 10 зникли тільки тому, що видалили весь файл. `User::getCart()` з прикладу вище теж був мертвим кодом. Дії кошика задовго до того перейшли на впроваджений репозиторій кошика, і цей метод моделі викликав лише інший мертвий код. Він пішов разом із комітом «Cleanup» і кількома схожими викликами. Лише останній вимагав справжнього рефакторингу. Будьмо чесними: більшість таких викликів жила в старому коді, а старий код видаляють.

### Останній: модель, яка сама будувала свій первинний ключ

Останній виклик протримався до квітня 2026 року. Він жив у моделі `Order`, яка сама генерувала свій 8-значний id з префіксом року:

```php
// app/Models/Order.php, до квітня 2026
public function newUniqueId(): string
{
  $now = Date::now();
  /** @var PrimaryKeyIntegerGenerator $primaryKeyIntegerGenerator */
  $primaryKeyIntegerGenerator = app(PrimaryKeyIntegerGenerator::class);
  $primaryKeyIntegerGenerator
    ->setModel($this)
    ->setLockSeconds(config('limits.order.min_processing_time_lock'))
    ->setPrefix($now->format('y'))
    ->setBuilderAggregate(Order::query()->whereYear('created_at', $now));

  return strval($primaryKeyIntegerGenerator->generate());
}
```

Eloquent створює моделі через `new`, а не через контейнер, тож у конструктор моделі нічого не впровадиш. А `newUniqueId()` - хук, який Eloquent викликає сам, без аргументів. Усередині такого хука сервіс можна лише попросити: через `app()` або фасад. Тому **якщо моделі потрібен `app()`, логіка, найімовірніше, лежить не на своєму місці**.

Справедливості заради, тестуванню заважав не сам `app()`. У Laravel прив'язку можна підмінити через `$this->instance()` або `$this->mock()`. Справжня проблема була в тому, що специфічна для замовлень логіка (префікс, блокування, межі року) жила в хуку моделі. Коли я захотів протестувати граничні випадки (заблокований id, забагато спроб), спершу довелося цю логіку винести:

```php
// app/Actions/Order/OrderCreateAction.php, сьогодні
final readonly class OrderCreateAction implements Actionable
{
  public function __construct(
    // ...
    private OrderPrimaryKeyGenerator $orderPrimaryKeyGenerator,
    // ...
  )
  {
  }

  public function handle(OrderCreateDTO $orderCreateDTO, int $userId, ?int $managerId = null): Order
  {
    // ...
    $id = $this->orderPrimaryKeyGenerator->generate();

    $orderData['id'] = $id;
    $orderData['number'] = $id;
    // ...
  }
}
```

Компроміс такий: у моделі `$incrementing = false`, тож `Order::create()` в обхід дії не отримає id від Laravel. У нашому випадку обидві дії створення замовлення отримують генератор через впровадження, а фабрика задає власний id.

А тепер генератор має власний тест, і створювати замовлення для нього не треба:

```php
public function test_order_pk_skips_locked_id_and_tries_next(): void
{
  // Arrange
  $year = Date::now()->format('y');
  $lockedId = intval($year . '000001');
  Cache::lock(Order::class . ':' . $lockedId, 60)->get();

  // Act
  $id = (new OrderPrimaryKeyGenerator())->generate();

  // Assert
  $this->assertSame(intval($year . '000002'), $id);
}
```

Так, усередині генератор досі використовує фасади `Cache` і `Date`, `config()` та `Order::query()`. Тож тест і далі завантажує застосунок і звертається до бази даних. Це те саме застереження щодо меж, що й вище: фасади лишилися, а прихований пошук власного класу через `app()` зник.

Коміт, що прибрав останній виклик `app()`, називався «Test: Add failing unit tests for OrderPrimaryKeyGenerator». Його витіснив тест.

### Ні лінтера, ні блокувального рев'ю

Не було ні правила PHPStan, ні архітектурного тесту, ні рев'ю, яке б блокувало злиття.

За ці роки я кілька разів згадував про це колезі на код-рев'ю. Радше як зауваження, ніж як правило. Якось я навіть визнав, що сам іноді використовую `app()`, і сказав йому робити по-своєму. Мої власні нові виклики з'являлися ще кілька місяців після того. Судячи з `git blame`, я додав таких викликів більше, ніж він. Тож це не історія про виправлення чужого коду. Ми обидва писали ці виклики й обидва їх видаляли.

Записане правило врешті з'явилося. «Уникайте `app()`, надавайте перевагу впровадженню через конструктор» потрапило в настанови нашого проєкту у квітні 2026 року, коли лишався рівно один виклик. За два тижні не стало й його.

### Де app() не потрібен (і де він доречний)

Перш ніж тягнутися по `app()`, перевірте, чи Laravel і так не викликає ваш метод через контейнер. Він робить це в більшій кількості місць, ніж зазвичай думають:

- `handle()` у командах і завданнях у черзі;
- `rules()` і `authorize()` у form request (задокументовано);
- `after()` у form request (не задокументовано, але він теж проходить через `container->call()`).

Колись у нас таке було в кількох form request (грудень 2024 року):

```php
// app/Http/Requests/.../CartItemImportRequest.php, 2024
public function after(): array
{
  /** @var CartValidateImportFileAction $cartValidateImportFileAction */
  $cartValidateImportFileAction = App::make(CartValidateImportFileAction::class);

  return [
    function (Validator $validator) use ($cartValidateImportFileAction): void {
      $cartValidateImportFileAction->handle($validator, $this->file('import_file'));
    },
  ];
}
```

Зрештою ми відмовилися від цього хука з інших причин, тож справжньої версії «після» немає. Але `App::make()` тут ніколи не був потрібен. Ось як це могло б виглядати:

```php
// як це могло б виглядати: впровадження через метод
public function after(CartValidateImportFileAction $validateImportFile): array
{
  return [
    function (Validator $validator) use ($validateImportFile): void {
      $validateImportFile->handle($validator, $this->file('import_file'));
    },
  ];
}
```

Зверніть увагу: документація згадує впровадження залежностей для `rules()` і `authorize()`, але не для `after()`. Я перевірив на Laravel 12.43.1: впроваджений клас розв'язується, і хук спрацьовує. Старіші версії я не перевіряв. І ще одна пастка: Laravel передає валідатор в `after()` за іменем, тож не називайте свій впроваджений параметр `$validator`.

Де `app()` доречний: сервіс-провайдери, звісно. Код, який Laravel створює без контейнера, як-от моделі, коли логіку справді неможливо винести. Ліниве розв'язання чогось важкого, що потрібне лише в одній гілці коду. Список короткий. Майже все інше, з мого досвіду, мало бути параметром конструктора.

### Моє емпіричне правило

Не правило для команди, а лише те, чого мене навчила історія:

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

### Коротко

- `app(Foo::class)` розв'язує контейнер, але це все одно патерн Service Locator. Впровадження залежностей означає, що залежність приходить через сигнатуру.
- В одному реальному проєкті кількість таких викликів упала з піку в 18 до 0, поки код виріс приблизно втричі. Багато викликів просто померли разом зі старим кодом.
- Останній сидів у хуку моделі, і його витіснив тест. Записане правило з'явилося, коли лишався тільки він.
- `after()` у form request теж приймає впровадження через метод (не задокументовано, перевірено на Laravel 12.43.1).
