Что такое луковая архитектура?

Луковая архитектура (Onion Architecture) — это шаблон проектирования, предложенный Джеффри Палермо, который структурирует приложение вокруг независимого доменного ядра. Основная идея — защитить бизнес-логику от изменений во внешних компонентах, таких как базы данных, фреймворки или интерфейсы пользователя. Архитектура визуально напоминает луковицу с концентрическими слоями, где каждый внешний слой может зависеть только от слоёв, находящихся ближе к центру.

Ключевые слои

• Доменный слой (Domain Layer) — ядро, содержащее сущности и бизнес-правила. Он полностью изолирован и не ссылается ни на какие внешние библиотеки или фреймворки.
• Слой приложения (Application Layer) — содержит сценарии использования (use cases) и координирует поток данных между доменом и внешним миром. Здесь определяются интерфейсы репозиториев.
• Слой инфраструктуры (Infrastructure Layer) — реализует технические детали: доступ к базе данных, отправку email, вызовы API. Этот слой зависит от домена и приложения через инверсию зависимостей.
• Презентационный слой (Presentation Layer) — отвечает за взаимодействие с пользователем (UI, API контроллеры). Он также зависит от внутренних слоёв.

Как это работает на практике

Принцип инверсии зависимостей (Dependency Inversion Principle) является ключевым. Вместо того чтобы доменный слой зависел от реализации базы данных, мы определяем интерфейс репозитория в слое приложения, а конкретную реализацию (например, с использованием Entity Framework) предоставляем в слое инфраструктуры. Это позволяет легко менять технологии без воздействия на бизнес-логику.

Пример кода

Рассмотрим упрощённый пример на C# для управления пользователями:

// Доменный слой: сущность User
namespace Domain.Entities
{
    public class User
    {
        public int Id { get; set; }
        public string Name { get; set; }
    }
}

// Слой приложения: интерфейс репозитория
namespace Application.Interfaces
{
    public interface IUserRepository
    {
        User GetById(int id);
    }
}

// Слой инфраструктуры: реализация репозитория
namespace Infrastructure.Persistence.Repositories
{
    public class UserRepository : IUserRepository
    {
        private readonly AppDbContext _context;
        public UserRepository(AppDbContext context)
        {
            _context = context;
        }
        public User GetById(int id)
        {
            return _context.Users.Find(id);
        }
    }
}

// Презентационный слой (например, API контроллер)
[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    private readonly IUserRepository _userRepository;
    public UsersController(IUserRepository userRepository)
    {
        _userRepository = userRepository;
    }
    [HttpGet("{id}")]
    public IActionResult GetUser(int id)
    {
        var user = _userRepository.GetById(id);
        return Ok(user);
    }
}

В этом примере контроллер зависит от интерфейса IUserRepository, а не от конкретного репозитория. Реализация внедряется через Dependency Injection, что соответствует принципам луковой архитектуры.

Где применяется

Луковая архитектура особенно полезна в сложных enterprise-приложениях, где бизнес-логика является ценной и должна быть защищена от частых изменений во внешних системах. Она часто используется в сочетании с Domain-Driven Design (DDD) и Clean Architecture. Подход распространён в backend-разработке на платформах .NET, Java Spring, а также в Node.js с TypeScript.

Вывод: Луковую архитектуру стоит применять, когда вы разрабатываете долгоживущее приложение со сложной бизнес-логикой, где важны тестируемость, поддержка и возможность замены внешних компонентов (например, базы данных или UI-фреймворка) без переписывания ядра системы.