Golang + Redux

Привет, Хабр!

Сегодня мы попробуем реализовать управление состоянием в Go‑приложениях с помощью паттерна Redux. Да‑да, Redux не только для JS.

Redux — это предсказуемый контейнер состояния для приложений. Он помогает управлять состоянием приложения централизованно, делая его более предсказуемым и удобным для отладки. В основном Redux ассоциируется с фронтендом на JavaScript, но принципы, лежащие в его основе, иногда могут подойти и для Go‑приложений.

Основные концепции Redux:

1. Store: Централизованное хранилище состояния.

2. Actions: Описания того, что произошло.

3. Reducers: Функции, которые определяют, как состояние изменяется в ответ на действия.

4. Dispatch: Процесс отправки действий в хранилище.

Создаем Redux-подобную систему в Go

Определяем состояние

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

// state.go package main  // Cat представляет собой котика type Cat struct {     ID        int     Name      string     Breed     string     IsAdopted bool }  // AppState хранит текущее состояние приложения type AppState struct {     Cats []Cat }

Определяем действия

Действия описывают, что происходит в нашем приложении. Например, добавление задачи, удаление задачи или изменение статуса задачи.

// actions.go package main  // ActionType определяет тип действия type ActionType string  const (     AddCat          ActionType = "ADD_CAT"     RemoveCat       ActionType = "REMOVE_CAT"     ToggleAdoption  ActionType = "TOGGLE_ADOPTION" )  // Action представляет собой действие type Action struct {     Type    ActionType     Payload interface{} }

Создаем редьюсеры

Редьюсеры определяют, как состояние изменяется в ответ на действия.

// reducers.go package main  // Reducer функция, которая принимает состояние и действие, и возвращает новое состояние type Reducer func(state AppState, action Action) AppState  // rootReducer объединяет все редьюсеры func rootReducer(state AppState, action Action) AppState {     switch action.Type {     case AddCat:         cat, ok := action.Payload.(Cat)         if !ok {             return state         }         cat.ID = len(state.Cats) + 1         state.Cats = append(state.Cats, cat)     case RemoveCat:         id, ok := action.Payload.(int)         if !ok {             return state         }         for i, cat := range state.Cats {             if cat.ID == id {                 state.Cats = append(state.Cats[:i], state.Cats[i+1:]...)                 break             }         }     case ToggleAdoption:         id, ok := action.Payload.(int)         if !ok {             return state         }         for i, cat := range state.Cats {             if cat.ID == id {                 state.Cats[i].IsAdopted = !state.Cats[i].IsAdopted                 break             }         }     default:         // Неизвестное действие, возвращаем состояние без изменений     }     return state }

Создаем хранилище

Хранилище управляет состоянием и обрабатывает действия через редьюсеры.

// store.go package main  import "sync"  // Store хранит состояние и позволяет подписываться на его изменения type Store struct {     state       AppState     reducer     Reducer     mutex       sync.RWMutex     subscribers []chan AppState }  // NewStore создает новое хранилище func NewStore(reducer Reducer, initialState AppState) *Store {     return &Store{         state:       initialState,         reducer:     reducer,         subscribers: make([]chan AppState, 0),     } }  // GetState возвращает текущее состояние func (s *Store) GetState() AppState {     s.mutex.RLock()     defer s.mutex.RUnlock()     return s.state }  // Dispatch отправляет действие и обновляет состояние func (s *Store) Dispatch(action Action) {     s.mutex.Lock()     s.state = s.reducer(s.state, action)     // Копируем подписчиков, чтобы избежать блокировок     subscribers := append([]chan AppState{}, s.subscribers...)     s.mutex.Unlock()      // Уведомляем всех подписчиков     for _, sub := range subscribers {         // Не блокируем основной поток         go func(ch chan AppState) {             ch <- s.state         }(sub)     } }  // Subscribe добавляет нового подписчика func (s *Store) Subscribe() chan AppState {     s.mutex.Lock()     defer s.mutex.Unlock()     ch := make(chan AppState, 1)     s.subscribers = append(s.subscribers, ch)     // Отправляем текущее состояние сразу после подписки     ch <- s.state     return ch }

Используем хранилище в приложении

Теперь можно использовать хранилище, редьюсеры и действия, приложении:

// main.go package main  import (     "fmt"     "time" )  func main() {     initialState := AppState{         Cats: []Cat{},     }      store := NewStore(rootReducer, initialState)      // Подписываемся на изменения состояния     subscriber := store.Subscribe()      // Запускаем горутину для обработки изменений состояния     go func() {         for state := range subscriber {             fmt.Println("Текущее состояние котиков:")             for _, cat := range state.Cats {                 status := "Не усыновлен"                 if cat.IsAdopted {                     status = "Усыновлен"                 }                 fmt.Printf("ID: %d, Имя: %s, Порода: %s, Статус: %s\n", cat.ID, cat.Name, cat.Breed, status)             }             fmt.Println("-----")         }     }()      // Диспатчим действия     store.Dispatch(Action{         Type: AddCat,         Payload: Cat{             Name:  "Мурзик",             Breed: "Сиамская",         },     })      store.Dispatch(Action{         Type: AddCat,         Payload: Cat{             Name:  "Барсик",             Breed: "Британская",         },     })      time.Sleep(500 * time.Millisecond) // Ждем, чтобы горутина успела обработать      store.Dispatch(Action{         Type:    ToggleAdoption,         Payload: 1,     })      time.Sleep(500 * time.Millisecond) // Ждем обновлений      store.Dispatch(Action{         Type:    RemoveCat,         Payload: 2,     })      time.Sleep(500 * time.Millisecond) // Ждем финальных обновлений }

Запускаем

После запуска получим следующий вывод:

Текущее состояние котиков: ID: 1, Имя: Мурзик, Порода: Сиамская, Статус: Не усыновлен ----- Текущее состояние котиков: ID: 1, Имя: Мурзик, Порода: Сиамская, Статус: Не усыновлен ID: 2, Имя: Барсик, Порода: Британская, Статус: Не усыновлен ----- Текущее состояние котиков: ID: 1, Имя: Мурзик, Порода: Сиамская, Статус: Усыновлен ID: 2, Имя: Барсик, Порода: Британская, Статус: Не усыновлен ----- Текущее состояние котиков: ID: 1, Имя: Мурзик, Порода: Сиамская, Статус: Усыновлен -----

Итак, этот паттерн хорошо впишется, если нужно централизованно управлять состоянием приложения и следить за его изменениями. Если проект растет и управление состоянием становится сложным, Redux-подход в Go может в чем-то упростить жизнь.

Но есть и пару моментов, о которых стоит помнить:

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

• Будь осторожен с подписками — без механизма отписки могут возникнуть утечки горутин.

• Не перегружай хранилище: хранение слишком большого состояния может замедлить приложение.

• Избегай гонок данных — всегда используй мьютексы или другие механизмы синхронизации при работе с состоянием.

Используй Redux-подход разумно. Если есть вопросы или идеи, пишите в комментариях.

В рамках курса «Software Architect» в ноябре пройдут открытые уроки:

• 7 ноября: «Стратегии тестирования в архитектуре микросервисов». Узнать подробнее

• 19 ноября: «Паттерны отказоустойчивости и масштабируемости микросервисной архитектуры». Узнать подробнее