Что такое многослойная архитектура (Layered Architecture)?

Многослойная архитектура — это подход к проектированию ПО, при котором приложение разделяется на горизонтальные слои, каждый из которых выполняет определенную роль. Главное правило — слой может взаимодействовать только со слоем, находящимся непосредственно под ним. Это обеспечивает четкое разделение ответственности и слабую связанность компонентов.

Классические слои в веб-приложении:

1. Слой представления (Presentation Layer): Отвечает за взаимодействие с пользователем. В Go это, как правило, обработчики HTTP-запросов (http.Handler), которые принимают запросы, валидируют их и передают данные на следующий слой.
   • Компоненты: Controllers, Handlers.
2. Слой бизнес-логики (Business Logic/Service Layer): Содержит основную логику приложения. Он не зависит от деталей представления или хранения данных. Здесь реализуются бизнес-правила и координируется работа со слоем доступа к данным.
   • Компоненты: Services.
3. Слой доступа к данным (Data Access Layer): Отвечает за взаимодействие с хранилищем данных (БД, кэш, внешние API). Он абстрагирует детали работы с базой данных от бизнес-логики.
   • Компоненты: Repositories, DAO (Data Access Object).

Пример реализации на Go с внедрением зависимостей:

package main

import (
    "database/sql"
    "fmt"
    "log"
    "net/http"
)

// --- Слой доступа к данным (Data Access Layer) ---
type UserRepository struct {
    db *sql.DB
}

func (r *UserRepository) Save(name string) error {
    fmt.Printf("Saving user '%s' to the databasen", name)
    // _, err := r.db.Exec("INSERT INTO users (name) VALUES (?)", name)
    // return err
    return nil
}

// --- Слой бизнес-логики (Service Layer) ---
type UserService struct {
    repo *UserRepository
}

func (s *UserService) RegisterUser(name string) error {
    if len(name) < 3 {
        return fmt.Errorf("username is too short")
    }
    return s.repo.Save(name)
}

// --- Слой представления (Presentation Layer) ---
type UserHandler struct {
    service *UserService
}

func (h *UserHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    name := r.URL.Query().Get("name")
    if err := h.service.RegisterUser(name); err != nil {
        http.Error(w, err.Error(), http.StatusBadRequest)
        return
    }
    w.WriteHeader(http.StatusCreated)
    w.Write([]byte("User registered successfully!"))
}

// --- Сборка приложения в main.go ---
func main() {
    // Инициализация зависимостей (Dependency Injection)
    // db, err := sql.Open(...) - здесь было бы реальное подключение к БД
    db := &sql.DB{}

    repository := &UserRepository{db: db}
    service := &UserService{repo: repository}
    handler := &UserHandler{service: service}

    http.Handle("/register", handler)
    log.Println("Server is running on :8080")
    log.Fatal(http.ListenAndServe(":8080", nil))
}

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

• Разделение ответственности: Код становится более организованным и понятным.
• Тестируемость: Каждый слой можно тестировать изолированно, подменяя (мокируя) зависимости.
• Переиспользование компонентов: Слои, такие как доступ к данным, могут использоваться разными частями бизнес-логики.
• Гибкость: Легко заменить реализацию одного слоя (например, перейти с PostgreSQL на MongoDB), не затрагивая другие.

Недостатки:

• Избыточность: Для очень простых приложений может создавать ненужное усложнение.
• Накладные расходы: Передача данных между слоями может привести к небольшому снижению производительности.