TeoreticQuiz

Laravel

Материал для подготовки к собеседованию (Middle / Senior). Термины на английском там, где это принято. Порядок и содержание — на основе исходного конспекта; примеры кода перенесены из скриншотов исходного документа в текст (по правилу проекта картинки не вставляем).

Содержание


Локализация

Локализация в Laravel позволяет создавать многоязычные приложения, обеспечивая поддержку различных языков и культур. Основные особенности:

  1. Файлы перевода: все переводы хранятся в директории lang/ в корне проекта (в старых версиях Laravel — resources/lang; в новых публикуется командой php artisan lang:publish). Каждый язык имеет свою папку (en, ru) с PHP- или JSON-файлами, где ключи соответствуют строкам перевода.
/lang
    /en
        messages.php
    /ru
        messages.php
  1. Использование переводов: для получения перевода используется функция __(). Например, __('messages.welcome') вернёт строку, соответствующую ключу welcome в файле messages.php.
  2. Параметризованные строки: можно передавать параметры в строки перевода. Например, __('messages.greeting', ['name' => 'John']) вернёт «Привет, John», если строка содержит Привет, :name (ключ без префикса файла, __('greeting', ...), ищется в JSON-переводах lang/ru.json).
  3. Выбор локали: локаль задаётся в config/app.php параметром locale; временно — App::setLocale('ru').
  4. Проверка доступных локалей: App::getLocale() возвращает текущую локаль, App::getFallbackLocale() (параметр fallback_locale) — запасную на случай отсутствия перевода.
  5. Форматирование дат и чисел: используются классы Carbon и NumberFormatter.
  6. Роутинг и локализация: локализованные маршруты через параметр в URL или группировку по локалям.
  7. Blade-шаблоны: функция __() (или директива @lang) для вывода переводов. Плюрализация — trans_choice().

Почта

Отправка почты в Laravel осуществляется встроенной системой. Основные особенности:

  1. Конфигурация: настройки в config/mail.php (mailer SMTP, Mailgun, Postmark, SES и т.д., хост, порт, учётные данные SMTP); ключи API Mailgun/Postmark/SES — в config/services.php.
  2. Использование фасада Mail: Mail::to($recipient)->send(new YourMailableClass());.
  3. Создание Mailable классов: классы, наследующие Mailable; создание — php artisan make:mail YourMailableClass.
  4. Шаблоны Blade: размещаются в resources/views/emails.
  5. Поддержка очередей: асинхронная отправка методом queue() вместо send().
  6. Тестирование почты: Mail::fake() для имитации без фактической доставки.
  7. Markdown-письма: упрощают форматирование и стилизацию.
  8. Логирование: отправленных писем для отладки (драйвер log).

Тестирование

Тестирование приложений в Laravel включает несколько ключевых аспектов:

  1. Типы тестов:
    • Unit-тесты — проверяют отдельные методы или функции.
    • Feature-тесты — проверяют функциональность, включая взаимодействие с базой данных и внешними сервисами.
  2. PHPUnit: основной инструмент (альтернатива — Pest). Тесты размещаются в директории tests.
  3. Создание тестов: php artisan make:test TestName. Для unit-тестов — флаг --unit.
  4. Ассерты: assertTrue(), assertDatabaseHas(), assertSee() и другие.
  5. Фейковые данные: Mail::fake(), Event::fake(), Queue::fake(), Http::fake(), Storage::fake() — имитируют внешние сервисы.
  6. Работа с базой данных: SQLite в памяти для скорости; миграции, сидеры, фабрики, трейт RefreshDatabase.
  7. HTTP-тесты: запросы к маршрутам методами get(), post(), put() и т.д.
  8. Тестирование аутентификации: методы для тестов аутентифицированных/неаутентифицированных пользователей (actingAs()).
  9. Параметризованные тесты: один тест с разными наборами данных (data providers).
  10. Запуск тестов: php artisan test или vendor/bin/phpunit.

Scout — поиск

Laravel Scout предоставляет простое решение на основе драйверов для добавления полнотекстового поиска в модели Eloquent. Используя наблюдателей (observers) моделей, Scout автоматически синхронизирует поисковые индексы с данными моделей Eloquent.

Добавьте трейт Laravel\Scout\Searchable к модели, которую хотите сделать доступной для поиска. Этот трейт зарегистрирует наблюдателя модели, который будет автоматически синхронизировать модель с вашим драйвером поиска:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Post extends Model
{
    use Searchable;
}

После настройки драйвера очереди установите значение параметра queue в config/scout.php в true — синхронизация будет выполняться в фоне:

'queue' => true,

Каждая модель Eloquent синхронизируется с заданным поисковым «индексом», который содержит все доступные для поиска записи для этой модели. Другими словами, можно думать о каждом индексе как о таблице MySQL. Имя индекса по умолчанию можно переопределить методом searchableAs:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Post extends Model
{
    use Searchable;

    /**
     * Переопределение имени индекса модели по умолчанию
     */
    public function searchableAs(): string
    {
        return 'posts_index';
    }
}

По умолчанию вся форма toArray данной модели будет сохранена в её поисковом индексе. Чтобы настроить данные, которые синхронизируются с индексом, переопределите метод toSearchableArray:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class Post extends Model
{
    use Searchable;

    /**
     * Переопределение массива индекса модели по умолчанию
     *
     * @return array<string, mixed>
     */
    public function toSearchableArray(): array
    {
        $array = $this->toArray();

        // Настраиваем массив данных...

        return $array;
    }
}

В отличие от других драйверов Scout, Meilisearch требует предварительного определения настроек поиска индекса — фильтруемых атрибутов, сортируемых атрибутов и других поддерживаемых полей:

use App\Models\User;
use App\Models\Flight;

'meilisearch' => [
    'host' => env('MEILISEARCH_HOST', 'http://localhost:7700'),
    'key'  => env('MEILISEARCH_KEY', null),
    'index-settings' => [
        User::class => [
            'filterableAttributes' => ['id', 'name', 'email'],
            'sortableAttributes'   => ['created_at'],
            // Другие поля настроек...
        ],
        Flight::class => [
            'filterableAttributes' => ['id', 'destination'],
            'sortableAttributes'   => ['updated_at'],
        ],
    ],
],

По умолчанию Scout использует первичный ключ модели в качестве уникального идентификатора / ключа модели, который хранится в индексе. Настроить это поведение можно, переопределив методы getScoutKey и getScoutKeyName:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Laravel\Scout\Searchable;

class User extends Model
{
    use Searchable;

    /**
     * Переопределение значения ключа индекса модели по умолчанию
     */
    public function getScoutKey(): mixed
    {
        return $this->email;
    }

    /**
     * Переопределение имени ключа индекса модели по умолчанию
     */
    public function getScoutKeyName(): mixed
    {
        return 'email';
    }
}

Использование драйвера database — самый быстрый способ начать работу с Scout: он использует полнотекстовые индексы MySQL/PostgreSQL и условия «where like» при фильтрации результатов из существующей базы данных. Ещё есть драйвер «коллекций» (collection) — использует условие «where» и фильтрацию набора результатов из БД; индексировать модели не нужно, они извлекаются из локальной базы (удобно локально). Также поддерживаются Algolia, Meilisearch, Typesense.

Импорт существующих записей в индекс — Artisan-команда scout:import; через очереди — scout:queue-import:

php artisan scout:import "App\Models\Post"
php artisan scout:queue-import "App\Models\Post" --chunk=500

Удаление всех записей из индекса — scout:flush:

php artisan scout:flush "App\Models\Post"

Синхронизация настроек индекса (например, с Algolia) — scout:sync-index-settings (можно включить в процесс деплоя):

php artisan scout:sync-index-settings

Добавить коллекцию моделей в индекс по запросу Eloquent — метод searchable (разобьёт результаты на блоки, при включённых очередях импортирует в фоне):

use App\Models\Order;

Order::where('price', '>', 100)->searchable();

Поиск — метод search; получить модели — get:

use App\Models\Order;

$orders = Order::search('Star Trek')->get();

Scout позволяет добавлять простые условия «where» (только базовые проверки числового равенства — полезно для ограничения по идентификатору владельца; сложные условия не поддерживаются, т.к. индекс — не реляционная БД):

use App\Models\Order;

$orders = Order::search('Star Trek')->where('user_id', 1)->get();

Пагинация результатов — метод paginate (вернёт Illuminate\Pagination\LengthAwarePaginator):

use App\Models\Order;

$orders = Order::search('Star Trek')->paginate();

Нововведения Laravel 12

По исходному конспекту к Laravel 12 отнесены: добавление пакета с ИИ, оптимизация, улучшения в тестировании, обновлённые starter kits.

Примечание по достоверности: примеры ниже (пакет laravel/prompts-ai, флаг make:test --ai, метод assertDatabaseOptimized(), таблица прироста производительности) взяты из исходного конспекта, но не являются частью официального фреймворка и, вероятно, иллюстративны/сгенерированы. На собеседовании их не стоит приводить как реальные фичи Laravel 12. Достоверное про Laravel 12 — упор на минимальные ломающие изменения и новые starter kits.

Пример из конспекта — генерация SEO-текста (иллюстративно):

use Laravel\PromptsAI\GPT;

$seoText = GPT::generate(
    model: 'gpt-4',
    prompt: 'Напиши описание для интернет-магазина велосипедов на русском, до 500 символов.',
    temperature: 0.7
);

Генерация тестов на основе AI (иллюстративно) — система анализирует код контроллера и генерирует базовые сценарии:

php artisan make:test UserRegistrationTest --ai

Проверка отсутствия N+1 (иллюстративно):

$this->get('/users')
    ->assertDatabaseOptimized();

Таблица прироста производительности из конспекта (иллюстративно):

Параметр Laravel 11 Laravel 12 Улучшение
Время обработки запроса (мс) 145 92 36%
Потребление памяти (МБ) 45 32 29%
Запросов в секунду 230 380 65%

Starter Kits. Обновлённые готовые шаблоны для быстрого старта: достаточно выбрать стек (React, Vue или Livewire) и приступить к разработке. Livewire Starter Kit включает бесплатные Flux-компоненты; компоненты загружаются из отдельных GitHub-репозиториев, что упрощает кастомизацию.

Достоверные вехи предыдущих версий: Laravel 9 — Symfony 6, PHP 8.0, каталог lang/; Laravel 10 — PHP 8.1, типизация скелета, слой Process; Laravel 11 — упрощённая структура (конфиг в bootstrap/app.php, нет Http/Kernel.php), расписание в routes/console.php, per-second rate limiting, health-роут, Reverb.


Сервис-контейнер, сервис-провайдеры, контракты, фасады, DI

Service Container

Service container — это мощный инструмент для управления зависимостями классов и выполнения внедрения зависимостей. Внедрение зависимостей (DI) по существу означает: зависимости классов «вводятся» в класс через конструктор в виде аргументов или через методы-сеттеры. При создании класса или вызове методов фреймворк смотрит на список аргументов и, если нужно, создаёт экземпляры необходимых классов и сам подаёт их на вход конструктора или метода.

По сути, это переменная $this->app \ App::.

Почти все связывания в контейнере регистрируются в Service Providers. Типичная регистрация:

// bind — новый экземпляр при каждом разрешении
$this->app->bind(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

// singleton — один экземпляр на всё приложение
$this->app->singleton(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

// scoped — один экземпляр на жизненный цикл запроса/задания
$this->app->scoped(Transistor::class, function (Application $app) {
    return new Transistor($app->make(PodcastParser::class));
});

Метод scoped связывает класс/интерфейс, который должен быть извлечён только один раз в течение данного жизненного цикла запроса / задания Laravel. Этот метод похож на singleton, но, в отличие от него, экземпляры scoped сбрасываются всякий раз, когда приложение запускает новый «жизненный цикл» — например, когда Laravel Octane обрабатывает новый запрос или когда очереди обрабатывают новое задание.

Извлечение экземпляра из контейнера — метод make (принимает имя класса или интерфейса):

use App\Services\Transistor;

$transistor = $this->app->make(Transistor::class);

В качестве альтернативы можно объявить тип зависимости в конструкторе класса, который извлекается контейнером (контроллеры, слушатели событий, посредники и т.д.), а также в методе handle заданий очереди. На практике именно так контейнер должен извлекать большинство объектов (autowiring):

<?php

namespace App\Http\Controllers;

use App\Services\AppleMusic;

class PodcastController extends Controller
{
    /**
     * Создать новый экземпляр контроллера.
     */
    public function __construct(
        protected AppleMusic $apple,
    ) {}

    /**
     * Показать информацию о данном подкасте.
     */
    public function show(string $id): Podcast
    {
        return $this->apple->findPodcast($id);
    }
}

Service Providers

Сервис-провайдеры — центральное место начальной загрузки всех приложений Laravel. Под «начальной загрузкой» понимается регистрация элементов: связываний контейнера служб, слушателей событий, посредников и даже маршрутов.

Важно: в методе register следует только связывать сущности в контейнере. Никогда не следует регистрировать слушателей событий, маршруты или что-то другое в register — иначе можно случайно воспользоваться подсистемой, чей сервис-провайдер ещё не загружен.

<?php

namespace App\Providers;

use App\Services\Riak\Connection;
use Illuminate\Contracts\Foundation\Application;
use Illuminate\Support\ServiceProvider;

class RiakServiceProvider extends ServiceProvider
{
    /**
     * Регистрация любых служб приложения.
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection(config('riak'));
        });
    }
}

Если провайдер регистрирует много простых связываний, используйте свойства bindings и singletons вместо ручной регистрации — фреймворк проверит их автоматически:

class AppServiceProvider extends ServiceProvider
{
    /**
     * Все связывания контейнера, которые должны быть зарегистрированы.
     *
     * @var array
     */
    public $bindings = [
        ServerProvider::class => DigitalOceanServerProvider::class,
    ];

    /**
     * Все синглтоны контейнера, которые должны быть зарегистрированы.
     *
     * @var array
     */
    public $singletons = [
        DowntimeNotifier::class => PingdomDowntimeNotifier::class,
        ServerProvider::class   => ServerToolsProvider::class,
    ];
}

Регистрация компоновщика шаблонов делается в методе boot — он вызывается после регистрации всех остальных провайдеров, поэтому там уже доступны все службы:

<?php

namespace App\Providers;

use Illuminate\Support\Facades\View;
use Illuminate\Support\ServiceProvider;

class ComposerServiceProvider extends ServiceProvider
{
    /**
     * Загрузка любых служб приложения.
     */
    public function boot(): void
    {
        View::composer('view', function () {
            // ...
        });
    }
}

Все поставщики регистрируются в bootstrap/providers.php:

<?php

return [
    App\Providers\AppServiceProvider::class,
];

Deferred providers. Чтобы отложить загрузку провайдера, реализуйте интерфейс Illuminate\Contracts\Support\DeferrableProvider и метод provides, который возвращает связывания, регистрируемые данным классом:

class RiakServiceProvider extends ServiceProvider implements DeferrableProvider
{
    /**
     * Регистрация любых служб приложения.
     */
    public function register(): void
    {
        $this->app->singleton(Connection::class, function (Application $app) {
            return new Connection($app['config']['riak']);
        });
    }

    /**
     * Получить службы, предоставляемые поставщиком.
     *
     * @return array<int, string>
     */
    public function provides(): array
    {
        return [Connection::class];
    }
}

Facades (фасады)

Фасады предоставляют «статический» интерфейс для классов, доступных в контейнере служб приложения. Laravel из коробки включает множество фасадов. Пользовательские фасады расширяют базовый класс Illuminate\Support\Facades\Facade и переопределяют getFacadeAccessor (возвращает ключ связывания в контейнере):

class Student {
    public function students() {
        return 'Sean';
    }
}

app()->bind('student', function () {
    return new Student;
});
class StudentFacade extends Facade {
    protected static function getFacadeAccessor() {
        return 'student';
    }
}

Одно из основных преимуществ DI — возможность изменения реализации внедрённого класса (полезно при тестировании: можно вставить mock/stub и утверждать, что для заглушки были вызваны методы).

Contracts и суть DI

Внедрение зависимости (Dependency injection, DI) — процесс предоставления внешней зависимости программному компоненту. Является специфичной формой «инверсии управления» (Inversion of control, IoC), применённой к управлению зависимостями. В соответствии с принципом единственной ответственности объект отдаёт заботу о построении требуемых ему зависимостей внешнему механизму.

Contracts — набор интерфейсов ядра Laravel; зависимость от контракта вместо конкретной реализации даёт слабую связанность (принцип DIP из SOLID).


Жизненный цикл запроса

Первые шаги. Точка входа для всех запросов — public/index.php. Все запросы направляются в этот файл конфигурацией веб-сервера (Apache/Nginx). Файл index.php загружает автозагрузчик Composer, затем извлекает экземпляр приложения Laravel из bootstrap/app.php. Первое действие самого Laravel — создание экземпляра приложения / контейнера служб.

HTTP-ядро и ядро консоли. Входящий запрос отправляется либо HTTP-ядру, либо ядру консоли (методы handleRequest / handleCommand). HTTP-ядро (Illuminate\Foundation\Http\Kernel) определяет массив загрузчиков (bootstrappers), запускающихся до выполнения запроса: настройка обработки ошибок, логирования, определение среды приложения. HTTP-ядро также передаёт запрос через стек посредников (сессия, режим обслуживания, проверка CSRF-токена и т.д.). Сигнатура метода handle проста: получает Request — возвращает Response.

Сервис-провайдеры. Одно из важнейших действий инициализации ядра — загрузка сервис-провайдеров (настройка БД, очередей, валидации, маршрутизации). Laravel создаёт экземпляр каждого провайдера, вызывает у всех метод register, а затем у всех — метод boot. Поэтому к моменту boot все связывания контейнера уже зарегистрированы и доступны.

Маршрутизация. После загрузки приложения Request передаётся маршрутизатору, который отправит его на маршрут/контроллер и запустит посредников конкретного маршрута.

Окончание. Когда метод маршрута/контроллера вернёт ответ, ответ проходит обратно через посредников маршрута (возможность изменить/проверить исходящий ответ). Затем метод handle ядра возвращает объект ответа в handleRequest, и вызывается метод send, который отправляет содержимое ответа в браузер. Жизненный цикл завершён.


Виды пагинации

В Laravel существует несколько видов пагинации, каждый со своими особенностями и преимуществами.

1. Стандартная пагинация — paginate()

$users = User::paginate(15);

Преимущества:

  • Простой и интуитивно понятный способ получения данных.
  • Автоматически генерирует ссылки для навигации между страницами.
  • Легко интегрируется с Blade-шаблонами с помощью метода links().

(Особенность: считает общее число записей через COUNT, что дорого на очень больших таблицах.)

2. simplePaginate()

$users = User::simplePaginate(15);

Не вычисляет общее количество записей, что эффективнее для больших наборов данных.

Преимущества:

  • Более высокая производительность на больших таблицах (не нужно вычислять общее количество записей).
  • Подходит, когда нет необходимости в точном количестве страниц (навигация «назад/вперёд»).

3. cursorPaginate()

$users = User::orderBy('id')->cursorPaginate(15);

Пагинация на основе курсора, особенно полезна для динамических наборов данных.

Преимущества:

  • Эффективен для больших наборов данных и потоковой обработки.
  • Уменьшает вероятность пропуска или дублирования записей при изменении данных между запросами.

В то время как paginate и simplePaginate создают запросы с использованием SQL-оператора «offset», cursor-пагинация работает путём создания конструкции «where», которая сравнивает значения упорядоченных столбцов — это обеспечивает наилучшую производительность среди всех методов пагинации Laravel. Особенно хорошо подходит для больших наборов данных и интерфейсов с «бесконечной» прокруткой.

В отличие от offset-пагинации (номер страницы в query-строке), cursor-пагинация помещает в query-строку «cursor» — закодированную строку с местом и направлением следующего запроса:

http://localhost/users?cursor=eyJpZCI6MTUsIl9wb2ludHNUb05leHRJdGVtcyI6dHJ1ZX0

Несколько экземпляров пагинации на странице. Если оба пагинатора используют параметр page, они конфликтуют. Разрешается через третий аргумент — имя параметра query-строки:

use App\Models\User;

$users = User::where('votes', '>', 100)->paginate(
    $perPage = 15, $columns = ['*'], $pageName = 'users'
);

Преимущества cursor-пагинации над offset: лучшая производительность на больших наборах (offset сканирует все ранее сопоставленные данные, если столбцы order by проиндексированы); при частых записях offset может пропускать записи или показывать дубли.

Ограничения cursor-пагинации: только ссылки «Далее»/«Назад» (нет ссылок с номерами страниц); порядок должен быть основан минимум на одном уникальном столбце (или комбинации), столбцы с null не поддерживаются; выражения «order by» поддерживаются только с псевдонимом и добавлением в «select»; выражения с параметрами не поддерживаются.


Scopes — глобальные и локальные

Глобальный скоуп. Создайте класс командой make:scope, реализующий интерфейс Illuminate\Database\Eloquent\Scope с методом apply:

<?php

namespace App\Models\Scopes;

use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Scope;

class AncientScope implements Scope
{
    /**
     * Применить диапазон к переданному построителю запросов.
     */
    public function apply(Builder $builder, Model $model): void
    {
        $builder->where('created_at', '<', now()->subYears(2000));
    }
}

Назначить глобальный скоуп можно атрибутом ScopedBy:

<?php

namespace App\Models;

use App\Models\Scopes\AncientScope;
use Illuminate\Database\Eloquent\Attributes\ScopedBy;

#[ScopedBy([AncientScope::class])]
class User extends Model
{
    //
}

Либо через метод booted модели:

class User extends Model
{
    /**
     * Метод «booted» модели.
     */
    protected static function booted(): void
    {
        static::addGlobalScope(new AncientScope);
    }
}

Локальные скоупы позволяют определять общие наборы ограничений для повторного использования. Диапазоны должны всегда возвращать тот же экземпляр построителя запросов или void. Современный синтаксис — атрибут #[Scope] на методе:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Attributes\Scope;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * Диапазон запроса, включающий только популярных пользователей.
     */
    #[Scope]
    protected function popular(Builder $query): void
    {
        $query->where('votes', '>', 100);
    }

    /**
     * Диапазон запроса, включающий только активных пользователей.
     */
    #[Scope]
    protected function active(Builder $query): void
    {
        $query->where('active', 1);
    }
}

Вызов: User::popular()->active()->get();. В старом синтаксисе метод назывался с префиксом scope (scopePopular), а вызывался без него (popular()).


Аксессоры и мутаторы

Аксессор (get) преобразует значение атрибута экземпляра Eloquent при обращении к нему. Мутатор (set) преобразует значение атрибута в момент его присвоения. Современный синтаксис (Laravel 9+) — один метод, возвращающий Attribute:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Model;

class User extends Model
{
    /**
     * Манипуляции с именем пользователя
     */
    protected function firstName(): Attribute
    {
        return Attribute::make(
            get: fn (string $value) => ucfirst($value),
            set: fn (string $value) => strtolower($value),
        );
    }
}

Casts — аналог свойства $casts модели: автоприведение типов атрибутов (array, boolean, datetime, encrypted, enum). Можно создавать свои кастомные касты (CastsAttributes).


Jobs — очереди

Параметры конфигурации очереди хранятся в config/queue.php. Драйверы: база данных, Amazon SQS, Redis, Beanstalkd, синхронный (sync, немедленное выполнение — для локальной разработки) и null (выбрасывает задания, не исполняя). Laravel предлагает Horizon — панель мониторинга и систему настройки для очередей на базе Redis.

Диспетчеризация задания и выбор очереди:

use App\Jobs\ProcessPodcast;

// Задание отправляется в очередь `default` соединения по умолчанию
ProcessPodcast::dispatch();

// Задание отправляется в очередь `emails` соединения по умолчанию
ProcessPodcast::dispatch()->onQueue('emails');

Цепочка заданий — список заданий, выполняемых последовательно после успешного основного (если одно упало — остальные не выполняются). Через метод chain фасада Bus:

use App\Jobs\OptimizePodcast;
use App\Jobs\ProcessPodcast;
use App\Jobs\ReleasePodcast;
use Illuminate\Support\Facades\Bus;

Bus::chain([
    new ProcessPodcast,
    new OptimizePodcast,
    new ReleasePodcast,
])->dispatch();

Анонимные задания — вместо класса можно отправить функцию (содержимое криптографически подписывается, чтобы его нельзя было изменить при передаче):

$podcast = App\Podcast::find(1);

dispatch(function () use ($podcast) {
    $podcast->publish();
});

Обработчики очереди. queue:listen не требует ручного перезапуска при изменении кода, но значительно менее эффективен, чем queue:work:

php artisan queue:listen

Приоритет очередей — порядок в аргументе --queue:

dispatch((new Job)->onQueue('high'));
php artisan queue:work --queue=high,low

Supervisor — диспетчер процессов для Linux, автоматически перезапускает процессы queue:work при сбое:

sudo apt-get install supervisor

Events & listeners — события и слушатели

События Laravel обеспечивают простую реализацию шаблона Наблюдатель. Классы событий хранятся в app/Events, слушатели — в app/Listeners. Создание:

php artisan make:event PodcastProcessed
php artisan make:listener SendPodcastNotification --event=PodcastProcessed

Слушатель обрабатывает событие в методе handle; можно слушать несколько событий через union-типы:

use App\Events\PodcastProcessed;

class SendPodcastNotification
{
    /**
     * Handle the event.
     */
    public function handle(PodcastProcessed $event): void
    {
        // ...
    }
}

// Несколько событий:
public function handle(PodcastProcessed|PodcastPublished $event): void
{
    // ...
}

Класс события — контейнер данных:

<?php

namespace App\Events;

use App\Models\Order;
use Illuminate\Broadcasting\InteractsWithSockets;
use Illuminate\Foundation\Events\Dispatchable;
use Illuminate\Queue\SerializesModels;

class OrderShipped
{
    use Dispatchable, InteractsWithSockets, SerializesModels;

    /**
     * Создать новый экземпляр события.
     */
    public function __construct(
        public Order $order,
    ) {}
}

Слушатель:

<?php

namespace App\Listeners;

use App\Events\OrderShipped;

class SendShipmentNotification
{
    public function __construct() {}

    /**
     * Обработать событие.
     */
    public function handle(OrderShipped $event): void
    {
        // Доступ к заказу с помощью $event->order ...
    }
}

Чтобы слушатель ставился в очередь, добавьте ему интерфейс ShouldQueue.

Подписчики событий — классы, подписывающиеся на несколько событий; определяют метод subscribe, получающий диспетчер:

<?php

namespace App\Listeners;

use Illuminate\Auth\Events\Login;
use Illuminate\Auth\Events\Logout;
use Illuminate\Events\Dispatcher;

class UserEventSubscriber
{
    public function handleUserLogin(Login $event): void {}
    public function handleUserLogout(Logout $event): void {}

    /**
     * Зарегистрировать слушателей для подписчика.
     */
    public function subscribe(Dispatcher $events): void
    {
        $events->listen(Login::class,  [UserEventSubscriber::class, 'handleUserLogin']);
        $events->listen(Logout::class, [UserEventSubscriber::class, 'handleUserLogout']);
    }
}

Регистрация подписчика:

class AppServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        Event::subscribe(UserEventSubscriber::class);
    }
}

События модели. Eloquent инициирует хуки жизненного цикла: retrieved, creating, created, updating, updated, saving, saved, deleting, deleted, trashed, forceDeleting, forceDeleted, restoring, restored, replicating. Их можно сопоставить с классами событий через $dispatchesEvents:

<?php

namespace App\Models;

use App\Events\UserDeleted;
use App\Events\UserSaved;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
    use Notifiable;

    /**
     * Карта событий для модели.
     *
     * @var array<string, string>
     */
    protected $dispatchesEvents = [
        'saved'   => UserSaved::class,
        'deleted' => UserDeleted::class,
    ];
}

Метод boot в модели

Метод boot в модели используется для выполнения кода при инициализации модели. Он вызывается автоматически при загрузке класса модели и обычно используется для настройки глобальных параметров, добавления событий, применения наблюдателей или определения других условий, применяемых ко всем экземплярам модели:

protected static function boot()
{
    parent::boot();

    static::creating(function ($model) {
        // Логика перед созданием модели
    });
}

Глобальные скоупы также можно применять здесь, чтобы автоматически фильтровать результаты запросов.


Хэширование — Hash

Фасад Hash обеспечивает безопасное хеширование Bcrypt и Argon2 для хранения паролей. При использовании стартового комплекта по умолчанию используется Bcrypt.

Bcrypt — отличный выбор, потому что его «коэффициент работы» (work factor) регулируется: время генерации хеша можно увеличивать по мере роста мощности оборудования. При хешировании паролей — чем медленнее, тем лучше: тем дороже злоумышленнику строить «радужные таблицы».

Хеширование и проверка:

Hash::make($request->newPassword);
if (Hash::check('plain-text', $hashedPassword)) {
    // Пароли совпадают...
}

Различия argon и bcrypt:

1. Алгоритмы. Bcrypt: адаптивное хеширование с солью; стандарт, широко используется; в Laravel по умолчанию. Argon2: более новый, победитель Password Hashing Competition (PHC); режимы Argon2i и Argon2d под разные типы атак; гибче настраивается.

2. Безопасность. Bcrypt: безопасен, но скорость может быть проблемой на современных устройствах. Argon2: выше защита за счёт адаптации к росту вычислительных мощностей и устойчивости к атакам.

3. Настройки. Bcrypt: стоимость хеширования (cost factor — число итераций). Argon2: три параметра — время выполнения (time cost), использование памяти (memory cost), параллелизм (parallelism).


Ключ приложения (key:generate)

APP_KEY (генерируется командой php artisan key:generate) — секретный ключ, на базе которого во фреймворке всё шифруется.

  1. Шифрование данных: Laravel использует APP_KEY для шифрования. При смене ключа все данные, зашифрованные старым ключом, станут недоступны. Влияет на: защиту сессий, шифрование пользовательских данных, шифрование куки.
  2. Сессии: при шифровании сессий после смены ключа все существующие сессии станут недоступны — пользователи будут разлогинены и должны войти заново.
  3. Куки: зашифрованные данные в куках также станут недоступны.
  4. Безопасность: смена ключа полезна для повышения безопасности, особенно при подозрении на компрометацию.
  5. Миграция данных: зашифрованные данные, которые нужно сохранить, нужно сначала расшифровать старым ключом, затем зашифровать новым.

Ключ хранится в .env и не должен попадать в репозиторий.


Middleware (посредники)

Посредники оборачивают обработку HTTP-запроса — фильтрация и модификация запроса/ответа:

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class EnsureTokenIsValid
{
    /**
     * Обработка входящего запроса.
     */
    public function handle(Request $request, Closure $next): Response
    {
        if ($request->input('token') !== 'my-secret-token') {
            return redirect('/home');
        }

        return $next($request);
    }
}

Глобальный стек посредников — запуск на каждый HTTP-запрос; регистрируется в bootstrap/app.php:

use App\Http\Middleware\EnsureTokenIsValid;

->withMiddleware(function (Middleware $middleware): void {
    $middleware->append(EnsureTokenIsValid::class);
})

Исключение посредника для отдельного маршрута группы — withoutMiddleware:

use App\Http\Middleware\EnsureTokenIsValid;

Route::middleware([EnsureTokenIsValid::class])->group(function () {
    Route::get('/', function () {
        // ...
    });

    Route::get('/profile', function () {
        // ...
    })->withoutMiddleware([EnsureTokenIsValid::class]);
});

Посредник с параметрами — через : после имени:

use App\Http\Middleware\EnsureUserHasRole;

Route::put('/post/{id}', function (string $id) {
    // ...
})->middleware(EnsureUserHasRole::class.':editor');

Завершающий посредник (terminable). Метод terminate выполняется после отправки ответа в браузер (при использовании FastCGI):

<?php

namespace Illuminate\Session\Middleware;

use Closure;
use Illuminate\Http\Request;
use Symfony\Component\HttpFoundation\Response;

class TerminatingMiddleware
{
    public function handle(Request $request, Closure $next): Response
    {
        return $next($request);
    }

    /**
     * Обработать задачи после отправки ответа в браузер.
     */
    public function terminate(Request $request, Response $response): void
    {
        // ...
    }
}

Чтобы использовать один и тот же экземпляр посредника в handle и terminate, зарегистрируйте его как singleton в register вашего AppServiceProvider:

use App\Http\Middleware\TerminatingMiddleware;

public function register(): void
{
    $this->app->singleton(TerminatingMiddleware::class);
}

Модели и связи

Eloquent — ActiveRecord-ORM. Миграции версионируют схему, сидеры наполняют данными, фабрики генерируют фейковые модели.

Один ко многим (hasMany) с методом chaperone() (автоматически проставляет обратную связь у дочерних моделей, устраняя лишние запросы):

$posts = Post::with('comments')->get();

foreach ($posts as $post) {
    foreach ($post->comments as $comment) {
        echo $comment->post->title;
    }
}
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Post extends Model
{
    /**
     * Get the comments for the blog post.
     */
    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class)->chaperone();
    }
}

belongsTo с дефолтом (withDefault — вернёт «пустую» модель вместо null):

/**
 * Получить автора поста.
 */
public function user(): BelongsTo
{
    return $this->belongsTo(User::class)->withDefault([
        'name' => 'Guest Author',
    ]);
}

hasOne с выбором одной из многих (latestOfMany):

/**
 * Получить последний (самый новый) заказ пользователя
 */
public function latestOrder(): HasOne
{
    return $this->hasOne(Order::class)->latestOfMany();
}

Has One Through — доступ к далёкой модели через промежуточную:

mechanics
    id - integer
    name - string

cars
    id - integer
    model - string
    mechanic_id - integer

owners
    id - integer
    name - string
    car_id - integer

Has Many Through:

applications
    id - integer
    name - string

environments
    id - integer
    application_id - integer
    name - string

deployments
    id - integer
    environment_id - integer
    commit_hash - string

withAttributes — дополнительные условия и значения для связи:

/**
 * Get the user's featured posts.
 */
public function featuredPosts(): HasMany
{
    return $this->posts()->withAttributes(['featured' => true]);
}

Фильтрация many-to-many по pivot:

return $this->belongsToMany(Role::class)
    ->wherePivot('approved', 1);

return $this->belongsToMany(Role::class)
    ->wherePivotIn('priority', [1, 2]);

return $this->belongsToMany(Role::class)
    ->wherePivotNotIn('priority', [1, 2]);
return $this->belongsToMany(Badge::class)
    ->where('rank', 'gold')
    ->orderByPivot('created_at', 'desc');

Кастомная pivot-модель (using):

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class Role extends Model
{
    /**
     * Пользователи, принадлежащие к роли.
     */
    public function users(): BelongsToMany
    {
        return $this->belongsToMany(User::class)->using(RoleUser::class);
    }
}
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Relations\Pivot;

class RoleUser extends Pivot
{
    // ...
}

Полиморфная связь (один к одному). Схема таблиц:

posts
    id - integer
    name - string

users
    id - integer
    name - string

images
    id - integer
    url - string
    imageable_id - integer
    imageable_type - string
<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Image extends Model
{
    /**
     * Получить родительскую модель (пользователя или пост).
     */
    public function imageable(): MorphTo
    {
        return $this->morphTo();
    }
}

class Post extends Model
{
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

class User extends Model
{
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

Жадная (eager) загрузка. При доступе к отношениям как к свойствам связанные модели загружаются отложенно (lazy), что ведёт к проблеме N+1. Eloquent может загрузить отношения жадно во время запроса родительской модели.

Проблема N+1 (на каждую книгу — отдельный запрос за автором):

use App\Models\Book;

$books = Book::all();

foreach ($books as $book) {
    echo $book->author->name;
}

Решение — with:

$books = Book::with('author')->get();

foreach ($books as $book) {
    echo $book->author->name;
}

Вложенная и множественная жадная загрузка:

$books = Book::with('author.contacts')->get();

$books = Book::with([
    'author' => [
        'contacts',
        'publisher',
    ],
])->get();

Загрузка отношения всегда (свойство $with модели):

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Book extends Model
{
    /**
     * Отношения, которые всегда должны быть загружены.
     *
     * @var array
     */
    protected $with = ['author'];
}

Отложенная жадная загрузка (load) и loadMissing (догружает только отсутствующее):

use App\Models\Book;

$books = Book::all();

if ($condition) {
    $books->load('author', 'publisher');
}
$book->loadMissing('author');

Аутентификация / Sanctum / Passport / OAuth2

Passport — провайдер аутентификации OAuth2, предлагающий различные OAuth2 Grant Types для выдачи разных типов токенов. Надёжный и сложный пакет для аутентификации API. Однако большинству приложений не нужен весь функционал OAuth2, что может путать пользователей и разработчиков; исторически было неясно, как аутентифицировать SPA/мобильные приложения через OAuth2-провайдеры вроде Passport.

Sanctum — более простой и оптимизированный пакет аутентификации, обрабатывающий как сторонние веб-запросы из браузера, так и запросы API через токены. Предпочтительный и рекомендуемый пакет: подходит для приложений с собственным веб-интерфейсом и API, для SPA (существующего отдельно от бэкенда) и для мобильных клиентов.

Sanctum — гибридный пакет Web/API. Когда приложение получает запрос, Sanctum сначала определяет, содержит ли запрос cookie сессии, ссылающийся на аутентифицированную сессию (через встроенные службы аутентификации Laravel). Если запрос не аутентифицирован cookie сессии, Sanctum проверит наличие токена API и аутентифицирует по нему.

Две основные возможности Sanctum:

  1. Токены API / персональные токены доступа (вдохновлено GitHub): пользователь может сгенерировать токен для своей учётной записи в настройках. Токены обычно долгоживущие (годы), но могут быть отозваны в любой момент. Токен передаётся в заголовке Authorization как Bearer-токен. Модель User должна использовать трейт HasApiTokens:
use Laravel\Sanctum\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
}
  1. Аутентификация SPA (в том же или отдельном репозитории — Next.js, Nuxt): Sanctum не использует токены, а применяет встроенную аутентификацию сессии на основе cookie (охранник web). Это даёт защиту от CSRF, аутентификацию сессии и защиту от утечки учётных данных через XSS.

OAuth 2.0 — общая суть

OAuth 2.0 — это протокол авторизации. Он нужен, чтобы одно приложение могло получить ограниченный доступ к данным или действиям пользователя в другом сервисе без передачи логина и пароля. В Laravel OAuth2 всплывает, когда нужно: сделать API с токенами доступа; дать доступ мобильному приложению или SPA-фронтенду; разрешить вход через внешний сервис; выдать стороннему приложению доступ к API пользователя.

Важно: OAuth2 — не про аутентификацию в чистом виде, а именно про авторизацию. Вопрос OAuth2: «Что этому клиенту разрешено делать?», а не «Кто это вообще такой?».

Без OAuth2 приложение просило бы логин/пароль от другого сервиса — это небезопасно (пароль получает стороннее приложение, нельзя гибко ограничить и отозвать доступ). OAuth2 решает это через access token: пользователь подтверждает доступ → сервер авторизации выдаёт токен → приложение ходит в API с токеном → токен можно ограничить по сроку/правам и отозвать.

Основные сущности OAuth2:

  1. Resource Owner — пользователь, владелец данных.
  2. Client — приложение, которое хочет доступ (SPA, мобильное приложение, сторонний сервис, backend другого приложения).
  3. Authorization Server — сервер, выдающий токены (в Laravel с Passport это может быть твоё приложение).
  4. Resource Server — сервер с защищёнными ресурсами/API (часто это же Laravel-приложение).
  5. Access Token — токен доступа для запросов к API.
  6. Refresh Token — позволяет получить новый access token без повторного логина.
  7. Scope — ограничение прав токена (read-profile, create-orders, delete-users).

OAuth2 vs сессия. Session-based auth: логин через форму, сервер хранит сессию, браузер носит cookie — для обычных сайтов. OAuth2 / token-based: сервер выдаёт токен, клиент шлёт токен в заголовке — для API, мобильных клиентов, SPA, интеграций.

OAuth2 vs JWT. OAuth2 — это протокол (набор правил: как получать/обновлять токен, роли). JWT — это формат токена. Можно использовать OAuth2 с JWT или без, и JWT без OAuth2. Концептуально: OAuth2 != JWT.

Преимущества OAuth2: не нужно отдавать пароль сторонним приложениям; можно ограничить доступ по правам и по времени; можно отозвать конкретный токен; подходит для API и микросервисов; стандартный подход. Сложности: протокол заметно сложнее обычной авторизации; легко запутаться в grant types; при неправильной реализации небезопасно; для простого проекта избыточен.


Broadcasting (сокеты + channels)

Laravel упрощает «вещание» серверных событий через соединение WebSocket, позволяя использовать одни и те же имена событий и данные между бэкендом Laravel и клиентским JS-приложением. Клиенты подключаются к именованным каналам во фронтенде, а приложение транслирует события на эти каналы.

События транслируются по «каналам», которые могут быть публичными или частными. На публичный канал может подписаться любой без аутентификации; на частный — только аутентифицированный и авторизованный пользователь.

Событие указывает канал(ы) в методе broadcastOn:

use Illuminate\Broadcasting\Channel;
use Illuminate\Broadcasting\PrivateChannel;

/**
 * Получить каналы трансляции события.
 */
public function broadcastOn(): Channel
{
    return new PrivateChannel('orders.'.$this->order->id);
}

Авторизация приватного канала — в routes/channels.php:

use App\Models\Order;
use App\Models\User;

Broadcast::channel('orders.{orderId}', function (User $user, int $orderId) {
    return $user->id === Order::findOrNew($orderId)->user_id;
});

Клиент (Laravel Echo, пример на React):

import { useEcho } from "@laravel/echo-react";

useEcho(
    `orders.${orderId}`,
    "OrderShipmentStatusUpdated",
    (e) => {
        console.log(e.order);
    },
);

Драйверы: Laravel Reverb (собственный WebSocket-сервер, с v11), Pusher, Ably, Redis + Socket.io.


Политики и Gates

Laravel предлагает два основных способа авторизации действий: Gates (шлюзы) и Policies (политики). Аналогия: шлюзы и политики — как маршруты и контроллеры. Шлюзы — простой подход на замыканиях; политики группируют логику вокруг конкретной модели/ресурса. В большинстве приложений используется комбинация обоих: Gates — для действий, не связанных с моделью (например, просмотр админ-панели), Policies — для авторизации действий над конкретной моделью.

Gate определяется в boot (например, в AppServiceProvider):

use App\Models\Post;
use App\Models\User;
use Illuminate\Support\Facades\Gate;

public function boot(): void
{
    Gate::define('update-post', function (User $user, Post $post) {
        return $user->id === $post->user_id;
    });
}

Проверка Gate:

<?php

namespace App\Http\Controllers;

use App\Models\Post;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Gate;

class PostController extends Controller
{
    public function update(Request $request, Post $post): RedirectResponse
    {
        if (! Gate::allows('update-post', $post)) {
            abort(403);
        }

        // Обновление поста...

        return redirect('/posts');
    }
}

Политики — классы, организующие логику авторизации для конкретной модели (App\Policies\PostPolicy для App\Models\Post). Регистрация связи модели и политики:

use App\Models\Order;
use App\Policies\OrderPolicy;
use Illuminate\Support\Facades\Gate;

public function boot(): void
{
    Gate::policy(Order::class, OrderPolicy::class);
}

Пример политики:

<?php

namespace App\Policies;

use App\Models\Post;
use App\Models\User;

class PostPolicy
{
    /**
     * Определить, может ли пользователь обновить пост.
     */
    public function update(User $user, Post $post): bool
    {
        return $user->id === $post->user_id;
    }
}

Проверки: $user->can('update', $post), $this->authorize('update', $post) в контроллере, @can('update', $post) в Blade.


Защита и безопасность

Защита CSRF

CSRF (cross-site request forgery) — атака, при которой сайт заставляет уже авторизованного пользователя незаметно отправить запрос от своего имени. В Laravel защита от CSRF есть «из коробки» для web-маршрутов.

Пример атаки: ты вошёл в интернет-магазин (в браузере хранится сессия) → заходишь на вредоносный сайт → он отправляет POST-запрос на магазин (например, смена email или удаление аккаунта) → браузер автоматически приложит cookie сессии → сервер может подумать, что это легитимный запрос.

Как Laravel защищает: сервер генерирует CSRF-токен для сессии → токен вставляется в форму → при отправке сервер проверяет совпадение → если токена нет или он неверный, запрос отклоняется. В формах — @csrf, для AJAX — заголовок X-CSRF-TOKEN / X-XSRF-TOKEN. API на токенах от CSRF не зависит.

Прочие типы атак и защита

1. SQL Injection. Laravel защищает через Query Builder, Eloquent ORM и подготовленные запросы (prepared statements). Безопасно и опасно:

// Безопасно — значение не вставляется в SQL вручную
$user = DB::table('users')->where('email', $email)->first();

// Опасно — конкатенация в сырой SQL
$user = DB::select("SELECT * FROM users WHERE email = '$email'");

2. XSS. Защита через экранирование вывода в Blade:

{{ $name }}

{{ }} экранирует вывод; {!! !!} — не экранирует (использовать осторожно).

3. Mass Assignment. Если без ограничений принимать все поля из запроса, пользователь может подменить то, что не должен (например is_admin). Защита — $fillable (белый список) и $guarded (чёрный список).

4. Session Hijacking / защита сессий. Шифрование cookies, httpOnly, same_site, secure для HTTPS, регенерация session ID после логина.

5. Хранение паролей. Пароли не хранятся в открытом виде — безопасное хеширование bcrypt/argon2:

Hash::make($password);
Hash::check($plainPassword, $hashedPassword);

6. Подделка/чтение cookies. Laravel умеет шифровать cookies, подписывать данные, защищать часть клиентских данных от подмены.

9. Rate limiting / brute force. Защищает от перебора логина, спама запросами, abuse API (см. раздел Rate Limiting).

12. CORS / cross-origin. Laravel позволяет настраивать CORS — контролировать, какие внешние источники могут обращаться к приложению из браузера. Это не универсальная защита от взлома, а важная часть безопасности веб-приложения.


Кэширование

1. Кэш приложения (framework-level). Route Caching сохраняет все маршруты в один скомпилированный файл, чтобы Laravel не парсил файлы роутов на каждом запросе (ускоряет загрузку, особенно при большом числе маршрутов):

php artisan route:cache

Аналогичные механизмы:

config:cache — объединяет конфигурацию,
route:cache  — маршруты,
view:cache   — Blade-шаблоны,
event:cache  — события и слушатели.

Все эти команды уменьшают время загрузки приложения, но применяются на production, потому что при изменениях кэш нужно пересобирать.

2. Кэш данных. Кэш, который используешь ты сам в коде: результаты запросов к БД, тяжёлые вычисления, ответы внешних API, собранные списки/статистика/настройки. Обычно через фасад Cache:

Cache::put('key', $value, 600);
$value = Cache::remember('users', 600, fn () => User::all()); // get-or-compute
Cache::forget('key');

Драйверы: file, database, redis, memcached, array (для тестов). Redis/Memcached предпочтительны на проде. Теги (Cache::tags) — групповая инвалидация (redis/memcached); атомарные блокировки (Cache::lock) — против гонок.


Blade и компоновщик

Blade — шаблонизатор: {{ }} (с экранированием), {!! !!} (без), директивы @if/@foreach/@auth/@can, наследование @extends/@section/@yield, @include. Компилируется в PHP и кэшируется.

Blade-компоненты. Создание и использование:

php artisan make:component Alert
<x-alert type="success" :message="$message" />

Шаблон компонента:

<div class="alert alert-{{ $type }}">
    {{ $message }}
</div>

View Composer — способ автоматически передавать данные в определённые представления. Вместо повторения в каждом контроллере:

return view('profile', [
    'categories' => Category::all()
]);

можно централизованно сказать: «когда рендерится такой-то view, подставляй такие-то данные». Регистрируется в сервис-провайдере (AppServiceProvider):

use Illuminate\Support\Facades\View;
use App\Models\Category;

public function boot(): void
{
    View::composer('partials.sidebar', function ($view) {
        $view->with('categories', Category::all());
    });
}

Теперь при каждом рендере (например через @include('partials.sidebar')) в шаблоне partials.sidebar будет доступна переменная categories.


Ошибки в Laravel

Основной центр обработки исключений — глобальный обработчик. Раньше это ассоциировалось с файлом app/Exceptions/Handler.php; в современных версиях (Laravel 11+) многое настраивается через bootstrap/app.php.

Концептуальный пример регистрации кастомного рендера исключений:

use Illuminate\Database\Eloquent\ModelNotFoundException;
use Symfony\Component\HttpKernel\Exception\NotFoundHttpException;
use App\Exceptions\OrderCannotBeCancelledException;

->withExceptions(function ($exceptions) {
    // ModelNotFoundException до render-callback'ов превращается в NotFoundHttpException,
    // поэтому ловим его, а исходное исключение смотрим через getPrevious()
    $exceptions->render(function (NotFoundHttpException $e, $request) {
        if ($e->getPrevious() instanceof ModelNotFoundException && $request->expectsJson()) {
            return response()->json([
                'message' => 'Ресурс не найден'
            ], 404);
        }
    });

    $exceptions->render(function (OrderCannotBeCancelledException $e, $request) {
        return response()->json([
            'message' => $e->getMessage()
        ], 422);
    });
});

Сессии и куки

В Laravel cookie — это клиентское хранилище, а session — механизм хранения пользовательского состояния между запросами. Обычно браузер хранит session cookie с ID, а сами session-данные лежат на сервере — в файлах, БД или Redis. Сессии активно используются в web-auth, flash-сообщениях, old input и CSRF.

Cookie — маленький кусок данных, который хранится у клиента (в браузере) и отправляется на сервер с каждым запросом к соответствующему домену/пути. Session — серверная «корзина» данных, привязанная к пользователю через session ID. Связка работает через session cookie.

Драйверы: file, cookie, database, redis, array.

Типичный lifecycle:

  1. Пользователь делает запрос.
  2. Браузер отправляет cookie, в том числе session cookie.
  3. Laravel middleware читает session ID.
  4. Session driver загружает данные сессии из хранилища.
  5. В коде ты читаешь/пишешь session().
  6. В конце запроса Laravel сохраняет сессию обратно.
  7. Если session ID новый — клиенту отправляется Set-Cookie.

Данные реально записываются в session обычно в конце обработки запроса (middleware-слоем).

Session и аутентификация. В классической web-auth Laravel обычно использует session-based authentication: пользователь логинится → Laravel записывает информацию в session → пользователь считается аутентифицированным, пока session валидна. Для web — чаще session/cookies, для API — токены (Sanctum, Passport, JWT). Session-auth плохо подходит для stateless API, потому что session — stateful механизм, требующий хранения состояния между запросами.

Session fixation — атака, при которой злоумышленник навязывает жертве заранее известный session ID. Защита — перегенерировать session ID после логина:

$request->session()->regenerate();

Ещё полезно:

$request->session()->invalidate();
$request->session()->regenerateToken();

Используется при logout, sensitive actions, смене привилегий пользователя.

Шифрование cookie. В Laravel cookie обычно шифруются middleware'ом: содержимое защищено от подмены/чтения, но cookie всё равно хранится у клиента (размер и сетевые ограничения остаются).

Основные cookie-флаги:

  • HttpOnly — JavaScript не может читать cookie через document.cookie (против части XSS-сценариев).
  • Secure — cookie передаётся только по HTTPS (для production почти обязательно).
  • SameSite — ограничивает отправку cookie в cross-site контексте: Strict (максимально строго), Lax (безопасный компромисс-default), None (разрешает cross-site, но требует Secure).

SESSION_DOMAIN и поддомены. Чтобы шарить session/cookie между поддоменами (app.example.com, admin.example.com), нужно правильно настроить домен cookie. Если логин на одном поддомене не работает на другом — обычно неверно настроены SESSION_DOMAIN, SANCTUM_STATEFUL_DOMAINS (для Sanctum), SameSite, Secure.

Важно: session — это shared state между запросами пользователя, параллельные запросы могут вызывать race conditions, поэтому не стоит превращать session в главное бизнес-хранилище.


Config + env

env() нужно использовать только внутри config-файлов, а в приложении — config(). Почему:

  • конфиг централизован;
  • код меньше зависит от окружения напрямую;
  • это правильно работает с config:cache (после кэширования .env в рантайме не читается, и env() вне конфигов вернёт null);
  • легче менять значения и тестировать.

.env не хранится в репозитории; .env.example — шаблон.


Route Model Binding

Route Model Binding — механизм Laravel, который автоматически подставляет модель Eloquent в параметры маршрута/контроллера на основе значения из URL. Вместо ручного поиска:

$post = Post::findOrFail($id);

Laravel делает это сам:

public function show(Post $post)
{
    return view('posts.show', compact('post'));
}

Если маршрут выглядит так:

Route::get('/posts/{post}', [PostController::class, 'show']);

то Laravel возьмёт значение {post} из URL, найдёт модель Post по id и передаст её в метод контроллера. Это убирает ручной findOrFail() и делает получение сущностей декларативным (при отсутствии записи — автоматически 404).

Как это работает: Laravel смотрит на имя параметра маршрута ({user}) и type-hint в методе (User $user); если они логически совпадают, ищет модель:

Route::get('/users/{user}', ...);
public function show(User $user)

Кастомная логика поиска — Route::bind (например, в AppServiceProvider::boot):

Route::bind('user', function ($value) {
    return User::where('uuid', $value)->firstOrFail();
});

Поиск по другому полю — прямо в маршруте:

Route::get('/posts/{post:slug}', [PostController::class, 'show']);

Или задать поле по умолчанию в модели:

public function getRouteKeyName()
{
    return 'slug';
}

Scoped bindings. В маршруте с вложенными параметрами можно теоретически подставить пост чужого пользователя:

Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
    return $post;
});

Решение — scopeBindings(): Laravel будет искать Post через отношение пользователя:

Route::get('/users/{user}/posts/{post}', function (User $user, Post $post) {
    return $post;
})->scopeBindings();

Lazy Loading и проблема N+1

Lazy Loading — связь модели загружается лениво, при первом обращении. Это приводит к проблеме N+1: при обходе коллекции на каждый элемент выполняется отдельный запрос за связью. Решение — eager loading (см. раздел «Модели и связи»).

with() vs load():

  • with() — используешь до выполнения запроса.
  • load() — используешь после того, как модель/коллекция уже получена.

loadMissing() догружает связь только если она ещё не загружена (не делает лишней работы):

$posts->loadMissing('user');

Pivot

Pivot table — промежуточная таблица для связи many-to-many. Например: users, roles, и pivot-таблица role_user. Если у пользователя много ролей, а у роли много пользователей — используется pivot.

// User.php
public function roles()
{
    return $this->belongsToMany(Role::class);
}
// Role.php
public function users()
{
    return $this->belongsToMany(User::class);
}

Дополнительные поля pivot (assigned_at, created_by):

return $this->belongsToMany(Role::class)
    ->withPivot('assigned_at', 'created_by');

Запись с pivot-данными через attach:

$user->roles()->attach($roleId, [
    'assigned_at' => now(),
    'created_by'  => auth()->id(),
]);

Доступ к pivot-данным:

foreach ($user->roles as $role) {
    $role->pivot->assigned_at;
}

Кастомный Pivot — свой класс для промежуточной таблицы, когда withPivot() уже недостаточно (нужна логика, casts, аксессоры/мутаторы, методы, события):

use Illuminate\Database\Eloquent\Relations\Pivot;

class RoleUser extends Pivot
{
    protected $table = 'role_user';

    protected $casts = [
        'assigned_at' => 'datetime',
        'is_active'   => 'boolean',
    ];
}
// User.php
public function roles()
{
    return $this->belongsToMany(Role::class)
        ->using(RoleUser::class)
        ->withPivot('assigned_at', 'is_active');
}

На собеседовании: если промежуточная таблица только связывает две модели и хранит немного метаданных — достаточно Pivot; если у неё появляется собственная бизнес-ценность, отдельные сценарии и логика — лучше выносить в полноценную Model.


Планировщик задач (Schedule)

Планировщик заменяет множество cron-записей одной. Расписание задаётся кодом (в Laravel 11+ — в routes/console.php):

Schedule::command('emails:send')->daily();
Schedule::job(new ClearReportsJob)->hourly();

На сервере нужна одна cron-запись, запускающая schedule:run каждую минуту:

* * * * * php /path/to/artisan schedule:run >> /dev/null 2>&1

Кастомные Artisan-команды с замыканием:

Artisan::command('mail:send {user}', function (string $user) {
    $this->info("Отправка электронной почты на: {$user}!");
});

Полезное: withoutOverlapping(), onOneServer(), runInBackground().


Паттерн Репозиторий

Repository pattern в Laravel — это слой между бизнес-логикой и источником данных, который скрывает детали работы с БД или Eloquent-моделями за интерфейсом. Нужен, чтобы уменьшить связанность кода, упростить тестирование и дать возможность менять способ получения данных без переписывания сервиса или контроллера. Например: есть UserRepositoryInterface, есть реализация EloquentUserRepository, контроллер/сервис зависит от интерфейса, а не от модели User напрямую.

interface UserRepositoryInterface {
    public function find(int $id): ?User;
}

final class EloquentUserRepository implements UserRepositoryInterface {
    public function find(int $id): ?User {
        return User::find($id);
    }
}

// В AppServiceProvider::register()
$this->app->bind(UserRepositoryInterface::class, EloquentUserRepository::class);

Что говорят на собеседовании: отделяет доступ к данным от бизнес-логики; упрощает мокирование в тестах; делает код более гибким; полезен в сложных проектах.

Зрелая мысль: в Laravel репозиторий не всегда обязателен, потому что Eloquent уже частично решает задачу абстракции над данными. Использовать паттерн стоит там, где есть: сложная логика выборок; несколько источников данных; необходимость строгих интерфейсов; желание не привязывать сервисы напрямую к ORM.


Laravel Mix / Vite

Laravel Mix — инструмент для сборки и компиляции фронтенд-ассетов, построенный поверх Webpack (упрощает работу с JS, SCSS, минификацией и версионированием):

mix.js('resources/js/app.js', 'public/js')
    .sass('resources/sass/app.scss', 'public/css')
    .version();

В новых версиях Laravel чаще используют Vite, поэтому Mix актуален в основном для legacy-проектов. В Blade ассеты подключаются директивой @vite:

@vite(['resources/css/app.css', 'resources/js/app.js'])

Конфигурация Vite (vite.config.js):

import { defineConfig } from 'vite';
import laravel from 'laravel-vite-plugin';

export default defineConfig({
    plugins: [
        laravel([
            'resources/css/app.css',
            'resources/js/app.js',
        ]),
    ],
});

Rate Limiting / Brute force

Rate Limiting — механизм ограничения количества запросов за определённое время. Нужен, чтобы защитить приложение от спама, brute force-атак, перегрузки API и слишком частых запросов от одного пользователя или IP. Brute force — перебор логинов, паролей, кодов подтверждения. Защищаются через rate limiting, блокировку после нескольких неудачных попыток, CAPTCHA, 2FA и логирование подозрительной активности.

Обычно ограничение строится по IP, user ID, email или их комбинации; чаще всего используется для login, password reset, OTP/2FA, API endpoints.

Простой вариант — middleware throttle (60 запросов в 1 минуту):

Route::middleware('throttle:60,1')->group(function () {
    Route::post('/login', [AuthController::class, 'login']);
});

Именованный лимитер (в сервис-провайдере) — гибкая настройка по IP:

use Illuminate\Cache\RateLimiting\Limit;
use Illuminate\Support\Facades\RateLimiter;

RateLimiter::for('login', function ($request) {
    return Limit::perMinute(5)->by($request->ip());
});
Route::post('/login', [AuthController::class, 'login'])
    ->middleware('throttle:login');

Про brute force: при множестве неверных вводов пароля Laravel может временно заблокировать попытки; ограничивают по IP или связке email + IP; в Breeze/Jetstream/Fortify такие механизмы часто уже встроены. При превышении лимита возвращается HTTP 429 Too Many Requests.


Laravel Sail

Laravel Sail — легковесная Docker-обёртка для локальной разработки, официальный инструмент Laravel для запуска проекта в Docker-контейнерах без ручной настройки всего стека. Помогает быстро поднять окружение с PHP, Nginx, MySQL/PostgreSQL, Redis, Mailpit, Meilisearch, Selenium и другими сервисами.

Что важно понимать: Sail нужен для локальной разработки; построен поверх Docker и Docker Compose; позволяет всей команде работать в одинаковом окружении (уменьшает проблему «у меня работает, у тебя нет»); не заменяет сам Laravel, а только упрощает запуск инфраструктуры. Sail использует Docker Compose под капотом, но даёт готовую интеграцию именно для Laravel.


Laravel Octane

Laravel Octane — пакет для ускорения приложений за счёт запуска на высокопроизводительных application-серверах (Swoole, RoadRunner, FrankenPHP). В отличие от классического PHP-FPM, где приложение полностью загружается на каждый запрос, Octane держит приложение в памяти между запросами (long-running workers), поэтому уменьшается overhead на bootstrap и растёт производительность.

Плюсы: выше throughput и ниже latency; быстрее обработка большого числа запросов; меньше затрат на повторный bootstrap; хорошо для высоконагруженных API и realtime-сценариев.

Нюансы: нужно аккуратно работать с состоянием приложения, потому что объекты могут жить между запросами; нельзя бездумно хранить данные в singleton'ах, static-полях и сервисах, если они зависят от конкретного запроса; возможны memory leaks при неаккуратном коде; не каждый пакет одинаково хорошо ведёт себя в long-running окружении.

Когда использовать: высоконагруженные API; проекты с важной низкой задержкой; много однотипных запросов; realtime/near-realtime. Когда можно не использовать: маленький CRUD без нагрузки; если команда не готова учитывать особенности long-running процессов.

Типичные вопросы на собеседовании:

  • Почему Octane ускоряет приложение, даже если бизнес-логика не изменилась? Убирается повторный bootstrap Laravel на каждый запрос (контейнер, конфиги, роуты уже в памяти воркера). Подвох: Octane не делает код «умнее» — если запрос упирается в медленный SQL/внешний API, прирост ограничен.
  • Почему опасно класть Request или Auth user в singleton? Singleton может пережить текущий запрос; если в него положили запрос/пользователя/tenant ID/locale, следующий запрос получит старые данные.
  • Какие баги чаще появляются после перехода на Octane? Утечка состояния между запросами; memory leaks; stale config/data в памяти; проблемы с пакетами, рассчитанными на request-per-process; некорректная работа static cache; проблемы в multi-tenant, если tenant context закэширован в памяти.

Запуск:

php artisan octane:start --server=swoole
php artisan octane:start --server=roadrunner
php artisan octane:start --watch

Octane сбрасывает часть framework-level состояния между запросами, но не может исправить плохую архитектуру: ваши кастомные singleton/static-кеши — ваша ответственность. Для явного сброса состояния сервиса можно реализовать интерфейс сброса:

interface Flushable
{
    public function flush(): void;
}

Миграции и схема БД

Миграции — версионирование схемы БД в коде (up применяет, down откатывает). Создание — php artisan make:migration.

use Illuminate\Database\Migrations\Migration;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Support\Facades\Schema;

return new class extends Migration
{
    public function up(): void
    {
        Schema::create('posts', function (Blueprint $table) {
            $table->id();
            $table->foreignId('user_id')->constrained()->cascadeOnDelete();
            $table->string('slug')->unique();
            $table->string('title');
            $table->text('body');
            $table->boolean('is_published')->default(false);
            $table->timestamps();
            $table->softDeletes();

            $table->index(['is_published', 'created_at']); // составной индекс
        });
    }

    public function down(): void
    {
        Schema::dropIfExists('posts');
    }
};

Команды: migrate, migrate:rollback (откат последней «пачки»), migrate:fresh (пересоздать все таблицы), migrate:status. Внешние ключи — foreignId()->constrained() с cascadeOnDelete()/nullOnDelete().

Миграции без даунтайма (важно для Senior). На больших таблицах в проде опасны блокирующие операции. Практики: не переименовывать/удалять колонки сразу (сначала перестать использовать, потом удалить в отдельном релизе); добавлять колонки как nullable или с default; тяжёлые изменения — вне пиковой нагрузки; на MySQL учитывать блокировки при ALTER. Сидеры (db:seed) — справочные/тестовые данные, фабрики (Model::factory()) — генерация фейковых записей.

// database/factories/PostFactory.php
public function definition(): array
{
    return [
        'title' => fake()->sentence(),
        'slug'  => fake()->unique()->slug(),
        'body'  => fake()->paragraphs(3, true),
    ];
}

// использование
Post::factory()->count(50)->for(User::factory())->create();

Валидация и Form Requests

Быстрая валидация прямо в контроллере — метод validate (при провале редиректит назад с ошибками для web или отдаёт 422 JSON для API):

public function store(Request $request)
{
    $validated = $request->validate([
        'title' => ['required', 'string', 'max:255'],
        'slug'  => ['required', 'unique:posts,slug'],
        'body'  => ['required'],
        'tags'  => ['array'],
        'tags.*'=> ['integer', 'exists:tags,id'],
    ]);

    Post::create($validated);
}

Form Request (php artisan make:request StorePostRequest) выносит правила и авторизацию из контроллера; валидируется автоматически до входа в метод:

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class StorePostRequest extends FormRequest
{
    public function authorize(): bool
    {
        return $this->user()->can('create', Post::class);
    }

    public function rules(): array
    {
        return [
            'title' => ['required', 'string', 'max:255'],
            'body'  => ['required', 'string'],
        ];
    }

    public function messages(): array
    {
        return ['title.required' => 'Заголовок обязателен'];
    }
}

// Контроллер: тип-хинт делает всё сам
public function store(StorePostRequest $request)
{
    $post = Post::create($request->validated());
}

Кастомное правило (make:rule):

use Illuminate\Contracts\Validation\ValidationRule;

class Uppercase implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        if (strtoupper($value) !== $value) {
            $fail("Поле :attribute должно быть в верхнем регистре.");
        }
    }
}

API Resources

Слой трансформации моделей в JSON — отделяет структуру ответа от структуры БД. Класс JsonResource (make:resource):

<?php

namespace App\Http\Resources;

use Illuminate\Http\Resources\Json\JsonResource;

class PostResource extends JsonResource
{
    public function toArray($request): array
    {
        return [
            'id'        => $this->id,
            'title'     => $this->title,
            'published' => (bool) $this->is_published,
            // условное поле — только если атрибут есть
            'secret'    => $this->when($request->user()?->isAdmin(), $this->secret),
            // вложенный ресурс — только если связь загружена (защита от N+1)
            'author'    => new UserResource($this->whenLoaded('author')),
            'links'     => ['self' => route('posts.show', $this->id)],
        ];
    }
}

Использование: return new PostResource($post); или коллекция PostResource::collection($posts). Метаданные и обёртку задаёт ResourceCollection; additional() добавляет данные вне data.


Коллекции

Illuminate\Support\Collection — обёртка над массивом с fluent-API. Eloquent-выборки возвращают EloquentCollection.

$names = User::all()
    ->filter(fn ($u) => $u->active)
    ->sortByDesc('created_at')
    ->map(fn ($u) => $u->name)
    ->values();

$byRole = $users->groupBy('role');                 // группировка
$total  = $orders->sum('amount');                   // агрегат
$page   = $items->chunk(10);                         // разбивка
$exists = $users->contains(fn ($u) => $u->isAdmin());

Higher-order messages — краткий синтаксис для методов-коллбэков: $users->each->markAsVerified(), $invoices->sum->total.

LazyCollection — на генераторах, обрабатывает огромные наборы без загрузки всего в память:

use Illuminate\Support\LazyCollection;

LazyCollection::make(function () {
    $handle = fopen('huge.log', 'r');
    while (($line = fgets($handle)) !== false) {
        yield $line;
    }
})->filter(fn ($line) => str_contains($line, 'ERROR'))
  ->take(100)
  ->each(fn ($line) => process($line));

Запросы по связям и Query Builder vs Eloquent

Фильтрация и подсчёт по связям — has, whereHas, withCount, doesntHave:

// Посты, у которых есть хотя бы один комментарий
Post::has('comments')->get();

// Посты с >= 3 комментариями
Post::has('comments', '>=', 3)->get();

// Посты, где есть комментарии с условием
Post::whereHas('comments', fn ($q) => $q->where('approved', true))->get();

// Посты без комментариев
Post::doesntHave('comments')->get();

// Подсчёт связанных без их загрузки
$posts = Post::withCount('comments')->get();
echo $posts->first()->comments_count;

// Агрегаты по связи
Post::withSum('orders', 'amount')->withExists('comments')->get();

Query Builder vs Eloquent:

Query Builder Eloquent
Уровень над таблицами (DB::table()) над моделями (ActiveRecord)
Результат stdClass / массивы объекты моделей
Возможности быстрые запросы, агрегаты, сложные join связи, события, касты, скоупы
Накладные расходы минимальные выше (гидрация моделей)
// Query Builder — когда модели не нужны (тяжёлая аналитика)
$stats = DB::table('orders')
    ->select('status', DB::raw('count(*) as cnt'))
    ->groupBy('status')
    ->get();

Eloquent выразительнее; Query Builder — для тяжёлых массовых операций и аналитики, где гидрация моделей избыточна.


Обработка больших выборок

Загружать миллионы строк в память нельзя. Способы порционной обработки:

// chunk — по 500 записей за запрос
User::chunk(500, function ($users) {
    foreach ($users as $user) { /* ... */ }
});

// chunkById — безопаснее при изменении данных во время обхода
User::where('active', false)->chunkById(500, function ($users) {
    // ...
});

// cursor — один запрос + генератор (минимум памяти, но держит соединение)
foreach (User::cursor() as $user) {
    // ...
}

// lazy / lazyById — LazyCollection поверх chunk
User::lazy()->each(fn ($u) => process($u));

chunk подходит для батч-операций; cursor — для последовательной потоковой обработки; chunkById/lazyById устойчивы к изменениям данных во время итерации.


Транзакции и блокировки

Атомарность нескольких операций — DB::transaction (авто-commit при успехе, rollback при исключении):

use Illuminate\Support\Facades\DB;

DB::transaction(function () {
    $order = Order::create([...]);
    $order->items()->createMany($items);
    Inventory::where('id', $id)->decrement('qty', $count);
}, attempts: 3); // повтор при deadlock

Ручное управление:

DB::beginTransaction();
try {
    // ...
    DB::commit();
} catch (\Throwable $e) {
    DB::rollBack();
    throw $e;
}

Блокировки против гонок:

// Пессимистичная: блокирует строки до конца транзакции
DB::transaction(function () {
    $account = Account::where('id', 1)->lockForUpdate()->first();
    $account->balance -= 100;
    $account->save();
});

// sharedLock() — разделяемая блокировка на чтение

Оптимистичная блокировка — через колонку версии/updated_at в условии WHERE (обновление проходит, только если запись не изменилась). Важно: транзакции в очередях/Octane требуют аккуратности — не оставлять открытых транзакций между заданиями.


Soft Deletes

«Мягкое» удаление помечает запись (deleted_at), а не стирает. Трейт SoftDeletes + $table->softDeletes() в миграции:

use Illuminate\Database\Eloquent\SoftDeletes;

class Post extends Model
{
    use SoftDeletes;
}
$post->delete();                 // проставит deleted_at
$post->trashed();                // true

Post::withTrashed()->get();      // включая удалённые
Post::onlyTrashed()->get();      // только удалённые
$post->restore();                // восстановить
$post->forceDelete();            // удалить окончательно

По умолчанию мягко удалённые записи скрыты глобальным скоупом SoftDeletingScope.


Наблюдатели (Observers)

Observer выносит обработчики событий жизненного цикла модели в отдельный класс (чище, чем замыкания в boot). Создание — php artisan make:observer PostObserver --model=Post:

<?php

namespace App\Observers;

use App\Models\Post;

class PostObserver
{
    public function creating(Post $post): void
    {
        $post->slug ??= str($post->title)->slug();
    }

    public function deleted(Post $post): void
    {
        Cache::forget("post.{$post->id}");
    }
}

Регистрация — атрибут #[ObservedBy] на модели (или Post::observe(PostObserver::class) в провайдере):

use Illuminate\Database\Eloquent\Attributes\ObservedBy;

#[ObservedBy([PostObserver::class])]
class Post extends Model {}

Нюанс: события модели не срабатывают на массовых операциях (Post::where(...)->update(...), delete() через запрос) — они работают на уровне экземпляра.


Уведомления (Notifications)

Единый способ доставки сообщений через разные каналы: mail, database, broadcast, SMS (Vonage), Slack. Создание — make:notification:

<?php

namespace App\Notifications;

use Illuminate\Notifications\Notification;
use Illuminate\Notifications\Messages\MailMessage;

class InvoicePaid extends Notification
{
    public function __construct(public Invoice $invoice) {}

    public function via(object $notifiable): array
    {
        return ['mail', 'database'];   // каналы доставки
    }

    public function toMail(object $notifiable): MailMessage
    {
        return (new MailMessage)
            ->subject('Оплата получена')
            ->line("Счёт #{$this->invoice->id} оплачен.")
            ->action('Открыть счёт', url("/invoices/{$this->invoice->id}"));
    }

    public function toArray(object $notifiable): array
    {
        return ['invoice_id' => $this->invoice->id];
    }
}

Отправка: $user->notify(new InvoicePaid($invoice)); или Notification::send($users, ...). Асинхронно — интерфейс ShouldQueue. Для канала database нужна таблица notifications.


Хранилище файлов (Storage)

Единый API к файловым системам через фасад Storage (локальный диск, публичный, S3 и др.). Диски настраиваются в config/filesystems.php:

use Illuminate\Support\Facades\Storage;

$path = $request->file('avatar')->store('avatars', 'public'); // сохранить загруженный файл
Storage::disk('s3')->put('reports/report.pdf', $contents);
$url = Storage::disk('public')->url($path);                    // публичный URL
$temp = Storage::disk('s3')->temporaryUrl($path, now()->addMinutes(10)); // подписанный URL
Storage::delete($path);

Смена драйвера (local → s3) не требует правок кода — только конфигурации. Публичные файлы доступны после php artisan storage:link (симлинк public/storage).


Сервисный слой и Action-классы

Толстые контроллеры — антипаттерн. Бизнес-логику выносят в сервисы или одиночные Action-классы, а контроллер остаётся тонким (валидация → вызов сервиса → ответ).

final class PublishPostAction
{
    public function __construct(private Notifier $notifier) {}

    public function execute(Post $post): void
    {
        $post->update(['is_published' => true, 'published_at' => now()]);
        $this->notifier->notifySubscribers($post);
    }
}

// Контроллер
public function publish(Post $post, PublishPostAction $action)
{
    $this->authorize('update', $post);
    $action->execute($post);
    return back();
}

Плюсы: переиспользование логики (контроллер, команда, очередь, тест), тестируемость, соблюдение SRP. DTO переносит между слоями типизированные данные.


Макросы и контекстная привязка

Макросы — динамическое добавление методов к «макросящимся» классам Laravel (Collection, Str, Request, Response, Builder). Регистрируются в boot провайдера:

use Illuminate\Support\Collection;

Collection::macro('toUpper', function () {
    return $this->map(fn ($value) => strtoupper($value));
});

collect(['a', 'b'])->toUpper(); // ['A', 'B']

Контекстная привязка — разная реализация одного интерфейса для разных классов:

use App\Services\Storage;
use Illuminate\Contracts\Filesystem\Filesystem;

$this->app->when(PhotoController::class)
    ->needs(Filesystem::class)
    ->give(fn () => Storage::disk('local'));

$this->app->when(VideoController::class)
    ->needs(Filesystem::class)
    ->give(fn () => Storage::disk('s3'));

Тегирование — разрешить группу связанных сервисов:

$this->app->tag([CpuReport::class, MemoryReport::class], 'reports');
$this->app->bind(ReportAggregator::class, fn ($app) =>
    new ReportAggregator($app->tagged('reports')));

Вероятные вопросы

Что такое Service Container и DI? Контейнер управляет зависимостями и внедряет их: смотрит на типы аргументов конструктора и сам подставляет экземпляры (autowiring). DI — подача зависимостей извне, а не создание внутри класса.

Чем bind отличается от singleton и scoped? bind — новый экземпляр каждый раз; singleton — один на всё приложение; scoped — один на жизненный цикл запроса/задания (сбрасывается в Octane и при обработке нового job).

register vs boot в провайдере? В register — только привязки контейнера (другие сервисы недоступны); в boot — код после регистрации всех провайдеров (сервисы доступны).

Как работает Route Model Binding? По параметру маршрута Laravel сам находит модель (по id или полю {post:slug}); при отсутствии — 404. Кастомная логика — Route::bind; защита вложенных — scopeBindings().

Что такое проблема N+1 и как решить? Лишние запросы при обращении к связи в цикле. Решение — eager loading (with), догрузка load/loadMissing.

with() vs load()? with — до выполнения запроса; load — после получения коллекции; loadMissing — догружает только отсутствующее.

paginate vs simplePaginate vs cursorPaginate? paginate считает total (дорогой COUNT); simplePaginate — без total (быстрее); cursorPaginate — по курсору, самый быстрый и устойчивый к изменениям, но без произвольных страниц.

Локальный vs глобальный скоуп? Локальный (#[Scope] / scopeXxx) — вызывается явно; глобальный (Scope + ScopedBy / addGlobalScope) — применяется ко всем запросам автоматически.

Событие vs Observer vs подписчик? Событие — произвольный факт с любыми слушателями; события модели — хуки жизненного цикла (creating, saved…); подписчик — класс, регистрирующий сразу несколько слушателей через subscribe.

Sanctum или Passport? Sanctum — для SPA/мобильных/простых API (токены/сессии); Passport — полноценный OAuth2-сервер.

OAuth2 — это про что и чем отличается от JWT? OAuth2 — протокол авторизации («что клиенту можно»), JWT — формат токена. Их можно использовать вместе или по отдельности.

Gate vs Policy? Gate — простая проверка-замыкание вне модели; Policy — класс правил вокруг конкретной модели.

Как работает защита CSRF? Для web-маршрутов требуется токен на POST/PUT/PATCH/DELETE: @csrf в форме или заголовок X-CSRF-TOKEN для AJAX. API на токенах от CSRF не зависит.

Bcrypt vs Argon2? Оба адаптивные с солью. Bcrypt настраивается cost; Argon2 — time/memory/parallelism, устойчивее к GPU-атакам.

Зачем APP_KEY и что будет при его смене? Ключ шифрования куки/сессий/Crypt. При смене ранее зашифрованные данные становятся недоступны, сессии сбрасываются.

Что такое session fixation и как защититься? Навязывание известного session ID; защита — session()->regenerate() после логина.

Почему session-auth плохо подходит для stateless API? Session — stateful механизм, требует хранения состояния между запросами; для API используют токены (Sanctum/Passport/JWT).

Почему нельзя env() вне config при config:cache? После кэширования .env не читается в рантайме — env() вне config/* вернёт null; используйте config().

Что даёт Octane и в чём риск? Резидентный процесс без пере-bootstrap — большой прирост скорости; риск — утечки состояния между запросами в singleton/static.

Зачем нужен Horizon? Панель мониторинга и настройки очередей на Redis (метрики, throughput, теги, авто-масштабирование воркеров).

validate() vs Form Request? validate() — быстрая валидация в контроллере; Form Request — отдельный класс с rules() и authorize(), валидируется автоматически до входа в метод, чище и переиспользуемо.

Зачем API Resources? Отделяют структуру JSON-ответа от структуры БД: условные поля (when), вложенные ресурсы только при загруженной связи (whenLoaded — защита от N+1), метаданные.

has vs whereHas vs withCount? has — есть ли связанные записи (можно с количеством); whereHas — есть ли связанные, удовлетворяющие условию; withCount — подсчитать связанные, не загружая их.

chunk vs cursor vs lazy? chunk/chunkById — порции по N записей (для батч-операций); cursor — один запрос + генератор (минимум памяти); lazy/lazyById — LazyCollection поверх chunk. Для больших выборок — не грузить всё в память.

Пессимистичная vs оптимистичная блокировка? Пессимистичная (lockForUpdate) блокирует строки в транзакции; оптимистичная — проверяет версию/updated_at в WHERE при обновлении. Транзакция — DB::transaction с авто-rollback и повтором при deadlock.

Как работают Soft Deletes? Трейт SoftDeletes + deleted_at: delete() помечает запись, глобальный скоуп скрывает её; withTrashed/onlyTrashed/restore/forceDelete.

Observer или события модели в boot? Observer выносит хуки (creating, deleted…) в отдельный класс — чище. Важно: события не срабатывают на массовых запросах (update/delete через Query Builder).

Что такое макрос? Динамическое добавление метода к макросящемуся классу (Collection, Str, Builder…) через ::macro() в boot провайдера.

Как дать разную реализацию интерфейса разным классам? Контекстная привязка when()->needs()->give(); для группы сервисов — тегирование (tag/tagged).