![](https://habrastorage.org/getpro/habr/upload_files/4a2/277/762/4a227776275e1230cbf4a1fbd526bb2b.png)
Привет, Хабр! В предыдущей статье я поделился своей версией шаблона Go-микросервиса для начинающих, чтобы помочь тем, кто только начинает знакомиться с языком и еще не полностью его освоил. В этом продолжении я хочу подойти к задаче более серьезно и создать полностью функциональный сервис с необходимой инфраструктурой, которую мы развернем в Docker. Кроме того, я планирую внести изменения в структуру проекта, учитывая замечания из комментариев и анализа кода других проектов.
Содержание
Создание шаблона решил представить в виде небольшого проекта книжного магазина для простоты понимания. Как это будет выглядеть и что мы будем реализовывать, я отразил на схеме, прикрепленной ниже:
![Визуальная схема, того, что мы хотим сделать Визуальная схема, того, что мы хотим сделать](https://habrastorage.org/getpro/habr/upload_files/994/e6e/fdc/994e6efdcbf285cad0aa2e630e7bf27f.png)
Теперь переходим от описания того, что мы хотим реализовать, к тому, как будет выглядеть наш микросервис.
Начнем с того, как будет взаимодействовать клиент с нашим книжным магазином. Для взаимодействия мы выбираем REST API, которое будет включать в себя следующие запросы:
GET /api/v1/books - Получение списка книг клиентом, доступных для продажи.
POST /api/v1/books - Добавление новой книги в наш магазин.
POST /api/v1/books/buy - Приобретение книги содержащейся в нашем магазине
В своей архитектуре микросервиса я решил отказаться от классического сервисного подхода в пользу CQRS с использованием библиотеки MediatR, где в качестве контрактов API будут выступать команды (Command) и запросы (Query). Такое решение очень хорошо ложится на микросервисы в .NET, и я думаю, что в Go это тоже не вызовет особых трудностей, так как на GitHub я видел множество проектов, работающих на такой основе.
Имитировать поставку книг мы будем с помощью фоновой задачи, запущенной вместе с HTTP-сервером. Эта задача будет отправлять новые книги в Kafka, а наш consumer будет сохранять их в нашем магазине. Этот элемент я добавил для того, чтобы показать пример взаимодействия с Kafka, так что претензии по поводу целесообразности использования Kafka здесь не принимаются.
![Общая схема работы нашего магазина Общая схема работы нашего магазина](https://habrastorage.org/getpro/habr/upload_files/8e9/351/6f3/8e93516f3342a3eed376daf22c0fd10e.png)
Тесты, которые я приготовил для данного проекта, являются компонентными. Это своего рода аналог end-to-end тестов, но всё необходимое окружение для приложения поднимается в контейнерах, имитируя работу настоящего API. Ознакомиться с тем, что такое компонентные тесты, можно в следующей статье.
Однако они будут в продолжении данного шаблона и в следующей отдельной статье, также как и часть с kafka.
Начинаем
Посмотрев различные реальные проекты на GitHub, я решил немного отойти от той структуры, которую описывал в предыдущей статье. Я долго обдумывал это и пришел к следующему решению.
Для начала создадим проект и добавим в него первый каталог cmd
, в который поместим наш основной файл main.go
. Аналогом в последних версиях .NET выступает файл Program.cs
, в котором происходит конфигурация нашего сервера.
Конфигурация нашего сервиса будет происходить с помощью библиотеки "go.uber.org/fx", поэтому откроем консоль и выполним следующую команду:
go get "go.uber.org/fx"
Заполняем main.go следующим образом.
package main
import "go.uber.org/fx"
func main() {
fx.New(
fx.Options(
fx.Provide(),
),
).Run()
}
Uber FX представляет собой обёртку, в которой мы регистрируем все необходимые зависимости и также запускаем задачи на обработку.
Для большего понимания покажу, как бы это выглядело на .NET:
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.Run();
Нам нужно сконфигурировать наш HTTP-сервер, который будет обрабатывать входящие запросы. Для этих целей я решил использовать библиотеку Echo.
go get "github.com/labstack/echo/v4"
go get "github.com/labstack/gommon/log"
Переходим в каталог, где будут лежать наши общие для сервисов пакеты pkg
, и создаём каталог http
, в котором создаём каталог server
с файлом echo_server.go
.
package echoserver
import (
"context"
"github.com/labstack/echo/v4"
"github.com/labstack/gommon/log"
"time"
)
const (
MaxHeaderBytes = 1 << 20
ReadTimeout = 15 * time.Second
WriteTimeout = 15 * time.Second
)
type EchoConfig struct {
Port string `mapstructure:"port" validate:"required"`
Development bool `mapstructure:"development"`
BasePath string `mapstructure:"basePath" validate:"required"`
DebugErrorsResponse bool `mapstructure:"debugErrorsResponse"`
IgnoreLogUrls []string `mapstructure:"ignoreLogUrls"`
Timeout int `mapstructure:"timeout"`
Host string `mapstructure:"host"`
}
func NewEchoServer() *echo.Echo {
e := echo.New()
return e
}
// RunHttpServer - запустить наш HTTP-сервер
func RunHttpServer(ctx context.Context, echo *echo.Echo, cfg *EchoConfig) error {
echo.Server.ReadTimeout = ReadTimeout
echo.Server.WriteTimeout = WriteTimeout
echo.Server.MaxHeaderBytes = MaxHeaderBytes
go func() {
for {
select {
case <-ctx.Done():
log.Infof("Сервер завершает свою работу. HTTP POST: {%s}", cfg.Port)
err := echo.Shutdown(ctx)
if err != nil {
log.Errorf("(ОТКЛЮЧЕНИЕ СЕРВЕРА) ошибка: {%v}", err)
return
}
return
}
}
}()
err := echo.Start(cfg.Port)
return err
}
В данном коде содержится непосредственно конфигурация нашего сервера и функция для непосредственно запуска.
Также нам необходимо создать файл context_provider.go
в каталоге http
, который будет останавливать работу сервера и отменять операции. Аналогом в .NET выступает CancellationToken.
package http
import (
"context"
"github.com/labstack/gommon/log"
"os"
"os/signal"
"syscall"
)
// NewContext - создать новый контекст приложения. Context - является аналогом CancellationToken
func NewContext() context.Context {
ctx, cancel := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM, syscall.SIGINT)
go func() {
for {
select {
case <-ctx.Done():
log.Info("context is canceled!")
cancel()
return
}
}
}()
return ctx
}
Как это будет выглядеть:
![](https://habrastorage.org/getpro/habr/upload_files/ef7/7e9/9f1/ef77e99f1702bd0fffef530729cb8d86.png)
Добавления конфигурации приложения
Далее для конфигурирования нашего сервиса необходимо подгружать основные настройки из конфигурационных файлов в формате JSON.
Библиотека, которая работает с конфигурация Viper, по-этому для начала подключим ее в проект.
go get "github.com/spf13/viper"
Теперь в корне проекта создаем папку config
с файлами config.go
, config.development.json
Содержимое config.go
package config
import (
"fmt"
"github.com/pkg/errors"
"github.com/spf13/viper"
echoserver "go-template-microservice-v2/pkg/http/server"
"os"
)
type Config struct {
ServiceName string `mapstructure:"serviceName"`
Echo *echoserver.EchoConfig `mapstructure:"echo"`
}
func NewConfig() (*Config, *echoserver.EchoConfig, error) {
env := os.Getenv("APP_ENV")
if env == "" {
env = "development"
}
cfg := &Config{}
viper.SetConfigName(fmt.Sprintf("config.%s", env))
viper.AddConfigPath("./config/")
viper.SetConfigType("json")
if err := viper.ReadInConfig(); err != nil {
return nil, nil, errors.Wrap(err, "viper.ReadInConfig")
}
if err := viper.Unmarshal(cfg); err != nil {
return nil, nil, errors.Wrap(err, "viper.Unmarshal")
}
return cfg, cfg.Echo, nil
}
Содержимое config.development.json
{
"serviceName": "book_service",
"deliveryType": "http",
"context": {
"timeout": 20
},
"echo": {
"port": ":5000",
"development": true,
"timeout": 30,
"basePath": "/api/v1",
"host": "http://localhost",
"debugHeaders": true,
"httpClientDebug": true,
"debugErrorsResponse": true,
"ignoreLogUrls": [
"metrics"
]
}
}
![как будет выглядеть по структуре как будет выглядеть по структуре](https://habrastorage.org/getpro/habr/upload_files/ec8/9fd/fb0/ec89fdfb045128fb2abe49f557ec2ad5.png)
Теперь возвращаемся в main.go, чтобы подключить в DI нашу конфигурацию:
package main
import (
"go-template-microservice-v2/config"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
echoserver.NewEchoServer,
),
),
).Run()
}
Настройка сервера
Теперь для реализации первой части нашего микросервиса, необходимо сконфигурировать общий файл сервера, в котором будут запускаться echo_server и в будущем воркер, который будет отправлять новые книги со склада, через kafka.
![Первая часть нашей реализации Первая часть нашей реализации](https://habrastorage.org/getpro/habr/upload_files/9d0/4e6/cb3/9d04e6cb399a60fdf23c4340c4a0eddd.png)
По-этому идем и в корневой папке создаем каталог server
с файлом server.go
package server
import (
"context"
"github.com/labstack/echo/v4"
"github.com/pkg/errors"
"go-template-microservice-v2/config"
echoserver "go-template-microservice-v2/pkg/http/server"
"go.uber.org/fx"
"log"
"net/http"
)
// RunServers - запустить все сервера
func RunServers(lc fx.Lifecycle, ctx context.Context, e *echo.Echo, cfg *config.Config) error {
lc.Append(fx.Hook{
OnStart: func(_ context.Context) error {
log.Println("Starting server")
// Запустить HTTP - сервер
go func() {
if err := echoserver.RunHttpServer(ctx, e, cfg.Echo); !errors.Is(err, http.ErrServerClosed) {
log.Fatalf("error running http server: %v", err)
}
}()
e.GET("/", func(c echo.Context) error {
return c.String(http.StatusOK, cfg.ServiceName)
})
return nil
},
OnStop: func(_ context.Context) error {
log.Println("all servers shutdown gracefully...")
return nil
},
})
return nil
}
![как выглядит каталог как выглядит каталог](https://habrastorage.org/getpro/habr/upload_files/da3/5a5/727/da35a5727fd18560b5981dc0d182d685.png)
Также на будущее устанавливаем пакет "github.com/go-playground/validator"
go get "github.com/go-playground/validator"
И возвращаемся в main.go для подключения нашего сервера.
package main
import (
"github.com/go-playground/validator"
"go-template-microservice-v2/config"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go-template-microservice-v2/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
echoserver.NewEchoServer,
validator.New,
),
fx.Invoke(server.RunServers),
),
).Run()
}
Запускаем и проверяем.
![](https://habrastorage.org/getpro/habr/upload_files/0f7/1dd/c79/0f71ddc793432ef62871554bcad55844.png)
Наш сервер запустился, теперь мы можешь начать реализацию нашей схемы, но для начала мы подключим базу данных.
Подключение и конфигурация базы данных
Для начала подключить библиотеку для работы с гуидами и также скачиваем ORM gorm и дополнительные драйвера для подключения postgresql.
go get "github.com/satori/go.uuid"
go get "github.com/cenkalti/backoff/v4"
go get "github.com/uptrace/bun/driver/pgdriver"
go get "gorm.io/driver/postgres"
go get "gorm.io/gorm"
Отправляемся в каталог pkg
в которой создаем папку gorm_pg
, так-как совместно с ORM мы будет использовать базу данных postgresql, а в этом каталоге мы создаем файл pg_gorm.go
Сам файл с настройками подключение и накатыванием миграций будет выглядеть следующим образом.
package gormpg
import (
"database/sql"
"fmt"
"github.com/cenkalti/backoff/v4"
"github.com/pkg/errors"
"github.com/uptrace/bun/driver/pgdriver"
gorm_postgres "gorm.io/driver/postgres"
"gorm.io/gorm"
"time"
)
// PgConfig - конфигурация для соединения с Postgresql
type PgConfig struct {
Host string `mapstructure:"host"`
Port int `mapstructure:"port"`
User string `mapstructure:"user"`
DBName string `mapstructure:"dbName"`
SSLMode bool `mapstructure:"sslMode"`
Password string `mapstructure:"password"`
}
// PgGorm - модель базы данных
type PgGorm struct {
DB *gorm.DB
Config *PgConfig
}
func NewPgGorm(config *PgConfig) (*PgGorm, error) {
err := createDatabaseIfNotExists(config)
if err != nil {
panic(err)
return nil, err
}
connectionString := getConnectionString(config, config.DBName)
bo := backoff.NewExponentialBackOff()
bo.MaxElapsedTime = 10 * time.Second
maxRetries := 5
var gormDb *gorm.DB
err = backoff.Retry(func() error {
gormDb, err = gorm.Open(gorm_postgres.Open(connectionString), &gorm.Config{})
if err != nil {
return errors.Errorf("failed to connect postgres: %v and connection information: %s", err, connectionString)
}
return nil
}, backoff.WithMaxRetries(bo, uint64(maxRetries-1)))
return &PgGorm{DB: gormDb, Config: config}, err
}
func Migrate(gorm *gorm.DB, types ...interface{}) error {
for _, t := range types {
err := gorm.AutoMigrate(t)
if err != nil {
return err
}
}
return nil
}
func createDatabaseIfNotExists(config *PgConfig) error {
connectionString := fmt.Sprintf("postgres://%s:%s@%s:%d/%s?sslmode=disable",
config.User,
config.Password,
config.Host,
config.Port,
"postgres",
)
pgSqlDb := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(connectionString)))
var exists int
selectDbQueryString := fmt.Sprintf("SELECT 1 FROM pg_catalog.pg_database WHERE datname='%s'", config.DBName)
rows, err := pgSqlDb.Query(selectDbQueryString)
if err != nil {
return err
}
if rows.Next() {
err = rows.Scan(&exists)
if err != nil {
return err
}
}
if exists == 1 {
return nil
}
createDbQueryString := fmt.Sprintf("CREATE DATABASE %s", config.DBName)
_, err = pgSqlDb.Exec(createDbQueryString)
if err != nil {
return err
}
defer func(pgSqlDb *sql.DB) {
err := pgSqlDb.Close()
if err != nil {
panic(err)
}
}(pgSqlDb)
return nil
}
func getConnectionString(config *PgConfig, dbName string) string {
return fmt.Sprintf("host=%s port=%d user=%s dbname=%s password=%s",
config.Host,
config.Port,
config.User,
dbName,
config.Password,
)
}
![Как будет выглядеть в структуре Как будет выглядеть в структуре](https://habrastorage.org/getpro/habr/upload_files/723/75e/006/72375e0065bc1466fce78b1ad83d9e14.png)
Теперь поправим наши конфигурационные файлы с учетом добавленного.
package config
import (
"fmt"
"github.com/pkg/errors"
"github.com/spf13/viper"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
echoserver "go-template-microservice-v2/pkg/http/server"
"os"
)
type Config struct {
ServiceName string `mapstructure:"serviceName"`
Echo *echoserver.EchoConfig `mapstructure:"echo"`
PgConfig *gormpg.PgConfig `mapstructure:"pgConfig"`
}
func NewConfig() (*Config, *echoserver.EchoConfig, *gormpg.PgConfig, error) {
env := os.Getenv("APP_ENV")
if env == "" {
env = "development"
}
cfg := &Config{}
viper.SetConfigName(fmt.Sprintf("config.%s", env))
viper.AddConfigPath("./config/")
viper.SetConfigType("json")
if err := viper.ReadInConfig(); err != nil {
return nil, nil, nil, errors.Wrap(err, "viper.ReadInConfig")
}
if err := viper.Unmarshal(cfg); err != nil {
return nil, nil, nil, errors.Wrap(err, "viper.Unmarshal")
}
return cfg, cfg.Echo, cfg.PgConfig, nil
}
{
"serviceName": "book_service",
"deliveryType": "http",
"context": {
"timeout": 20
},
"echo": {
"port": ":5000",
"development": true,
"timeout": 30,
"basePath": "/api/v1",
"host": "http://localhost",
"debugHeaders": true,
"httpClientDebug": true,
"debugErrorsResponse": true,
"ignoreLogUrls": [
"metrics"
]
},
"PgConfig": {
"Host": "localhost",
"Port": 5432,
"User": "tgbotchecker",
"DbName": "tgbotchecker",
"SSLMode": false,
"Password": "tgbotchecker"
}
}
Далее подключаем зависимости в main.go
package main
import (
"github.com/go-playground/validator"
"go-template-microservice-v2/config"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go-template-microservice-v2/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
gormpg.NewPgGorm,
echoserver.NewEchoServer,
validator.New,
),
fx.Invoke(server.RunServers),
),
).Run()
}
Для поднятие нашей базы данных в докере в корневом каталоге создадим папку deployments
в которой создадим docker-compose.yml
, который мы сможем вызывать использовав команду в консоли из каталога с файлом docker-compose up.
version: "3.9"
services:
postgres:
image: postgres
environment:
POSTGRES_DB: "tgbotchecker"
POSTGRES_USER: "tgbotchecker"
POSTGRES_PASSWORD: "tgbotchecker"
ports:
- "5432:5432"
volumes:
- ./data:/var/lib/postgresql/data
Создадим сущности БД и репозитории
Отправляемся в корневой каталог и создадим папку internal
в которой создадим каталог data
и в нем создадим каталог entities
и в нем создадим файл book_entity.go
package entities
import (
uuid "github.com/satori/go.uuid"
)
// BookEntity model
type BookEntity struct {
Id uuid.UUID `json:"id" gorm:"primaryKey"`
Name string `json:"name"`
Author string `json:"author"`
Price float64 `json:"price"`
Enabled bool `json:"enabled"`
}
// CreateBookEntity создать модель
func CreateBookEntity(name string, author string, price float64) BookEntity {
return BookEntity{
Name: name,
Author: author,
Price: price,
Id: uuid.NewV4(),
Enabled: true,
}
}
![](https://habrastorage.org/getpro/habr/upload_files/9c8/fbd/8f1/9c8fbd8f1e8258f6ce8a7dabbc18c673.png)
Теперь для создании миграций в файле main.go необходимо зарегистрировать нашу сущность.
package main
import (
"github.com/go-playground/validator"
"go-template-microservice-v2/config"
"go-template-microservice-v2/internal/data/entities"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go-template-microservice-v2/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
gormpg.NewPgGorm,
echoserver.NewEchoServer,
validator.New,
),
fx.Invoke(server.RunServers),
fx.Invoke(
func(sql *gormpg.PgGorm) error {
return gormpg.Migrate(sql.DB, &entities.BookEntity{})
}),
),
).Run()
}
Теперь в папке data
создадим 2 каталога contracts
и repositories
. В каталоге contracts
будет интерфейс абстракция для нашего репозитория book_repository.go
, а в каталоге repository
будет лежать непосредственно реализация для postgresql pg_book_repository.go
package contracts
import (
uuid "github.com/satori/go.uuid"
"go-template-microservice-v2/internal/data/entities"
)
type IBookRepository interface {
AddBook(bookEntity entities.BookEntity) error
GetBook(id uuid.UUID) (*entities.BookEntity, error)
GetAllBook() ([]*entities.BookEntity, error)
UpdateBook(bookEntity entities.BookEntity) error
}
package repositories
import (
"fmt"
"github.com/pkg/errors"
uuid "github.com/satori/go.uuid"
"go-template-microservice-v2/internal/data/contracts"
"go-template-microservice-v2/internal/data/entities"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
)
type PgBookRepository struct {
PgGorm *gormpg.PgGorm
}
func NewPgBookRepository(pgGorm *gormpg.PgGorm) contracts.IBookRepository {
return &PgBookRepository{PgGorm: pgGorm}
}
func (p PgBookRepository) AddBook(bookEntity entities.BookEntity) error {
err := p.PgGorm.DB.Create(bookEntity).Error
if err != nil {
return errors.Wrap(err, "error in the inserting book into the database.")
}
return nil
}
func (p PgBookRepository) GetBook(id uuid.UUID) (*entities.BookEntity, error) {
var book entities.BookEntity
if err := p.PgGorm.DB.First(&book, id).Error; err != nil {
return nil, errors.Wrap(err, fmt.Sprintf("can't find the book with id %s into the database.", id))
}
return &book, nil
}
func (p PgBookRepository) GetAllBook() ([]*entities.BookEntity, error) {
var books []*entities.BookEntity
if err := p.PgGorm.DB.Find(&books).Error; err != nil {
return nil, errors.Wrap(err, fmt.Sprintf("can't find the books into the database."))
}
return books, nil
}
func (p PgBookRepository) UpdateBook(bookEntity entities.BookEntity) error {
err := p.PgGorm.DB.Save(bookEntity).Error
if err != nil {
return errors.Wrap(err, "error in the inserting book into the database.")
}
return nil
}
![структура структура](https://habrastorage.org/getpro/habr/upload_files/e76/60e/84a/e7660e84a43376752afa3f8aa9f97e42.png)
Теперь зарегистрируем в DI наш репозиторий в main.go
package main
import (
"github.com/go-playground/validator"
"go-template-microservice-v2/config"
"go-template-microservice-v2/internal/data/entities"
"go-template-microservice-v2/internal/data/repositories"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go-template-microservice-v2/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
gormpg.NewPgGorm,
repositories.NewPgBookRepository,
echoserver.NewEchoServer,
validator.New,
),
fx.Invoke(server.RunServers),
fx.Invoke(
func(sql *gormpg.PgGorm) error {
return gormpg.Migrate(sql.DB, &entities.BookEntity{})
}),
),
).Run()
}
Реализация команд медиатора
Мы уже почти вплотную подошли к реализации контроллера, остался лишь последний шаг — описать команды, которые будут играть роль сервисов в нашем приложении.
go get "github.com/mehdihadeli/go-mediatr"
Команды в нашем приложении также будут выполнять роль контрактов для запросов и ответов.
Для нашей реализации понадобятся следующие команды: добавление новой книги, покупка книги, а также запрос на получение списка всех книг.
Поэтому идем в каталог internal
и создаем каталог features
, в котором создаем 3 каталога add_book
, buy_book
, get_all_books
.
![](https://habrastorage.org/getpro/habr/upload_files/568/562/199/568562199839c0166e7aefea4ef1f8ef.png)
Для начала будем работать с каталогом add_book
. В котором мы создадим каталог commands
в котором создадим файлы: add_book_command.go
, add_book_handler.go
, add_book_response.go
.
package commands
// AddBookCommand - модель добавления книги в каталог
type AddBookCommand struct {
Name string `json:"name" validate:"required"`
Author string `json:"author" validate:"required"`
Price float64 `json:"price" validate:"required"`
}
package commands
import (
"context"
"go-template-microservice-v2/internal/data/contracts"
"go-template-microservice-v2/internal/data/entities"
)
// AddBookHandler - хендлер для команды AddUserRequestCommand
type AddBookHandler struct {
Repository contracts.IBookRepository
Ctx context.Context
}
// NewAddBookHandler - DI
func NewAddBookHandler(
repository contracts.IBookRepository,
ctx context.Context) *AddBookHandler {
return &AddBookHandler{Repository: repository, Ctx: ctx}
}
// Handle - выполнить
func (handler *AddBookHandler) Handle(ctx context.Context, command *AddBookCommand) (*AddBookResponse, error) {
bookEntity := entities.CreateBookEntity(
command.Name,
command.Author,
command.Price)
err := handler.Repository.AddBook(bookEntity)
if err != nil {
return nil, err
}
return &AddBookResponse{BookId: bookEntity.Id}, nil
}
package commands
import uuid "github.com/satori/go.uuid"
type AddBookResponse struct {
BookId uuid.UUID `json:"book_id"`
}
Теперь создадим аналог нашего контроллера в каталоге add_book
сделаем каталог endpoints
в котором создадим файл add_book_endpoints
package endpoints
import (
"context"
"github.com/go-playground/validator"
"github.com/labstack/echo/v4"
"github.com/labstack/gommon/log"
"github.com/mehdihadeli/go-mediatr"
"github.com/pkg/errors"
"go-template-microservice-v2/internal/features/add_book/commands"
"net/http"
)
// MapRoute - настройка маршрутизации
func MapRoute(validator *validator.Validate, echo *echo.Echo, ctx context.Context) {
group := echo.Group("/api/v1/books")
group.POST("", addBook(validator, ctx))
}
// AddBook
// @Tags Book
// @Summary Add Book
// @Description Add new Book in catalogue
// @Accept json
// @Produce json
// @Param AddBookCommand body commands.AddBookCommand true "Book data"
// @Success 200 {object} commands.AddBookResponse
// @Security -
// @Router /api/v1/books [post]
func addBook(validator *validator.Validate, ctx context.Context) echo.HandlerFunc {
return func(c echo.Context) error {
request := &commands.AddBookCommand{}
if err := c.Bind(request); err != nil {
badRequestErr := errors.Wrap(err, "[addBookEndpoint_handler.Bind] error in the binding request")
log.Error(badRequestErr)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
if err := validator.StructCtx(ctx, request); err != nil {
validationErr := errors.Wrap(err, "[addBook_handler.StructCtx] command validation failed")
log.Error(validationErr)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
result, err := mediatr.Send[*commands.AddBookCommand, *commands.AddBookResponse](ctx, request)
if err != nil {
log.Errorf("(Handle) id: {%s}, err: {%v}", request.Name, err)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
log.Infof("(auto added) id: {%s}", result.BookId)
return c.JSON(http.StatusCreated, result)
}
}
![](https://habrastorage.org/getpro/habr/upload_files/1f4/343/592/1f4343592ef1a2b7b1969091021d7143.png)
Переходим к следующему каталогу get_all_books
и создаем в нем каталог queries
в котором создаем get_all_books_query
, get_all_books_handler
, get_all_books_response
package queries
type GetAllBooksQuery struct{}
package queries
import (
"context"
"go-template-microservice-v2/internal/data/contracts"
)
type GetAllBooksHandler struct {
Repository contracts.IBookRepository
Ctx context.Context
}
// NewGetAllBooksHandler - DI
func NewGetAllBooksHandler(
repository contracts.IBookRepository,
ctx context.Context) *GetAllBooksHandler {
return &GetAllBooksHandler{Repository: repository, Ctx: ctx}
}
// Handle - выполнить
func (handler *GetAllBooksHandler) Handle(ctx context.Context, command *GetAllBooksQuery) (*GetAllBooksResponse, error) {
getAllBooksResponse := &GetAllBooksResponse{
Books: make([]GetAllBooksResponseItem, 0),
}
result, err := handler.Repository.GetAllBook()
if err != nil {
return nil, err
}
for _, element := range result {
getAllBooksResponse.Books = append(getAllBooksResponse.Books, GetAllBooksResponseItem{
Id: element.Id,
Name: element.Name,
Author: element.Author,
Price: element.Price,
Enabled: element.Enabled,
})
}
return getAllBooksResponse, nil
}
package queries
import uuid "github.com/satori/go.uuid"
type GetAllBooksResponse struct {
Books []GetAllBooksResponseItem `json:"books,omitempty"`
}
type GetAllBooksResponseItem struct {
Id uuid.UUID `json:"id"`
Name string `json:"name"`
Author string `json:"author"`
Price float64 `json:"price"`
Enabled bool `json:"enabled"`
}
И теперь по аналогии создадим каталог endpoints
с файлом get_all_books_endpoints.go
package endpoints
import (
"context"
"github.com/go-playground/validator"
"github.com/labstack/echo/v4"
"github.com/labstack/gommon/log"
"github.com/mehdihadeli/go-mediatr"
"go-template-microservice-v2/internal/features/get_all_books/queries"
"net/http"
)
// MapRoute - настройка маршрутизации
func MapRoute(validator *validator.Validate, echo *echo.Echo, ctx context.Context) {
group := echo.Group("/api/v1/books")
group.GET("", getAllBooks(validator, ctx))
}
// AddBook
// @Tags Book
// @Summary Get All Books
// @Description Get All Books from catalogue
// @Accept json
// @Produce json
// @Param GetAllBooksQuery body queries.GetAllBooksQuery true "Book data"
// @Success 200 {object} queries.GetAllBooksResponse
// @Security -
// @Router /api/v1/books [get]
func getAllBooks(validator *validator.Validate, ctx context.Context) echo.HandlerFunc {
return func(c echo.Context) error {
query := queries.GetAllBooksQuery{}
result, err := mediatr.Send[*queries.GetAllBooksQuery, *queries.GetAllBooksResponse](ctx, &query)
if err != nil {
log.Errorf("(Handle) err: {%v}", err)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
return c.JSON(http.StatusCreated, result)
}
}
![](https://habrastorage.org/getpro/habr/upload_files/44c/737/ae8/44c737ae858d0c6477fd20b9f537470a.png)
Осталось реализовать последнюю команду и можно будет приступать к регистрации медиаторов.
Переходим к следующему каталогу buy_book
и создаем в нем каталог commands
в котором создаем buy_book_commands
, buy_book_handler
, buy_book_response.
package commands
import uuid "github.com/satori/go.uuid"
// BuyBookCommand - модель добавления книги в каталог
type BuyBookCommand struct {
BookId uuid.UUID `json:"BookId" validate:"required"`
}
package commands
import (
"context"
"go-template-microservice-v2/internal/data/contracts"
)
// BuyBookHandler - хендлер для команды AddUserRequestCommand
type BuyBookHandler struct {
Repository contracts.IBookRepository
Ctx context.Context
}
// NewBuyBookHandler - DI
func NewBuyBookHandler(
repository contracts.IBookRepository,
ctx context.Context) *BuyBookHandler {
return &BuyBookHandler{Repository: repository, Ctx: ctx}
}
// Handle - выполнить
func (handler *BuyBookHandler) Handle(ctx context.Context, command *BuyBookCommand) (*BuyBookResponse, error) {
book, err := handler.Repository.GetBook(command.BookId)
if err != nil {
return nil, err
}
book.Enabled = false
err = handler.Repository.UpdateBook(*book)
if err != nil {
return nil, err
}
return &BuyBookResponse{Result: book.Enabled}, nil
}
package commands
type BuyBookResponse struct {
Result bool `json:"result"`
}
package endpoints
import (
"context"
"github.com/go-playground/validator"
"github.com/labstack/echo/v4"
"github.com/labstack/gommon/log"
"github.com/mehdihadeli/go-mediatr"
"github.com/pkg/errors"
"go-template-microservice-v2/internal/features/buy_book/commands"
"net/http"
)
// MapRoute - настройка маршрутизации
func MapRoute(validator *validator.Validate, echo *echo.Echo, ctx context.Context) {
group := echo.Group("/api/v1/books/buy")
group.POST("", buyBook(validator, ctx))
}
// AddBook
// @Tags Book
// @Summary Buy Book
// @Description Buy Book in catalogue
// @Accept json
// @Produce json
// @Param BuyBookCommand body commands.BuyBookCommand true "Book data"
// @Success 200 {object} commands.BuyBookResponse
// @Security -
// @Router /api/v1/books/buy [post]
func buyBook(validator *validator.Validate, ctx context.Context) echo.HandlerFunc {
return func(c echo.Context) error {
request := &commands.BuyBookCommand{}
if err := c.Bind(request); err != nil {
badRequestErr := errors.Wrap(err, "[addBookEndpoint_handler.Bind] error in the binding request")
log.Error(badRequestErr)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
if err := validator.StructCtx(ctx, request); err != nil {
validationErr := errors.Wrap(err, "[addBook_handler.StructCtx] command validation failed")
log.Error(validationErr)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
result, err := mediatr.Send[*commands.BuyBookCommand, *commands.BuyBookResponse](ctx, request)
if err != nil {
log.Errorf("(Handle) err: {%v}", err)
return echo.NewHTTPError(http.StatusBadRequest, err)
}
log.Infof("(auto added) id: {%s}", result.Result)
return c.JSON(http.StatusCreated, result)
}
}
![](https://habrastorage.org/getpro/habr/upload_files/370/5d4/7af/3705d47af23837ac568b682ed951d89b.png)
Регистрация роутов и команд медиатора.
Для регистрации маршрутизации и команд медиатор необходимо в каталоге internal
создать каталог configurations
в котором создать 2 файла endpoints_configurations
и mediator_configurations
.
package configurations
import (
"context"
"github.com/go-playground/validator"
"github.com/labstack/echo/v4"
addBookEndpoints "go-template-microservice-v2/internal/features/add_book/endpoints"
buyBookEndpoints "go-template-microservice-v2/internal/features/buy_book/endpoints"
getAllBooksEndpoints "go-template-microservice-v2/internal/features/get_all_books/endpoints"
)
// ConfigEndpoints - конфигурирование ендпоинтов нашего API
func ConfigEndpoints(validator *validator.Validate, echo *echo.Echo, ctx context.Context) {
addBookEndpoints.MapRoute(validator, echo, ctx)
buyBookEndpoints.MapRoute(validator, echo, ctx)
getAllBooksEndpoints.MapRoute(validator, echo, ctx)
}
package configurations
import (
"context"
"github.com/mehdihadeli/go-mediatr"
"go-template-microservice-v2/internal/data/contracts"
addBookCommand "go-template-microservice-v2/internal/features/add_book/commands"
buyBookCommand "go-template-microservice-v2/internal/features/buy_book/commands"
getAllBooksQueries "go-template-microservice-v2/internal/features/get_all_books/queries"
)
// ConfigMediator - DI
func ConfigMediator(
ctx context.Context,
repository contracts.IBookRepository) (err error) {
err = mediatr.RegisterRequestHandler[
*addBookCommand.AddBookCommand,
*addBookCommand.AddBookResponse](addBookCommand.NewAddBookHandler(repository, ctx))
err = mediatr.RegisterRequestHandler[
*buyBookCommand.BuyBookCommand,
*buyBookCommand.BuyBookResponse](buyBookCommand.NewBuyBookHandler(repository, ctx))
err = mediatr.RegisterRequestHandler[
*getAllBooksQueries.GetAllBooksQuery,
*getAllBooksQueries.GetAllBooksResponse](getAllBooksQueries.NewGetAllBooksHandler(repository, ctx))
if err != nil {
return err
}
return nil
}
![](https://habrastorage.org/getpro/habr/upload_files/087/ed6/b09/087ed6b099be5c55c7a5d3d3b99d1656.png)
Теперь осталось все это зарегистрировать в DI в файле main.go
package main
import (
"github.com/go-playground/validator"
"go-template-microservice-v2/config"
"go-template-microservice-v2/internal/configurations"
"go-template-microservice-v2/internal/data/entities"
"go-template-microservice-v2/internal/data/repositories"
gormpg "go-template-microservice-v2/pkg/gorm_pg"
"go-template-microservice-v2/pkg/http"
echoserver "go-template-microservice-v2/pkg/http/server"
"go-template-microservice-v2/server"
"go.uber.org/fx"
)
func main() {
fx.New(
fx.Options(
fx.Provide(
config.NewConfig,
http.NewContext,
gormpg.NewPgGorm,
repositories.NewPgBookRepository,
echoserver.NewEchoServer,
validator.New,
),
fx.Invoke(configurations.ConfigEndpoints),
fx.Invoke(configurations.ConfigMediator),
fx.Invoke(server.RunServers),
fx.Invoke(
func(sql *gormpg.PgGorm) error {
return gormpg.Migrate(sql.DB, &entities.BookEntity{})
}),
),
).Run()
}
Проверяем, что у нас все запустилось
![](https://habrastorage.org/getpro/habr/upload_files/ae6/480/cbd/ae6480cbdd4e402fdf9b560b799d373c.png)
Проверяем в БД, что табличка по миграции создалась
![](https://habrastorage.org/getpro/habr/upload_files/86e/f9e/4fe/86ef9e4fe9a415f3f661e6c58b939c04.png)
Проверяем запрос
![](https://habrastorage.org/getpro/habr/upload_files/094/ab2/ea5/094ab2ea5f0493e576fdad44aad22408.png)
Проверяем валидацию price
![](https://habrastorage.org/getpro/habr/upload_files/c99/166/609/c991666098ea80b6562019a9f932f8a0.png)
Проверяем добавилась ли книга
![](https://habrastorage.org/getpro/habr/upload_files/d53/89e/234/d5389e234972cae0da58b7b404c8e381.png)
Отлично у нас есть работающий микросервис!
Заключение
В данной статье я решил поделиться и познакомить со структурой проекта микросервиса, где у нас присутствовала валидация входных запросов, контракты заменены на команды и запросы медиатора, была подключена база данных, настроен DI и конфигурация, также настроены эндпоинты, как аналоги контроллеров.
Спасибо за внимание! В следующей статье я планирую подключить kafka и уже начать писать компонентные тесты на данный функционал, а также подключить swagger.
Ссылка на репозиторий: https://github.com/ItWithMisha/go-template-microservice-v2