Go에서 의존성 주입: 패턴 및 최고의 실천 방법

// 저장소를 위한 인터페이스 정의
type UserRepository interface {
    FindByID(id int) (*User, error)
    Save(user *User) error
}

// 저장소 인터페이스에 의존하는 서비스
type UserService struct {
    repo UserRepository
}

// 의존성을 주입하는 생성자
func NewUserService(repo UserRepository) *UserService {
    return &UserService{repo: repo}
}

// 주입된 의존성을 사용하는 메서드
func (s *UserService) GetUser(id int) (*User, error) {
    return s.repo.FindByID(id)
}

type EmailService interface {
    Send(to, subject, body string) error
}

type Logger interface {
    Info(msg string)
    Error(msg string, err error)
}

type OrderService struct {
    repo        OrderRepository
    emailSvc    EmailService
    logger      Logger
    paymentSvc  PaymentService
}

func NewOrderService(
    repo OrderRepository,
    emailSvc EmailService,
    logger Logger,
    paymentSvc PaymentService,
) *OrderService {
    return &OrderService{
        repo:       repo,
        emailSvc:   emailSvc,
        logger:     logger,
        paymentSvc: paymentSvc,
    }
}

// 좋음: 작은, 집중된 인터페이스
type PaymentProcessor interface {
    ProcessPayment(amount float64) error
}

// 나쁨: 불필요한 메서드가 포함된 큰 인터페이스
type PaymentService interface {
    ProcessPayment(amount float64) error
    RefundPayment(id string) error
    GetPaymentHistory(userID int) ([]Payment, error)
    UpdatePaymentMethod(userID int, method PaymentMethod) error
    // ... 많은 다른 메서드
}

// 데이터베이스 인터페이스 - 고수준 추상화
type DB interface {
    Query(ctx context.Context, query string, args ...interface{}) (Rows, error)
    Exec(ctx context.Context, query string, args ...interface{}) (Result, error)
    BeginTx(ctx context.Context) (Tx, error)
}

// 추상화에 의존하는 저장소
type UserRepository struct {
    db DB
}

func NewUserRepository(db DB) *UserRepository {
    return &UserRepository{db: db}
}

func (r *UserRepository) FindByID(ctx context.Context, id int) (*User, error) {
    query := "SELECT id, name, email FROM users WHERE id = $1"
    rows, err := r.db.Query(ctx, query, id)
    if err != nil {
        return nil, err
    }
    defer rows.Close()
    
    // ... 행 파싱
}

func main() {
    // 인프라스트럭처 의존성 초기화
    db := initDatabase()
    logger := initLogger()
    
    // 저장소 초기화
    userRepo := NewUserRepository(db)
    orderRepo := NewOrderRepository(db)
    
    // 의존성을 가진 서비스 초기화
    emailSvc := NewEmailService(logger)
    paymentSvc := NewPaymentService(logger)
    userSvc := NewUserService(userRepo, logger)
    orderSvc := NewOrderService(orderRepo, emailSvc, logger, paymentSvc)
    
    // HTTP 핸들러 초기화
    userHandler := NewUserHandler(userSvc)
    orderHandler := NewOrderHandler(orderSvc)
    
    // 라우트 연결
    router := setupRouter(userHandler, orderHandler)
    
    // 서버 시작
    log.Fatal(http.ListenAndServe(":8080", router))
}

go install github.com/google/wire/cmd/wire@latest

// wire.go
//go:build wireinject
// +build wireinject

package main

import "github.com/google/wire"

func InitializeApp() (*App, error) {
    wire.Build(
        NewDB,
        NewUserRepository,
        NewUserService,
        NewUserHandler,
        NewApp,
    )
    return &App{}, nil
}

import "go.uber.org/dig"

func main() {
    container := dig.New()
    
    // 제공자 등록
    container.Provide(NewDB)
    container.Provide(NewUserRepository)
    container.Provide(NewUserService)
    container.Provide(NewUserHandler)
    
    // 의존성이 필요한 함수 호출
    err := container.Invoke(func(handler *UserHandler) {
        // 핸들러 사용
    })
    if err != nil {
        log.Fatal(err)
    }
}

// 테스트를 위한 모크 구현
type mockUserRepository struct {
    users map[int]*User
    err   error
}

func (m *mockUserRepository) FindByID(id int) (*User, error) {
    if m.err != nil {
        return nil, m.err
    }
    return m.users[id], nil
}

func (m *mockUserRepository) Save(user *User) error {
    if m.err != nil {
        return m.err
    }
    m.users[user.ID] = user
    return nil
}

// 모크 사용 테스트
func TestUserService_GetUser(t *testing.T) {
    mockRepo := &mockUserRepository{
        users: map[int]*User{
            1: {ID: 1, Name: "John", Email: "john@example.com"},
        },
    }
    
    service := NewUserService(mockRepo)
    
    user, err := service.GetUser(1)
    assert.NoError(t, err)
    assert.Equal(t, "John", user.Name)
}

// 좋음: 클라이언트는 사용자 조회만 필요함
type UserReader interface {
    FindByID(id int) (*User, error)
    FindByEmail(email string) (*User, error)
}

// 별도의 인터페이스로 작성
type UserWriter interface {
    Save(user *User) error
    Delete(id int) error
}

func NewUserService(repo UserRepository) (*UserService, error) {
    if repo == nil {
        return nil, errors.New("사용자 저장소는 nil일 수 없습니다")
    }
    return &UserService{repo: repo}, nil
}

type ctxKey string

const dbKey ctxKey = "db"

func WithDB(ctx context.Context, db DB) context.Context {
    return context.WithValue(ctx, dbKey, db)
}

func DBFromContext(ctx context.Context) (DB, bool) {
    db, ok := ctx.Value(dbKey).(DB)
    return db, ok
}

// 좋음: 내부 캐시는 주입 필요 없음
type UserService struct {
    repo UserRepository
    // 내부 캐시 - 주입 필요 없음
    cache map[int]*User
}

func NewUserService(repo UserRepository) *UserService {
    return &UserService{
        repo:  repo,
        cache: make(map[int]*User),
    }
}

// UserService는 사용자 관련 비즈니스 로직을 처리합니다.
// 데이터 액세스를 위해 UserRepository가 필요하며, Logger를 사용하여
// 오류 추적을 수행합니다. 병렬 처리 환경에서 사용될 경우
// UserRepository는 스레드 안전해야 합니다.
func NewUserService(repo UserRepository, logger Logger) *UserService {
    // ...
}

// 간단한 구조체 - DI 필요 없음
type Point struct {
    X, Y float64
}

func NewPoint(x, y float64) Point {
    return Point{X: x, Y: y}
}

// 간단한 유틸리티 - DI 필요 없음
func FormatCurrency(amount float64) string {
    return fmt.Sprintf("$%.2f", amount)
}

type PDFGenerator interface {
    GenerateReport(data ReportData) ([]byte, error)
}

type ReportService struct {
    pdfGen PDFGenerator
    repo   ReportRepository
}

func NewReportService(pdfGen PDFGenerator, repo ReportRepository) *ReportService {
    return &ReportService{
        pdfGen: pdfGen,
        repo:   repo,
    }
}