Шаблон Go-микросервиса для начинающих от .NET разработчика. Часть 2

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

Содержание

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

Теперь переходим от описания того, что мы хотим реализовать, к тому, как будет выглядеть наш микросервис.

Начнем с того, как будет взаимодействовать клиент с нашим книжным магазином. Для взаимодействия мы выбираем 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 здесь не принимаются.

Тесты, которые я приготовил для данного проекта, являются компонентными. Это своего рода аналог 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 } 

Как это будет выглядеть:

Добавления конфигурации приложения

Далее для конфигурирования нашего сервиса необходимо подгружать основные настройки из конфигурационных файлов в формате 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"     ]   } }

Теперь возвращаемся в 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.

По-этому идем и в корневой папке создаем каталог 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 } 

Также на будущее устанавливаем пакет «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() } 

Запускаем и проверяем.

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

Подключение и конфигурация базы данных

Для начала подключить библиотеку для работы с гуидами и также скачиваем 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, ) } 

Теперь поправим наши конфигурационные файлы с учетом добавленного.

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, } } 

Теперь для создании миграций в файле 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 } 

Теперь зарегистрируем в 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 .

Для начала будем работать с каталогом 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) } } 

Переходим к следующему каталогу 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) } } 

Осталось реализовать последнюю команду и можно будет приступать к регистрации медиаторов.

Переходим к следующему каталогу 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) } } 

Регистрация роутов и команд медиатора.

Для регистрации маршрутизации и команд медиатор необходимо в каталоге 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 }  

Теперь осталось все это зарегистрировать в 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() } 

Проверяем, что у нас все запустилось

Проверяем в БД, что табличка по миграции создалась

Проверяем запрос

Проверяем валидацию price

Проверяем добавилась ли книга

Отлично у нас есть работающий микросервис!

Заключение

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

Спасибо за внимание! В следующей статье я планирую подключить kafka и уже начать писать компонентные тесты на данный функционал, а также подключить swagger.

Ссылка на репозиторий: https://github.com/ItWithMisha/go-template-microservice-v2