Goとレイヤードアーキテクチャの相性を徹底解説｜言語特性・実装例・選定基準

// domain/repository.go — ドメイン層でinterfaceを定義
type UserRepository interface {
    FindByID(ctx context.Context, id string) (*User, error)
    Save(ctx context.Context, user *User) error
}

// infrastructure/user_repository.go — インフラ層で実装
type userRepositoryImpl struct {
    db *sql.DB
}

func (r *userRepositoryImpl) FindByID(ctx context.Context, id string) (*domain.User, error) {
    // DBアクセスの実装
    row := r.db.QueryRowContext(ctx, "SELECT id, name, email FROM users WHERE id = $1", id)
    u := &domain.User{}
    if err := row.Scan(&u.ID, &u.Name, &u.Email); err != nil {
        return nil, fmt.Errorf("find user by id: %w", err)
    }
    return u, nil
}

func (r *userRepositoryImpl) Save(ctx context.Context, user *domain.User) error {
    _, err := r.db.ExecContext(ctx,
        "INSERT INTO users (id, name, email) VALUES ($1, $2, $3) ON CONFLICT (id) DO UPDATE SET name = $2, email = $3",
        user.ID, user.Name, user.Email,
    )
    if err != nil {
        return fmt.Errorf("save user: %w", err)
    }
    return nil
}

// usecase/user_usecase.go
type UserUsecase struct {
    repo   domain.UserRepository
    mailer domain.Mailer
}

func NewUserUsecase(repo domain.UserRepository, mailer domain.Mailer) *UserUsecase {
    return &UserUsecase{
        repo:   repo,
        mailer: mailer,
    }
}

func (u *UserUsecase) Register(ctx context.Context, name, email string) (*domain.User, error) {
    user := domain.NewUser(name, email)
    if err := u.repo.Save(ctx, user); err != nil {
        return nil, fmt.Errorf("register user: %w", err)
    }
    if err := u.mailer.SendWelcome(ctx, user); err != nil {
        // メール送信失敗はログに記録して処理を続行
        slog.Error("failed to send welcome email", "userID", user.ID, "error", err)
    }
    return user, nil
}

myapp/
├── cmd/
│   └── api/
│       └── main.go          # エントリーポイント、DI配線
├── handler/
│   ├── user_handler.go      # HTTPハンドラ
│   └── middleware.go         # ミドルウェア
├── usecase/
│   └── user_usecase.go      # ユースケース
├── domain/
│   ├── user.go              # エンティティ
│   ├── user_repository.go   # リポジトリinterface
│   └── errors.go            # ドメインエラー定義
├── infrastructure/
│   ├── postgres/
│   │   └── user_repository.go  # PostgreSQL実装
│   └── smtp/
│       └── mailer.go           # メール送信実装
├── go.mod
└── go.sum

// cmd/api/main.go
func main() {
    db, err := sql.Open("postgres", os.Getenv("DATABASE_URL"))
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // インフラ層
    userRepo := postgres.NewUserRepository(db)
    mailer := smtp.NewMailer(os.Getenv("SMTP_HOST"))

    // ユースケース層
    userUsecase := usecase.NewUserUsecase(userRepo, mailer)

    // ハンドラ層
    userHandler := handler.NewUserHandler(userUsecase)

    // ルーティング（Go 1.22+の標準ServeMux）
    mux := http.NewServeMux()
    mux.HandleFunc("GET /users/{id}", userHandler.GetByID)
    mux.HandleFunc("POST /users", userHandler.Create)

    log.Println("server starting on :8080")
    log.Fatal(http.ListenAndServe(":8080", mux))
}

myapp/
├── main.go
├── handler.go
├── store.go    # DB操作
└── model.go    # データ構造

// usecase/user_usecase_test.go

type mockUserRepo struct {
    users map[string]*domain.User
}

func (m *mockUserRepo) FindByID(ctx context.Context, id string) (*domain.User, error) {
    user, ok := m.users[id]
    if !ok {
        return nil, domain.ErrUserNotFound
    }
    return user, nil
}

func (m *mockUserRepo) Save(ctx context.Context, user *domain.User) error {
    m.users[user.ID] = user
    return nil
}

type mockMailer struct {
    sent []string
}

func (m *mockMailer) SendWelcome(ctx context.Context, user *domain.User) error {
    m.sent = append(m.sent, user.Email)
    return nil
}

func TestUserUsecase_Register(t *testing.T) {
    repo := &mockUserRepo{users: make(map[string]*domain.User)}
    mailer := &mockMailer{}
    uc := NewUserUsecase(repo, mailer)

    user, err := uc.Register(context.Background(), "Alice", "alice@example.com")
    if err != nil {
        t.Fatalf("unexpected error: %v", err)
    }
    if user.Name != "Alice" {
        t.Errorf("got name %q, want %q", user.Name, "Alice")
    }

    // リポジトリに保存されたことを確認
    saved, err := repo.FindByID(context.Background(), user.ID)
    if err != nil {
        t.Fatalf("user not saved: %v", err)
    }
    if saved.Email != "alice@example.com" {
        t.Errorf("got email %q, want %q", saved.Email, "alice@example.com")
    }

    // ウェルカムメールが送信されたことを確認
    if len(mailer.sent) != 1 || mailer.sent[0] != "alice@example.com" {
        t.Errorf("welcome email not sent correctly: %v", mailer.sent)
    }
}

// domain/user.go
type User struct {
    ID        string
    Name      string
    Email     string
    Status    UserStatus
    CreatedAt time.Time
}

func NewUser(name, email string) (*User, error) {
    if name == "" {
        return nil, errors.New("name is required")
    }
    if !isValidEmail(email) {
        return nil, errors.New("invalid email format")
    }
    return &User{
        ID:        generateID(),
        Name:      name,
        Email:     email,
        Status:    UserStatusActive,
        CreatedAt: time.Now(),
    }, nil
}

func (u *User) Deactivate() error {
    if u.Status != UserStatusActive {
        return fmt.Errorf("cannot deactivate user with status %s", u.Status)
    }
    u.Status = UserStatusInactive
    return nil
}

// infrastructure/tx.go
type txKey struct{}

func RunInTx(ctx context.Context, db *sql.DB, fn func(ctx context.Context) error) error {
    tx, err := db.BeginTx(ctx, nil)
    if err != nil {
        return err
    }
    ctx = context.WithValue(ctx, txKey{}, tx)
    if err := fn(ctx); err != nil {
        tx.Rollback()
        return err
    }
    return tx.Commit()
}

// domain/transaction.go
type Transaction interface {
    RunInTx(ctx context.Context, fn func(ctx context.Context) error) error
}