🐹 Go

Padrões de projeto em Go (Golang): um guia detalhado

Lição 31 / 35 • Leitura completa da teoria

Что это такое и зачем? (аналогия из реальной жизни)

Представь, что ты строишь дом. Ты можешь каждый раз изобретать велосипед: придумывать, как соединять брёвна, как делать крышу, как проводить электричество. А можешь воспользоваться готовыми чертежами и решениями, которые придумали архитекторы до тебя. Эти готовые решения называются паттернами проектирования (design patterns).

В программировании паттерны — это проверенные способы решать типичные задачи. Они не дают готового кода (как библиотека), а предлагают шаблон — общую схему, которую ты адаптируешь под свою задачу.

Аналогия из жизни: Представь, что ты учишься готовить. Вместо того чтобы каждый раз экспериментировать с солью и сахаром, ты используешь рецепт. Паттерн — это рецепт для программиста. Ты знаешь, какие ингредиенты (классы, функции) нужны и в каком порядке их смешивать.

Зачем это нужно? Во-первых, экономия времени. Ты не изобретаешь велосипед, а берёшь готовое решение. Во-вторых, понятность. Другие программисты, зная паттерны, сразу поймут твой код. В-третьих, надёжность. Паттерны проверены тысячами проектов, в них меньше ошибок.

В этой статье мы разберём три основных типа паттернов: порождающие (как создавать объекты), структурные (как организовывать классы) и поведенческие (как объекты общаются друг с другом). И всё это на примере языка Go (Golang).

Теория: как это работает изнутри

Паттерны проектирования — это не магия, а просто организация кода. Давай разберёмся, из чего они состоят.

У каждого паттерна есть четыре части:

Название — чтобы мы могли обсуждать решение: «Давай используем Singleton».
Задача — какую проблему решает паттерн.
Решение — схема классов и их взаимодействие.
Результат — что мы получаем (плюсы и минусы).

В Go паттерны выглядят немного иначе, чем в Java или Python. Почему? Потому что в Go нет классов в классическом понимании — есть структуры (struct) и интерфейсы. Но это не мешает, а даже помогает: код становится проще и прозрачнее.

Давай разберём три главных паттерна, которые ты будешь использовать чаще всего:

Тип паттерна	Название	Что делает	Пример из жизни
Порождающий	Singleton (Одиночка)	Гарантирует, что у класса есть только один объект	Один президент в стране
Структурный	Adapter (Адаптер)	Позволяет объектам с разными интерфейсами работать вместе	Переходник для зарядки телефона
Поведенческий	Observer (Наблюдатель)	Оповещает объекты об изменениях в другом объекте	Подписка на YouTube: ты получаешь уведомление, когда выходит новое видео

Теперь давай посмотрим, как это выглядит в коде.

Синтаксис в Go (Golang): все формы и варианты

В Go нет ключевого слова class. Вместо этого мы используем структуры (struct) и методы. Интерфейсы в Go — это набор методов, которые должна реализовать структура.

Вот как выглядят основные строительные блоки для паттернов:

// Структура — это как класс в других языках
type Car struct {
    Brand string
    Model string
    Year  int
}

// Метод — функция, привязанная к структуре
func (c Car) Info() string {
    return c.Brand + " " + c.Model + " (" + string(rune(c.Year)) + ")"
}

// Интерфейс — набор требований
type Vehicle interface {
    Start() string
    Stop() string
}

// Реализация интерфейса
func (c Car) Start() string {
    return "Машина завелась"
}

func (c Car) Stop() string {
    return "Машина остановилась"
}

Для паттернов нам понадобятся:

Интерфейсы — чтобы описать общее поведение.
Структуры — чтобы хранить данные.
Методы — чтобы реализовать логику.
Фабричные функции — чтобы создавать объекты (вместо конструкторов).

В Go нет наследования, но есть композиция — когда одна структура содержит другую. Это даже удобнее для паттернов.

Примеры кода — от простого к сложному

Пример 1: Singleton (Одиночка) — простейший вариант

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

// database.go
package main

import "sync"

// Database — структура, которая будет существовать в единственном экземпляре
type Database struct {
    connection string
}

// Объявляем переменную, которая будет хранить единственный экземпляр
var instance *Database

// Mutex нужен для безопасной работы в многопоточном режиме
var once sync.Once

// GetInstance — фабричная функция, которая возвращает единственный экземпляр
func GetInstance() *Database {
    // once.Do гарантирует, что функция выполнится только один раз
    once.Do(func() {
        // Создаём экземпляр только при первом вызове
        instance = &Database{connection: "postgres://localhost:5432/mydb"}
    })
    // Возвращаем существующий экземпляр
    return instance
}

func main() {
    // Получаем доступ к базе данных
    db1 := GetInstance()
    db2 := GetInstance()
    
    // Проверяем, что это один и тот же объект
    if db1 == db2 {
        println("Это один и тот же объект! Singleton работает.")
    }
}

Объяснение: sync.Once — это специальный механизм в Go, который выполняет функцию только один раз, даже если её вызывают из разных потоков. Мы используем его, чтобы создать базу данных только при первом обращении.

Пример 2: Factory (Фабрика) — создание объектов без указания конкретного типа

Допустим, ты пишешь игру. В ней есть разные типы врагов: зомби, скелеты, пауки. Вместо того чтобы создавать каждого вручную, ты используешь фабрику.

// enemy.go
package main

import "fmt"

// Enemy — интерфейс, который должны реализовать все враги
type Enemy interface {
    Attack() string
    GetName() string
}

// Zombie — конкретный тип врага
type Zombie struct {
    name string
}

func (z Zombie) Attack() string {
    return "Зомби кусает!"
}

func (z Zombie) GetName() string {
    return z.name
}

// Skeleton — ещё один тип врага
type Skeleton struct {
    name string
}

func (s Skeleton) Attack() string {
    return "Скелет стреляет из лука!"
}

func (s Skeleton) GetName() string {
    return s.name
}

// EnemyFactory — фабрика, которая создаёт врагов по типу
func EnemyFactory(enemyType string) Enemy {
    switch enemyType {
    case "zombie":
        return Zombie{name: "Зомби"}
    case "skeleton":
        return Skeleton{name: "Скелет"}
    default:
        return nil
    }
}

func main() {
    // Создаём врагов через фабрику
    enemy1 := EnemyFactory("zombie")
    enemy2 := EnemyFactory("skeleton")
    
    // Используем их, не зная конкретного типа
    fmt.Println(enemy1.GetName(), ":", enemy1.Attack())
    fmt.Println(enemy2.GetName(), ":", enemy2.Attack())
}

Объяснение: Фабрика возвращает интерфейс Enemy, а не конкретную структуру. Это значит, что мы можем добавить нового врага (например, Spider), и код, который использует врагов, не придётся менять.

Пример 3: Adapter (Адаптер) — соединяем несовместимое

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

// adapter.go
package main

import "fmt"

// OldPrinter — старый интерфейс, который мы хотим использовать
type OldPrinter interface {
    PrintOld(text string) string
}

// LegacyPrinter — старая реализация принтера
type LegacyPrinter struct{}

func (l LegacyPrinter) PrintOld(text string) string {
    return "Старый принтер печатает: " + text
}

// NewPrinter — новый интерфейс, который ожидает наша программа
type NewPrinter interface {
    PrintNew(text string) string
}

// PrinterAdapter — адаптер, который превращает старый принтер в новый
type PrinterAdapter struct {
    oldPrinter OldPrinter
}

// PrintNew — реализуем новый интерфейс, используя старый
func (a PrinterAdapter) PrintNew(text string) string {
    // Адаптер вызывает старый метод
    return a.oldPrinter.PrintOld(text) + " (через адаптер)"
}

func main() {
    // Создаём старый принтер
    old := LegacyPrinter{}
    
    // Создаём адаптер, передавая ему старый принтер
    adapter := PrinterAdapter{oldPrinter: old}
    
    // Теперь можем использовать старый принтер через новый интерфейс
    result := adapter.PrintNew("Привет, мир!")
    fmt.Println(result)
}

Объяснение: Адаптер содержит внутри себя старый объект и реализует новый интерфейс. Когда вызывается новый метод, адаптер перенаправляет вызов старому методу, возможно, преобразуя данные.

Пример 4: Observer (Наблюдатель) — система уведомлений

Представь, что ты подписан на канал с мемами. Когда выходит новый мем, ты получаешь уведомление.

// observer.go
package main

import "fmt"

// Observer — интерфейс для подписчиков
type Observer interface {
    Update(message string)
}

// Subject — интерфейс для канала, за которым следят
type Subject interface {
    Register(observer Observer)
    Unregister(observer Observer)
    NotifyAll()
}

// MemeChannel — конкретный канал с мемами
type MemeChannel struct {
    observers []Observer
    lastMeme  string
}

// Register — добавляем подписчика
func (m *MemeChannel) Register(observer Observer) {
    m.observers = append(m.observers, observer)
}

// Unregister — удаляем подписчика
func (m *MemeChannel) Unregister(observer Observer) {
    for i, obs := range m.observers {
        if obs == observer {
            m.observers = append(m.observers[:i], m.observers[i+1:]...)
            break
        }
    }
}

// NotifyAll — оповещаем всех подписчиков
func (m *MemeChannel) NotifyAll() {
    for _, observer := range m.observers {
        observer.Update(m.lastMeme)
    }
}

// NewMeme — публикуем новый мем
func (m *MemeChannel) NewMeme(meme string) {
    m.lastMeme = meme
    m.NotifyAll()
}

// User — конкретный подписчик
type User struct {
    name string
}

func (u User) Update(message string) {
    fmt.Printf("Пользователь %s получил уведомление: %s
", u.name, message)
}

func main() {
    // Создаём канал
    channel := &MemeChannel{}
    
    // Создаём подписчиков
    user1 := User{name: "Анна"}
    user2 := User{name: "Борис"}
    
    // Подписываем их
    channel.Register(user1)
    channel.Register(user2)
    
    // Публикуем новый мем
    channel.NewMeme("Кот в шляпе")
    
    // Отписываем Бориса
    channel.Unregister(user2)
    
    // Публикуем ещё один мем
    channel.NewMeme("Собака-программист")
}

Объяснение: Канал хранит список подписчиков. Когда появляется новый контент, он проходит по списку и вызывает метод Update у каждого. Подписчики могут добавляться и удаляться в любой момент.

Пример 5: Strategy (Стратегия) — выбираем алгоритм на лету

Ты пишешь калькулятор, который может выполнять разные операции: сложение, вычитание, умножение. Вместо того чтобы писать кучу if-else, используешь стратегию.

// strategy.go
package main

import "fmt"

// Strategy — интерфейс для всех алгоритмов
type Strategy interface {
    Execute(a, b int) int
}

// Addition — конкретная стратегия
type Addition struct{}

func (Addition) Execute(a, b int) int {
    return a + b
}

// Subtraction — ещё одна стратегия
type Subtraction struct{}

func (Subtraction) Execute(a, b int) int {
    return a - b
}

// Multiplication — третья стратегия
type Multiplication struct{}

func (Multiplication) Execute(a, b int) int {
    return a * b
}

// Calculator — контекст, который использует стратегию
type Calculator struct {
    strategy Strategy
}

// SetStrategy — меняем стратегию на лету
func (c *Calculator) SetStrategy(strategy Strategy) {
    c.strategy = strategy
}

// Calculate — выполняем операцию
func (c *Calculator) Calculate(a, b int) int {
    return c.strategy.Execute(a, b)
}

func main() {
    calc := &Calculator{}
    
    // Используем сложение
    calc.SetStrategy(Addition{})
    fmt.Println("10 + 5 =", calc.Calculate(10, 5))
    
    // Меняем на вычитание
    calc.SetStrategy(Subtraction{})
    fmt.Println("10 - 5 =", calc.Calculate(10, 5))
    
    // Меняем на умножение
    calc.SetStrategy(Multiplication{})
    fmt.Println("10 * 5 =", calc.Calculate(10, 5))
}

Объяснение: Калькулятор не знает, какую операцию выполняет. Он просто вызывает метод Execute у текущей стратегии. Это позволяет добавлять новые операции без изменения кода калькулятора.

Пример 6: Decorator (Декоратор) — добавляем функциональность без изменения класса

Представь, что ты заказываешь пиццу. Можно добавить сыр, грибы, колбасу. Каждая добавка — это декоратор.

// decorator.go
package main

import "fmt"

// Pizza — интерфейс для пиццы
type Pizza interface {
    GetPrice() int
    GetDescription() string
}

// BasePizza — базовая пицца
type BasePizza struct{}

func (b BasePizza) GetPrice() int {
    return 100 // базовая цена
}

func (b BasePizza) GetDescription() string {
    return "Пицца"
}

// CheeseDecorator — декоратор для сыра
type CheeseDecorator struct {
    pizza Pizza
}

func (c CheeseDecorator) GetPrice() int {
    return c.pizza.GetPrice() + 20 // добавляем цену сыра
}

func (c CheeseDecorator) GetDescription() string {
    return c.pizza.GetDescription() + " с сыром"
}

// MushroomDecorator — декоратор для грибов
type MushroomDecorator struct {
    pizza Pizza
}

func (m MushroomDecorator) GetPrice() int {
    return m.pizza.GetPrice() + 30
}

func (m MushroomDecorator) GetDescription() string {
    return m.pizza.GetDescription() + " с грибами"
}

func main() {
    // Создаём базовую пиццу
    pizza := BasePizza{}
    
    // Добавляем сыр
    pizzaWithCheese := CheeseDecorator{pizza: pizza}
    
    // Добавляем грибы
    pizzaWithCheeseAndMushrooms := MushroomDecorator{pizza: pizzaWithCheese}
    
    fmt.Println(pizzaWithCheeseAndMushrooms.GetDescription())
    fmt.Println("Цена:", pizzaWithCheeseAndMushrooms.GetPrice(), "рублей")
}

Объяснение: Каждый декоратор содержит внутри себя объект пиццы и добавляет свою функциональность. Можно комбинировать декораторы в любом порядке.

Пример 7: Command (Команда) — превращаем действия в объекты

Ты пишешь пульт для телевизора. Каждая кнопка — это команда. Можно записать макросы, отменять действия.

// command.go
package main

import "fmt"

// Command — интерфейс для всех команд
type Command interface {
    Execute()
    Undo()
}

// TV — получатель команд (телевизор)
type TV struct {
    isOn bool
}

func (t *TV) TurnOn() {
    t.isOn = true
    fmt.Println("Телевизор включён")
}

func (t *TV) TurnOff() {
    t.isOn = false
    fmt.Println("Телевизор выключен")
}

// TurnOnCommand — команда включения
type TurnOnCommand struct {
    tv *TV
}

func (c TurnOnCommand) Execute() {
    c.tv.TurnOn()
}

func (c TurnOnCommand) Undo() {
    c.tv.TurnOff()
}

// TurnOffCommand — команда выключения
type TurnOffCommand struct {
    tv *TV
}

func (c TurnOffCommand) Execute() {
    c.tv.TurnOff()
}

func (c TurnOffCommand) Undo() {
    c.tv.TurnOn()
}

// RemoteControl — пульт, который хранит команды
type RemoteControl struct {
    command Command
    history []Command
}

func (r *RemoteControl) SetCommand(command Command) {
    r.command = command
}

func (r *RemoteControl) PressButton() {
    r.command.Execute()
    r.history = append(r.history, r.command)
}

func (r *RemoteControl) PressUndo() {
    if len(r.history) > 0 {
        lastCommand := r.history[len(r.history)-1]
        lastCommand.Undo()
        r.history = r.history[:len(r.history)-1]
    }
}

func main() {
    tv := &TV{}
    
    turnOn := TurnOnCommand{tv: tv}
    turnOff := TurnOffCommand{tv: tv}
    
    remote := &RemoteControl{}
    
    // Включаем телевизор
    remote.SetCommand(turnOn)
    remote.PressButton()
    
    // Выключаем
    remote.SetCommand(turnOff)
    remote.PressButton()
    
    // Отменяем последнее действие (снова включаем)
    remote.PressUndo()
}

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

Сравнение с Python: чем похоже и чем отличается

Python и Go — оба популярные языки, но паттерны в них реализуются по-разному. Давай сравним.

Аспект	Go	Python
Классы	Нет классов, есть структуры и методы	Есть полноценные классы с наследованием
Интерфейсы	Неявные: структура реализует интерфейс, если у неё есть нужные методы	Явные: класс должен наследовать интерфейс (ABC)
Наследование	Нет, используется композиция (встраивание структур)	Есть множественное наследование
Singleton	Через sync.Once или инициализацию пакета	Через __new__ или декоратор
Фабрика	Функция, возвращающая интерфейс	Класс или функция, возвращающая объект
Производительность	Высокая, компилируемый язык	Ниже, интерпретируемый язык

Главное отличие: В Go паттерны получаются более «плоскими» из-за отсутствия наследования. Вместо длинных цепочек классов ты используешь композицию — один объект содержит другой. Это делает код проще и понятнее.

Пример Singleton на Python для сравнения:

class Database:
    _instance = None
    
    def __new__(cls):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance.connection = "postgres://localhost:5432/mydb"
        return cls._instance

# Использование
db1 = Database()
db2 = Database()
print(db1 is db2)  # True

В Go тот же паттерн требует явного управления горутинами и синхронизацией, но даёт больше контроля над производительностью.

Типичные ошибки и подводные камни

Даже опытные программисты допускают ошибки при использовании паттернов. Вот самые частые:

Избыточность. Не используй паттерн, если задача решается простой функцией. Паттерны — это инструмент, а не цель.
Неправильный Singleton. В Go легко создать несколько экземпляров, если забыть про sync.Once или мьютекс. Всегда проверяй потокобезопасность.
Путаница с интерфейсами. В Go интерфейсы неявные. Если структура случайно реализует интерфейс, это может привести к неожиданным ошибкам.
Игнорирование композиции. Новички пытаются эмулировать наследование через встраивание структур, но это не всегда правильно. Композиция — это «имеет», а не «является».
Сложность Observer. Если подписчиков много, уведомления могут занять много времени. В Go используй горутины для асинхронной рассылки.
Забыли про Undo в Command. Если реализуешь команды, всегда продумывай отмену. Иначе пользователь застрянет.
Смешивание стратегий. Не храни состояние в стратегии. Стратегия — это чистый алгоритм, без данных.

Важно: Паттерны — это не догма. Если ты видишь, что паттерн усложняет код, а не упрощает — откажись от него. Иногда лучше написать простой if-else, чем разворачивать целую фабрику.

Лучшие практики и советы профессионалов

Вот что советуют опытные Go-разработчики:

Начинай с малого. Не пытайся внедрить все паттерны сразу. Выбери один, который решает твою конкретную проблему.
Используй интерфейсы для гибкости. Всегда возвращай интерфейс из фабрики, а не конкретную структуру. Это позволит легко подменять реализации.
Пиши тесты. Паттерны упрощают тестирование. Например, Strategy позволяет подменить алгоритм на тестовый.
Документируй. Если используешь паттерн, напиши комментарий: «Здесь используется паттерн Observer для уведомлений». Это поможет коллегам.
Не бойся композиции. В Go композиция — это основной способ переиспользования кода. Встраивай структуры друг в друга, но помни про границы ответственности.
Изучай стандартную библиотеку. В Go много встроенных механизмов, которые заменяют паттерны. Например, sync.Once — это готовый Singleton, а каналы — это Observer.
Думай о производительности. В Go важна эффективность. Если паттерн создаёт много мелких объектов (как Decorator), это может замедлить программу. Профилируй код.

Вопросы для самопроверки

Что такое паттерн проектирования простыми словами?
Ответ: Это готовый шаблон решения типичной задачи в программировании. Как рецепт для приготовления блюда.
Какие три основных типа паттернов существуют?
Ответ: Порождающие (создание объектов), структурные (организация классов), поведенческие (взаимодействие объектов).
Зачем нужен Singleton?
Ответ: Чтобы гарантировать, что у класса есть только один экземпляр. Например, для подключения к базе данных.
Чем отличается Factory от Singleton?
Ответ: Factory создаёт объекты разных типов, а Singleton гарантирует, что объект только один. Factory может возвращать разные объекты, Singleton — всегда один и тот же.
Как реализовать Adapter в Go?
Ответ: Создать структуру, которая содержит старый объект и реализует новый интерфейс. В методах новой структуры вызывать методы старого объекта.
В чём разница между Observer и Strategy?
Ответ: Observer оповещает множество объектов об изменениях (один ко многим). Strategy позволяет менять алгоритм у одного объекта (один к одному).
Почему в Go нет классического наследования?
Ответ: Go использует композицию вместо наследования. Это делает код проще и избегает проблем множественного наследования.
Какой паттерн использовать, если нужно добавить новую функциональность объекту без изменения его кода?
Ответ: Decorator (Декоратор). Он оборачивает объект и добавляет новые методы или свойства.
Что такое «композиция» в Go?
Ответ: Это когда одна структура содержит другую. Например, type Car struct { Engine }. Машина «имеет» двигатель.
Какой паттерн используется для реализации отмены действий (Undo)?
Ответ: Command (Команда). Каждая команда хранит метод Execute и Undo, а история команд позволяет откатывать действия.

Итог и что изучить дальше

Мы разобрали семь основных паттернов проектирования на Go. Ты узнал, как они работают, увидел примеры кода и понял, где их применять. Главный вывод: паттерны — это не магия, а просто организация кода. Они помогают писать понятные, гибкие и надёжные программы.

Что изучать дальше?

Другие паттерны: Builder, Prototype, Facade, Proxy, Chain of Responsibility, Mediator, Memento.
Продвинутые темы Go: горутины, каналы, контексты — они часто заменяют паттерны.
Чистая архитектура: как паттерны вписываются в большие проекты.
Рефакторинг: как превратить плохой код в хороший с помощью паттернов.

Помни: лучший способ выучить паттерны — писать код. Открой Go Playground или установи Go на компьютер и попробуй реализовать каждый пример самостоятельно. Изменяй их, комбинируй, придумывай свои задачи. Удачи!

← Anterior Algoritmos de busca em Go (Golang): um guia detalh Próximo → Multithreading e assincronia em Go (Golang): um gu