Введение

Согласно официальному сайту, chi — это легковесный, идиоматический и композируемый маршрутизатор для создания HTTP-сервисов на Go. Он на 100% совместим с net/http и довольно легок в обращении, однако его документация предназначена скорее для опытных разработчиков, чем для новичков, поэтому я решил написать серию статей, в ходе которых мы будем постепенно развивать и перерабатывать простейший CRUD, написанный на chi.

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

Подготовка

Наш CRUD будет обслуживать хранение и обработку следующей структуры:

type CrudItem struct {
    Id          int
    Name        string
    Description string
    internal    string
}

За хранение записей будут отвечать следующие две переменные:

currentId := 1
storage := make(map[int]CrudItem)

Сущности мы будем сохранять в карте/словаре (вам как больше нравится?). При необходимости добавить значение в хранилище, оно добавляется по ключу currentId. Я хочу подчеркнуть, что это решение с запахом и не предназначено для использования в реальных проектах. В следующих частях мы отрефакторим механизм хранения, вынесем его за интерфейс и сделаем его потокобезопасным (но не сегодня).

CRUD

Простейшая программа с использованием chi будет выглядеть так:

package main
import (
    "net/http"
    "github.com/go-chi/chi/v5"
)  

func main() {
    r := chi.NewRouter()
    http.ListenAndServe(":3000", r)
}

Она ничего не делает, кроме создания структуры маршрутизатора и запуска его обслуживания на трехтысячном порту.
Создание простейшего обработчика и навешивание его на паттерн пути в chi выглядит следующим образом:

1. Выбрать метод марштрутизатора, соответствующий необходимому HTTP-методу

2. Передать в него паттерн пути и обработчик http.HandlerFunc (функция с сигнатурой  func(w http.ResponseWriter, r *http.Request)). Из коробки нам доступны следующие HTTP-методы:

Connect(pattern string, h http.HandlerFunc)
Delete(pattern string, h http.HandlerFunc)
Get(pattern string, h http.HandlerFunc)
Head(pattern string, h http.HandlerFunc)
Options(pattern string, h http.HandlerFunc)
Patch(pattern string, h http.HandlerFunc)
Post(pattern string, h http.HandlerFunc)
Put(pattern string, h http.HandlerFunc)
Trace(pattern string, h http.HandlerFunc)

Этого достаточно для написания стандартного CRUD-а, но если вам необходимо написать обработчик собственного кастомного HTTP-метода, то вам сначала необходимо зарегистрировать его с помощью chi.RegisterMethod("JELLO"), а затем навесить на паттерн пути в маршрутизаторе обработчик с помощью r.Method("JELLO", "/path", myJelloMethodHandler).

Create

Код регистрации обработчика для добавления нового CrudItem в наше импровизированное хранилище выглядит следующим образом:

r.Post("/crud-items/", func(w http.ResponseWriter, r *http.Request) {
        var item CrudItem
        err := json.NewDecoder(r.Body).Decode(&item)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            w.Write([]byte(err.Error()))
            return
        }
        item.Id = currentId
        storage[currentId] = item
        jsonItem, err := json.Marshal(item)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        w.Write(jsonItem)
        currentId += 1
    })

Что из себя представляет наша реализация обработчика:

1. Пытаемся прочитать из тела запроса json и десериализовать его в структуру CrudItem. Валидный JSON выглядит так:

{
	"name": "New name",
	"description": "New description"
}

2. Если по какой-то причине нам не удалось это сделать, мы говорим пользователю о том, что с его запросом что-то не так и заканчиваем работу.

3. Присваиваем сущности Id и сохраняем в наше хранилище. Ходят легенды, что в хороших CRUD-ах принято возвращать добавленный объект с присвоенными ему идентификаторами, и мы поступаем так же:

4. Сериализуем структуру CrudItem в json;

5. В случае провала говорим пользователю, что что-то пошло не так по нашей вине;

6. В случае успеха отправляем пользователю json и инкрементим текущий Id.

Read

Чтение мы сделаем двумя обработчиками:

• Прочитать все записи;

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

r.Get("/crud-items/", func(w http.ResponseWriter, r *http.Request) {
        result := make([]CrudItem, 0, len(storage))
        for _, item := range storage {
            result = append(result, item)
        }
        resultJson, err := json.Marshal(result)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        w.Write(resultJson)
    })

Гораздо интереснее выглядит обработчик получения записи по Id:

r.Get("/crud-items/{id}", func(w http.ResponseWriter, r *http.Request) {
        idStr := chi.URLParam(r, "id")
        id, err := strconv.Atoi(idStr)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            w.Write([]byte(err.Error()))
            return
        }
        if _, ok := storage[id]; !ok {
            w.WriteHeader(http.StatusNotFound)
            return
        }
        resultJson, err := json.Marshal(storage[id])
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        w.Write(resultJson)
    })

Здесь мы воспользовались получением id записи из URL. Для этого мы:

1. Задали в паттерне пути именной параметр id с помощью {id};

2. С помощью chi.URLParam(r, "id") получили строковое значение параметра id;

3. Попробовали привести параметр id к целому числу и в случае провала сообщили пользователю, что с его запросом что-то не так.

Update

Объединив реализации обработчика для добавления новой записи и получения записи по id мы можем соорудить обработчик для обновления записи:

r.Put("/crud-items/{id}", func(w http.ResponseWriter, r *http.Request) {
        idStr := chi.URLParam(r, "id")
        id, err := strconv.Atoi(idStr)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            w.Write([]byte(err.Error()))
            return
        }
        if _, ok := storage[id]; !ok {
            w.WriteHeader(http.StatusNotFound)
            return
        }
        var item CrudItem
        err = json.NewDecoder(r.Body).Decode(&item)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            w.Write([]byte(err.Error()))
            return
        }
        item.Id = id
        storage[id] = item
        jsonItem, err := json.Marshal(item)
        if err != nil {
            w.WriteHeader(http.StatusInternalServerError)
            w.Write([]byte(err.Error()))
            return
        }
        w.Write(jsonItem)
    })

Delete

Удаление записи из нашего хранилища выглядит следующим образом:

r.Delete("/crud-items/{id}", func(w http.ResponseWriter, r *http.Request) {
        idStr := chi.URLParam(r, "id")
        id, err := strconv.Atoi(idStr)
        if err != nil {
            w.WriteHeader(http.StatusBadRequest)
            w.Write([]byte(err.Error()))
            return
        }
        
        if _, ok := storage[id]; !ok {
            w.WriteHeader(http.StatusNotFound)
            return
        }
        delete(storage, id)
    })

По сути, удаление записи это удаление элемента словаря с предварительной проверкой наличия элемента.

Что дальше?

На этом создание базового приложения заканчивается. Сегодня мы реализовали CRUD с 5-ю обработчиками, используя маршрутизатор chi, научились читать json из тела запроса, отправлять его в ответ и получать значение из паттерна пути.
Чему будут посвящены следующие статьи:

• Рефакторинг хранилища и вынос его за интерфейс;

• Пагинация для обработчика получения всех записей с использованием middleware;

• Использование интерфейса Renderer и создание нормальных DTO;

• Добавление логирования;

• Авторизация;

• Работа с prometeus (создание обработчика и написание middleware для сбора статистики по обработчикам).

Свои идеи, предложения и вопросы пишите в комментарии или мне в телеграм.