359 lines
13 KiB
Go
359 lines
13 KiB
Go
package main
|
|
|
|
// Это пример инициализации через Uber Fx — runtime DI-контейнер.
|
|
// Fx делает всё в рантайме: через рефлексию анализирует сигнатуры конструкторов
|
|
// и автоматически собирает граф зависимостей.
|
|
//
|
|
// Плюсы:
|
|
// - Не нужна кодогенерация
|
|
// - Lifecycle хуки из коробки
|
|
//
|
|
// Минусы:
|
|
// - Рефлексия: ошибки только в рантайме, а не при компиляции
|
|
// - fx.Annotate + fx.As для каждого интерфейса — бойлерплейта не меньше, чем wire.Bind
|
|
// - Один конкретный тип → несколько интерфейсов? Нужны обёртки-адаптеры (fx.Out)
|
|
// - Свой логгер (zap), свой lifecycle — навязывает архитектуру
|
|
// - Магия: непонятно что происходит, пока не запустишь
|
|
//
|
|
// =====================================================
|
|
// ПОЧЕМУ ЗДЕСЬ СТОЛЬКО БОЙЛЕРПЛЕЙТА?
|
|
// =====================================================
|
|
//
|
|
// В этом проекте мы определяем интерфейсы по месту использования —
|
|
// Go-идиоматичный подход (Interface Segregation Principle):
|
|
//
|
|
// // service/auth.go — свой интерфейс
|
|
// type AuthUserRepository interface { ... }
|
|
//
|
|
// // service/user.go — свой интерфейс
|
|
// type UserRepository interface { ... }
|
|
//
|
|
// Один repository.UserRepo реализует оба. Fx не умеет это разрулить
|
|
// без fx.Out/fx.In структур и named-тегов — отсюда 300+ строк.
|
|
//
|
|
// Если у вас другой подход — общие интерфейсы в одном пакете:
|
|
//
|
|
// // shared/interfaces.go
|
|
// type UserRepository interface { ... } // один на всех потребителей
|
|
//
|
|
// То Fx ложится ГОРАЗДО проще: один тип → один интерфейс → нет проблемы.
|
|
// Просто fx.Provide(repository.NewUserRepo) — и готово.
|
|
//
|
|
// Это не плохой подход, просто другой. Java/Spring так и работают.
|
|
// Fx по сути портированный Dagger/Spring — он заточен под shared interfaces.
|
|
// Если у вас на проекте именно такая архитектура — Fx будет комфортным.
|
|
// =====================================================
|
|
|
|
import (
|
|
"log/slog"
|
|
"net/http"
|
|
|
|
"go.uber.org/fx"
|
|
|
|
"github.com/olezhek28/di-demo/internal/api"
|
|
"github.com/olezhek28/di-demo/internal/cache"
|
|
"github.com/olezhek28/di-demo/internal/config"
|
|
"github.com/olezhek28/di-demo/internal/database"
|
|
"github.com/olezhek28/di-demo/internal/events"
|
|
"github.com/olezhek28/di-demo/internal/repository"
|
|
"github.com/olezhek28/di-demo/internal/service"
|
|
)
|
|
|
|
func main() {
|
|
fx.New(
|
|
// Конфиг
|
|
fx.Provide(config.AppConfig),
|
|
|
|
// === Инфраструктура ===
|
|
// Здесь начинается самое «весёлое».
|
|
//
|
|
// database.DB реализует 3 интерфейса:
|
|
// - repository.UserDB
|
|
// - repository.SessionDB
|
|
// - repository.NotificationDB
|
|
//
|
|
// cache.Cache реализует 2 интерфейса:
|
|
// - repository.SessionCache
|
|
// - service.AuthCache
|
|
//
|
|
// events.EventBus реализует 3 интерфейса:
|
|
// - service.AuthEventPublisher
|
|
// - service.UserEventPublisher
|
|
// - service.NotificationEventSubscriber
|
|
//
|
|
// В Fx нельзя просто написать fx.As(new(A), new(B), new(C)).
|
|
// Если один провайдер возвращает конкретный тип, а его нужно
|
|
// подать как РАЗНЫЕ интерфейсы в разные потребители — нужно
|
|
// писать специальные структуры-адаптеры с fx.Out.
|
|
//
|
|
// Либо — провайдить конкретный тип + отдельные provide-обёртки
|
|
// для каждого интерфейса. Оба варианта — бойлерплейт.
|
|
//
|
|
// Мы используем fx.Out структуры — каноничный подход Fx.
|
|
|
|
fx.Provide(provideDB), // → dbOut{UserDB, SessionDB, NotificationDB}
|
|
fx.Provide(provideCache), // → cacheOut{SessionCache, AuthCache}
|
|
fx.Provide(provideEvents), // → eventsOut{AuthPub, UserPub, NotifSub}
|
|
|
|
// === Репозитории ===
|
|
// Та же история: repository.UserRepo реализует 2 интерфейса (service.AuthUserRepository
|
|
// и service.UserRepository), поэтому нужна fx.Out обёртка.
|
|
fx.Provide(provideUserRepo), // → userRepoOut{AuthUserRepo, UserRepo}
|
|
fx.Provide(provideSessionRepo), // → fx.As(service.AuthSessionRepository)
|
|
fx.Provide(provideNotificationRepo), // → fx.As(service.NotificationRepository)
|
|
|
|
// === Сервисы ===
|
|
// И здесь то же самое.
|
|
fx.Provide(provideAuthService), // → authServiceOut{UserAuth, APIAuth}
|
|
fx.Provide(provideUserService), // → userServiceOut{NotifUser, APIUser}
|
|
fx.Provide(provideNotificationService), // → api.NotificationService
|
|
|
|
// Handler — тоже нужна обёртка, потому что зависимости named.
|
|
fx.Provide(provideHandler),
|
|
|
|
// HTTP-сервер — через fx.Invoke.
|
|
fx.Invoke(startHTTPServer),
|
|
|
|
// Итого: чтобы «автоматически» собрать граф из 12 зависимостей,
|
|
// мы написали 7 fx.Out структур + 7 fx.In структур + 11 provide-обёрток.
|
|
// Файл ~300 строк для того же результата что 40 строк в DI-контейнере.
|
|
//
|
|
// А ТЕПЕРЬ ГЛАВНОЕ — как Fx работает внутри?
|
|
//
|
|
// При вызове fx.New() он:
|
|
// 1. Собирает все провайдеры
|
|
// 2. Через рефлексию анализирует сигнатуры (кто что принимает, кто что возвращает)
|
|
// 3. Строит граф зависимостей
|
|
// 4. Делает топологическую сортировку
|
|
// 5. Вызывает ВСЕ конструкторы разом, в правильном порядке
|
|
//
|
|
// То есть инициализация — EAGER, не ленивая.
|
|
// Всё создаётся при старте, как в антипаттерне и в Wire.
|
|
// Просто порядок вычисляется автоматически через рефлексию.
|
|
//
|
|
// Что это значит на практике:
|
|
// - Ошибки — только в рантайме (забыл провайдер → паника при старте)
|
|
// - Циклическая зависимость → Fx упадёт при старте (тот же тупик)
|
|
// - Ленивой инициализации нет — всё создаётся сразу
|
|
//
|
|
// Fx решает ту же задачу что Wire — «не вычисляй порядок руками».
|
|
// Но наш DI-контейнер не имеет порядка вообще — каждый геттер
|
|
// рекурсивно подтягивает зависимости при первом вызове.
|
|
// Нечему ломаться, нечего сортировать.
|
|
).Run()
|
|
}
|
|
|
|
// =====================================================
|
|
// Обёртки-адаптеры для Fx (fx.Out)
|
|
// =====================================================
|
|
// Каждая структура с fx.Out нужна потому что один конкретный тип
|
|
// реализует несколько интерфейсов для разных потребителей.
|
|
// Без этих структур Fx не знает как разрулить зависимости.
|
|
|
|
// --- database.DB → 3 интерфейса ---
|
|
|
|
type dbOut struct {
|
|
fx.Out
|
|
|
|
UserDB repository.UserDB `name:"userDB"`
|
|
SessionDB repository.SessionDB `name:"sessionDB"`
|
|
NotificationDB repository.NotificationDB `name:"notificationDB"`
|
|
}
|
|
|
|
func provideDB(cfg *config.Config) (dbOut, error) {
|
|
db, err := database.New(cfg.DSN)
|
|
if err != nil {
|
|
return dbOut{}, err
|
|
}
|
|
return dbOut{
|
|
UserDB: db,
|
|
SessionDB: db,
|
|
NotificationDB: db,
|
|
}, nil
|
|
}
|
|
|
|
// --- cache.Cache → 2 интерфейса ---
|
|
|
|
type cacheOut struct {
|
|
fx.Out
|
|
|
|
SessionCache repository.SessionCache `name:"sessionCache"`
|
|
AuthCache service.AuthCache `name:"authCache"`
|
|
}
|
|
|
|
func provideCache(cfg *config.Config) cacheOut {
|
|
c := cache.New(cfg.RedisAddr)
|
|
return cacheOut{
|
|
SessionCache: c,
|
|
AuthCache: c,
|
|
}
|
|
}
|
|
|
|
// --- events.EventBus → 3 интерфейса ---
|
|
|
|
type eventsOut struct {
|
|
fx.Out
|
|
|
|
AuthPublisher service.AuthEventPublisher `name:"authPublisher"`
|
|
UserPublisher service.UserEventPublisher `name:"userPublisher"`
|
|
NotifSub service.NotificationEventSubscriber `name:"notifSubscriber"`
|
|
}
|
|
|
|
func provideEvents() eventsOut {
|
|
bus := events.NewEventBus()
|
|
return eventsOut{
|
|
AuthPublisher: bus,
|
|
UserPublisher: bus,
|
|
NotifSub: bus,
|
|
}
|
|
}
|
|
|
|
// --- repository.UserRepo → 2 интерфейса ---
|
|
|
|
type userRepoOut struct {
|
|
fx.Out
|
|
|
|
AuthUserRepo service.AuthUserRepository `name:"authUserRepo"`
|
|
UserRepo service.UserRepository `name:"userRepo"`
|
|
}
|
|
|
|
type userRepoIn struct {
|
|
fx.In
|
|
|
|
DB repository.UserDB `name:"userDB"`
|
|
}
|
|
|
|
func provideUserRepo(in userRepoIn) userRepoOut {
|
|
repo := repository.NewUserRepo(in.DB)
|
|
return userRepoOut{
|
|
AuthUserRepo: repo,
|
|
UserRepo: repo,
|
|
}
|
|
}
|
|
|
|
// --- repository.SessionRepo → 1 интерфейс ---
|
|
|
|
type sessionRepoIn struct {
|
|
fx.In
|
|
|
|
DB repository.SessionDB `name:"sessionDB"`
|
|
Cache repository.SessionCache `name:"sessionCache"`
|
|
}
|
|
|
|
func provideSessionRepo(in sessionRepoIn) service.AuthSessionRepository {
|
|
return repository.NewSessionRepo(in.DB, in.Cache)
|
|
}
|
|
|
|
// --- repository.NotificationRepo → 1 интерфейс ---
|
|
|
|
type notificationRepoIn struct {
|
|
fx.In
|
|
|
|
DB repository.NotificationDB `name:"notificationDB"`
|
|
}
|
|
|
|
type notificationRepoOut struct {
|
|
fx.Out
|
|
|
|
Repo service.NotificationRepository `name:"notifRepo"`
|
|
}
|
|
|
|
func provideNotificationRepo(in notificationRepoIn) notificationRepoOut {
|
|
return notificationRepoOut{
|
|
Repo: repository.NewNotificationRepo(in.DB),
|
|
}
|
|
}
|
|
|
|
// --- service.AuthService → 2 интерфейса ---
|
|
|
|
type authServiceOut struct {
|
|
fx.Out
|
|
|
|
UserAuthService service.UserAuthService `name:"userAuthService"`
|
|
APIAuthService api.AuthService `name:"apiAuthService"`
|
|
}
|
|
|
|
type authServiceIn struct {
|
|
fx.In
|
|
|
|
UserRepo service.AuthUserRepository `name:"authUserRepo"`
|
|
SessionRepo service.AuthSessionRepository
|
|
Cache service.AuthCache `name:"authCache"`
|
|
Events service.AuthEventPublisher `name:"authPublisher"`
|
|
}
|
|
|
|
func provideAuthService(in authServiceIn) authServiceOut {
|
|
svc := service.NewAuthService(in.UserRepo, in.SessionRepo, in.Cache, in.Events)
|
|
return authServiceOut{
|
|
UserAuthService: svc,
|
|
APIAuthService: svc,
|
|
}
|
|
}
|
|
|
|
// --- service.UserService → 2 интерфейса ---
|
|
|
|
type userServiceOut struct {
|
|
fx.Out
|
|
|
|
NotifUserService service.NotificationUserService `name:"notifUserService"`
|
|
APIUserService api.UserService `name:"apiUserService"`
|
|
}
|
|
|
|
type userServiceIn struct {
|
|
fx.In
|
|
|
|
UserRepo service.UserRepository `name:"userRepo"`
|
|
AuthService service.UserAuthService `name:"userAuthService"`
|
|
Events service.UserEventPublisher `name:"userPublisher"`
|
|
}
|
|
|
|
func provideUserService(in userServiceIn) userServiceOut {
|
|
svc := service.NewUserService(in.UserRepo, in.AuthService, in.Events)
|
|
return userServiceOut{
|
|
NotifUserService: svc,
|
|
APIUserService: svc,
|
|
}
|
|
}
|
|
|
|
// --- service.NotificationService (fx.Annotate выше, но нужен fx.In для named deps) ---
|
|
|
|
type notificationServiceIn struct {
|
|
fx.In
|
|
|
|
Repo service.NotificationRepository `name:"notifRepo"`
|
|
UserSvc service.NotificationUserService `name:"notifUserService"`
|
|
Events service.NotificationEventSubscriber `name:"notifSubscriber"`
|
|
}
|
|
|
|
// Заменяем fx.Annotate на отдельный provide — иначе не прокинуть named зависимости.
|
|
func provideNotificationService(in notificationServiceIn) api.NotificationService {
|
|
return service.NewNotificationService(in.Repo, in.UserSvc, in.Events)
|
|
}
|
|
|
|
// --- api.Handler (fx.In для named deps) ---
|
|
|
|
type handlerIn struct {
|
|
fx.In
|
|
|
|
UserService api.UserService `name:"apiUserService"`
|
|
AuthService api.AuthService `name:"apiAuthService"`
|
|
NotificationService api.NotificationService
|
|
}
|
|
|
|
func provideHandler(in handlerIn) api.Handler {
|
|
return api.NewHandler(in.UserService, in.AuthService, in.NotificationService)
|
|
}
|
|
|
|
func startHTTPServer(handler api.Handler) {
|
|
srv := &http.Server{
|
|
Addr: config.AppConfig().HTTPAddr,
|
|
Handler: handler.Routes(),
|
|
}
|
|
|
|
slog.Info("сервер запущен", "addr", config.AppConfig().HTTPAddr)
|
|
|
|
if err := srv.ListenAndServe(); err != nil {
|
|
slog.Error("ошибка сервера", "err", err)
|
|
}
|
|
}
|