Веб-разработка/Средний ~ 35 мин

Echo и основы backend-разработки на Go

Прежде чем перейти к Echo, разберём как работает backend на базовом уровне. Это то, что часто подразумевается само собой, но нигде явно не объясняется — особенно людям, которые пришли в backend без опыта фронтенда или системного программирования.

Как работает backend: от запроса до базы данных

Представьте простое действие: пользователь нажимает кнопку "Создать задачу" в Todo-приложении. Вот что происходит:

Браузер/Клиент                    Ваш Go-сервер                    База данных
     │                                  │                                │
     │  POST /todos                     │                                │
     │  Content-Type: application/json  │                                │
     │  {"title": "Купить молоко"}      │                                │
     │ ───────────────────────────────► │                                │
     │                                  │  Декодируем JSON               │
     │                                  │  Валидируем данные             │
     │                                  │  INSERT INTO todos...          │
     │                                  │ ──────────────────────────────►│
     │                                  │                                │
     │                                  │  id=42, created_at=...         │
     │                                  │ ◄──────────────────────────────│
     │                                  │  Формируем JSON-ответ          │
     │  HTTP 201 Created                │                                │
     │  {"id": 42, "title": "..."}      │                                │
     │ ◄─────────────────────────────── │                                │

Каждый HTTP-запрос проходит один и тот же путь внутри сервера:

Входящий запрос
      │
      ▼
 Middleware        ← логирование, CORS, аутентификация
      │
      ▼
  Роутер           ← определяет какой обработчик вызвать
      │
      ▼
 Обработчик        ← бизнес-логика запроса
      │
      ├── Декодирование JSON из тела запроса
      ├── Валидация входных данных
      ├── Вызов сервисного слоя
      │       └── Запрос к базе данных
      └── Кодирование ответа в JSON

Слои приложения

Хорошо структурированный backend делится на слои. Каждый слой отвечает за своё:

┌─────────────────────────────────────────┐
│           Handler (Transport)           │  HTTP: парсинг запроса, ответ
├─────────────────────────────────────────┤
│              Service (Logic)            │  Бизнес-логика
├─────────────────────────────────────────┤
│           Repository (Storage)          │  Работа с базой данных
├─────────────────────────────────────────┤
│              Database                   │  PostgreSQL, MySQL...
└─────────────────────────────────────────┘

Handler — знает про HTTP. Читает запрос, вызывает сервис, пишет ответ. Не знает про базу данных.

Service — знает про бизнес-логику. Валидирует, считает, принимает решения. Не знает про HTTP и базу данных.

Repository — знает про базу данных. Выполняет SQL-запросы. Не знает про HTTP и бизнес-логику.

Такое разделение делает код тестируемым: каждый слой можно проверить независимо через интерфейсы и моки.

Почему фреймворк, а не чистый net/http

net/http — отличная база, но в реальных проектах постоянно нужно одно и то же:

Парсинг path-параметров (/users/:id)
Валидация входных данных
Группировка роутов с общим префиксом и middleware
Удобная работа с JSON
Структурированные ошибки

Писать это самому каждый раз — потеря времени. Фреймворки предоставляют готовые решения, оставаясь при этом тонкой обёрткой над net/http.

Echo — обзор

Echo — минималистичный высокопроизводительный веб-фреймворк. Его философия близка к философии Go: явное лучше неявного, минимум магии, максимум производительности.

go get github.com/labstack/echo/v4

Минимальное приложение

package main

import (
    "net/http"
    "github.com/labstack/echo/v4"
)

func main() {
    e := echo.New()

    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })

    e.Logger.Fatal(e.Start(":8080"))
}

Главное отличие от net/http — вместо двух аргументов (w, r) используется один echo.Context, который объединяет запрос и ответ:

// net/http
func handler(w http.ResponseWriter, r *http.Request) { ... }

// Echo
func handler(c echo.Context) error { ... }

echo.Context — сердце фреймворка

echo.Context — это обёртка над стандартными http.ResponseWriter и *http.Request, дополненная удобными методами:

func handler(c echo.Context) error {
    // ─── Запрос ───────────────────────────────────────────

    // Path параметры (/users/:id)
    id := c.Param("id")

    // Query параметры (?page=1&limit=10)
    page := c.QueryParam("page")
    limit := c.QueryParamOrDefault("limit", "10")

    // Заголовки
    token := c.Request().Header.Get("Authorization")

    // Декодирование JSON тела запроса
    var req CreateTodoRequest
    if err := c.Bind(&req); err != nil {
        return err
    }

    // ─── Ответ ────────────────────────────────────────────

    // JSON ответ
    return c.JSON(http.StatusOK, map[string]string{"id": id})

    // Строка
    return c.String(http.StatusOK, "hello")

    // Статус без тела
    return c.NoContent(http.StatusNoContent)

    // Редирект
    return c.Redirect(http.StatusMovedPermanently, "/new-path")
}

Роутинг

e := echo.New()

// Базовые методы
e.GET("/users", listUsers)
e.POST("/users", createUser)
e.GET("/users/:id", getUser)
e.PUT("/users/:id", updateUser)
e.DELETE("/users/:id", deleteUser)

// Группировка роутов
api := e.Group("/api/v1")
api.GET("/users", listUsers)
api.POST("/users", createUser)

// Группа с middleware (например, аутентификация только для этих роутов)
protected := api.Group("/admin")
protected.Use(authMiddleware)
protected.GET("/stats", getStats)

Bind и валидация

Bind автоматически декодирует данные из запроса в структуру — JSON, form-data, query параметры — в зависимости от Content-Type:

type CreateTodoRequest struct {
    Title    string `json:"title"    validate:"required,min=1,max=200"`
    Priority int    `json:"priority" validate:"min=1,max=3"`
}

func createTodo(c echo.Context) error {
    var req CreateTodoRequest

    // Bind декодирует JSON → структуру
    if err := c.Bind(&req); err != nil {
        return echo.NewHTTPError(http.StatusBadRequest, "invalid request body")
    }

    // Validate запускает валидацию по тегам
    if err := c.Validate(&req); err != nil {
        return err // Echo вернёт 400 с описанием ошибок
    }

    // Дальше работаем с валидными данными
    todo, err := todoService.Create(c.Request().Context(), req)
    if err != nil {
        return echo.NewHTTPError(http.StatusInternalServerError, "failed to create todo")
    }

    return c.JSON(http.StatusCreated, todo)
}

Валидатор нужно зарегистрировать при инициализации — Echo не навязывает конкретную библиотеку:

import "github.com/go-playground/validator/v10"

type CustomValidator struct {
    validator *validator.Validate
}

func (cv *CustomValidator) Validate(i interface{}) error {
    if err := cv.validator.Struct(i); err != nil {
        return echo.NewHTTPError(http.StatusBadRequest, err.Error())
    }
    return nil
}

func main() {
    e := echo.New()
    e.Validator = &CustomValidator{validator: validator.New()}
    // ...
}

Middleware в Echo

Echo поставляется с набором готовых middleware:

import "github.com/labstack/echo/v4/middleware"

e := echo.New()

// Логирование всех запросов
e.Use(middleware.Logger())

// Восстановление после паники
e.Use(middleware.Recover())

// CORS
e.Use(middleware.CORSWithConfig(middleware.CORSConfig{
    AllowOrigins: []string{"https://example.com"},
    AllowMethods: []string{http.MethodGet, http.MethodPost, http.MethodPut, http.MethodDelete},
}))

// Rate limiting
e.Use(middleware.RateLimiter(middleware.NewRateLimiterMemoryStore(20)))

// JWT аутентификация
e.Use(middleware.JWTWithConfig(middleware.JWTConfig{
    SigningKey: []byte("secret"),
}))

Кастомный middleware

func requestIDMiddleware(next echo.HandlerFunc) echo.HandlerFunc {
    return func(c echo.Context) error {
        // До обработчика
        requestID := uuid.New().String()
        c.Set("requestID", requestID)
        c.Response().Header().Set("X-Request-ID", requestID)

        // Вызываем следующий обработчик
        err := next(c)

        // После обработчика
        log.Printf("request %s completed", requestID)

        return err
    }
}

e.Use(requestIDMiddleware)

c.Set и c.Get — способ передавать данные между middleware и обработчиками внутри одного запроса. Аналог context.WithValue, но специфичный для Echo:

// В middleware
c.Set("userID", 42)

// В обработчике
userID := c.Get("userID").(int)

Обработка ошибок

Echo централизует обработку ошибок через HTTPErrorHandler. Все ошибки возвращённые из обработчиков попадают сюда:

type ErrorResponse struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

func customErrorHandler(err error, c echo.Context) {
    var httpError *echo.HTTPError
    if errors.As(err, &httpError) {
        c.JSON(httpError.Code, ErrorResponse{
            Code:    httpError.Code,
            Message: fmt.Sprintf("%v", httpError.Message),\n        })
        return
    }

    // Неизвестная ошибка — 500
    c.JSON(http.StatusInternalServerError, ErrorResponse{
        Code:    http.StatusInternalServerError,
        Message: "internal server error",
    })
}

func main() {
    e := echo.New()
    e.HTTPErrorHandler = customErrorHandler
}

Из обработчика можно возвращать:

// Стандартная HTTP ошибка
return echo.NewHTTPError(http.StatusNotFound, "todo not found")

// Любая ошибка Go — попадёт в HTTPErrorHandler как 500
return fmt.Errorf("database error: %w", err)

// nil — успешный ответ
return c.JSON(http.StatusOK, result)

Graceful Shutdown в Echo

func main() {
    e := echo.New()
    e.HideBanner = true

    // Роуты и middleware...

    // Запуск сервера в горутине
    go func() {
        if err := e.Start(":8080"); err != http.ErrServerClosed {
            e.Logger.Fatal(err)
        }
    }()

    // Ожидание сигнала завершения
    quit := make(chan os.Signal, 1)
    signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
    <-quit

    // Graceful shutdown с таймаутом 10 секунд
    ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
    defer cancel()

    if err := e.Shutdown(ctx); err != nil {
        e.Logger.Fatal(err)
    }
}

Echo vs Gin — коротко

Оба фреймворка решают одну задачу и очень похожи. Ключевые различия:

	Echo	Gin
Контекст	`echo.Context` — единый объект	`*gin.Context` — единый объект
Возврат ошибки	`return error` из обработчика	нет, всё через `c.JSON`
Встроенный middleware	богатый набор	базовый набор
Валидация	через интерфейс, любая библиотека	встроенная через binding
Производительность	чуть быстрее в бенчмарках	сопоставимо
Популярность	меньше	больше звёзд на GitHub

Echo удобнее тем, что обработчик возвращает error — это идиоматично для Go и упрощает централизованную обработку ошибок. В Gin нужно явно вызывать c.JSON и c.Abort в каждом обработчике, что многословнее.

Вопросы на собеседовании

Q: Из каких слоёв обычно состоит backend-приложение на Go?
A: Handler (transport) — знает про HTTP, парсит запросы и формирует ответы. Service — содержит бизнес-логику, не знает про HTTP и БД. Repository — работает с базой данных, только SQL и маппинг. Такое разделение делает каждый слой тестируемым независимо.

Q: Что такое echo.Context и чем он удобнее пары (w, r)?
A: Единый объект объединяющий запрос и ответ с удобными методами: Bind для декодирования, Param/QueryParam для параметров, JSON/String для ответа. Вместо двух аргументов — один, и возврат error вместо явной записи в ResponseWriter.

Q: Как работает Bind в Echo?
A: Автоматически определяет формат данных по заголовку Content-Type и декодирует тело запроса в переданную структуру. Поддерживает JSON, form-data, query параметры и path параметры через struct теги.

Q: Как централизовать обработку ошибок в Echo?
A: Через e.HTTPErrorHandler — функция, которая принимает ошибку и контекст. Все ошибки, возвращённые из обработчиков, попадают сюда. Позволяет единообразно форматировать ошибки, логировать их и возвращать клиенту.

Q: Чем отличается c.Set/c.Get от context.WithValue?
A: c.Set/c.Get — хранилище пар ключ-значение внутри Echo-контекста, специфичное для фреймворка. context.WithValue — стандартный механизм Go, работает везде включая сторонние библиотеки. Для передачи данных в библиотеки (например, в database/sql через ctx) нужен стандартный context, доступный через c.Request().Context().

Q: Зачем нужен Graceful Shutdown? Что без него произойдёт?
A: Без него при остановке процесса активные запросы получат обрыв соединения — клиент увидит ошибку сети вместо нормального ответа. Graceful Shutdown перестаёт принимать новые соединения и ждёт завершения текущих запросов перед остановкой.

Следующий шаг — итоговый проект: Todo API. Соберём всё вместе: Echo, слоистая архитектура, работа с in-memory хранилищем (без реальной БД чтобы не усложнять), контекст, graceful shutdown и базовая валидация. Переходим?

echoфреймворкмаршрутизацияmiddlewareвалидация