ドキュメント価格ブログ
お問い合わせ
ログイン無料で新規登録
Back to Tech Articles

過度に大きなGin/Echoハンドラーを、より小さく保守性の高いサービスおよび関数に段階的にリファクタリングする

9月 04, 2025
# Misc

Olivia Novak

Dev Intern · Leapcell

この記事はEnglish、한국어、Deutschでも利用できます
Cover of "過度に大きなGin/Echoハンドラーを、より小さく保守性の高いサービスおよび関数に段階的にリファクタリングする"

はじめに

Web開発の急速な進歩の中で、GinやEchoのようなフレームワークはGoで高性能なAPIを構築するための基盤となっています。そのシンプルさとスピードは否定できません。しかし、アプリケーションが複雑化するにつれて、一般的なアンチパターンが出現します。それが「ファットハンドラー」です。これは、単一のHTTPハンドラー関数が、リクエストの解析や検証から、ビジネスロジックの実行、データベースの操作まで、すべてを担当する巨大な塊となる状態を指します。このようなハンドラーは、読みにくく、テストや保守、スケーリングが非常に困難であることが知られています。しばしば、スパゲッティコードのもつれた塊となり、開発を遅らせ、バグのリスクを高めます。この記事では、これらのモノリシックなハンドラーに伴う問題点を浮き彫りにするだけでなく、よりモジュール化され、テスト可能で、保守しやすいアーキテクチャへとリファクタリングするための構造化されたステップバイステップの方法論を提供します。小さな、焦点を絞ったサービスと関数を活用します。これらの複雑な関数をどのように優雅に解きほぐし、Goアプリケーションをより堅牢で進化しやすくするかを探ります。

コアコンセプトの理解

リファクタリングプロセスに飛び込む前に、議論する主要な用語とアーキテクチャパターンについて共通の理解を確立しましょう。

HTTPハンドラー

GinやEchoのようなWebフレームワークの文脈では、HTTPハンドラーは、着信HTTPリクエストを処理し、HTTPレスポンスを生成する関数です。Ginでは通常 func(c *gin.Context)、Echoでは func(c echo.Context) error です。これらのハンドラーは通常、特定APIエンドポイントのエントリーポイントに配置されます。

ビジネスロジック

これは、アプリケーションがデータをどのように処理、保存、変更するかを定義するコアなルールと操作を指します。これは、API経由で「どのように」公開されるか、またはデータベースに「どのように」保存されるかに関係なく、アプリケーションが「何を」行うかです。

サービスレイヤー

サービスレイヤー（「サービスオブジェクト」または「ユースケース」とも呼ばれる）は、HTTPハンドラーとデータアクセスレイヤー（例：リポジトリ）の間の中間役として機能します。関連するビジネスロジックをカプセル化し、異なるコンポーネント間の相互作用を調整し、特定操作の単一のエントリーポイントとして機能します。サービスは、ビジネスロジックをHTTPの懸念事項から分離し、再利用性を促進するために不可欠です。

レポジトリレイヤー

レポジトリレイヤーは、データ永続化の詳細を抽象化します。データソース（データベース、外部API、ファイルなど）との対話のためのインターフェースを提供し、アプリケーションの他の部分にデータが「どのように」取得、保存、更新されるかの詳細を知る必要がなくなります。この分離により、データソースを簡単に切り替えたり、ビジネスロジックを単独でテストしたりすることが容易になります。

依存性注入

依存性注入（DI）は、オブジェクト間のハードコードされた依存関係を削除できるソフトウェアデザインパターンです。オブジェクトが自身の依存関係を作成するのではなく、それらはオブジェクトに注入されます。しばしばコンストラクタパラメータを通じて行われます。これにより、疎結合が促進され、コンポーネントはより独立し、テスト可能で、再利用可能になります。

ファットハンドラーの問題点

有機的に成長したアプリケーションでの典型的な「ユーザー作成」ハンドラーを考えてみましょう。

// リファクタリング前: ファットハンドラー
package main

import (
	"log"
	"net/http"
	"strconv"

	"github.com/gin-gonic/gin"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type User struct {
	ID        uint   `json:"id" gorm:"primaryKey"`
	Name      string `json:"name"`
	Email     string `json:"email" gorm:"unique"`
	Password  string `json:"-"` // JSON出力からパスワードを除外
	IsActive  bool   `json:"isActive"`
	AdminData string `json:"-"` // 機密データ
}

var db *gorm.DB

func init() {
	var err error
	db, err = gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
	if err != nil {
		log.Fatalf("failed to connect database: %v", err)
	}

	// スキーマのマイグレーション
	db.AutoMigrate(&User{})
}

type CreateUserRequest struct {
	Name     string `json:"name" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
}

// CreateUserHandlerは新しいユーザーの作成を処理します
func CreateUserHandler(c *gin.Context) {
	var req CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// ユーザーが既に存在するかチェック
	var existingUser User
	if err := db.Where("email = ?", req.Email).First(&existingUser).Error; err == nil {
		c.JSON(http.StatusConflict, gin.H{"error": "User with this email already exists"})
		return
	} else if err != gorm.ErrRecordNotFound {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error checking existing user"})
		return
	}

	// パスワードのハッシュ化（例として簡略化）
	hashedPassword := "hashed_" + req.Password // 本番ではbcryptのような強力なハッシュライブラリを使用してください

	user := User{
		Name:     req.Name,
		Email:    req.Email,
		Password: hashedPassword,
		IsActive: true, // デフォルトでアクティブ
	}

	// データベースにユーザーを保存
	if err := db.Create(&user).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create user"})
		return
	}

	// 作成のログ記録（監査に関連するビジネスロジック）
	log.Printf("User created: %s (%s)", user.Name, user.Email)

	// ウェルカムメール送信（別のビジネスロジック）- シミュレート
	go func() {
		log.Printf("Sending welcome email to %s", user.Email)
		// 実際のメール送信ロジックはここに入る
	}()

	c.JSON(http.StatusCreated, user)
}

func main() {
	r := gin.Default()
	r.POST("/users", CreateUserHandler)
	r.Run(":8080")
}

この CreateUserHandler はいくつかの問題を抱えています。

  1. 単一責任の原則（SRP）違反: リクエストの解析、検証、重複メールチェック、パスワードハッシュ化、データベース操作、ログ記録、さらには「メール送信」まで担当しています。
  2. テスト容易性が低い: このハンドラーをテストするには、完全なGinコンテキストと、場合によっては実際のデータベース接続をセットアップする必要があり、単体テストが困難で遅くなります。
  3. 再利用性が低い: ビジネスロジック（例：既存ユーザーのチェック、パスワードハッシュ化）はHTTPコンテキストに緊密に結合されており、他の場所（例：CLIツールや別のAPIエンドポイント）で簡単に再利用できません。
  4. 保守性の悪夢: ビジネスロジック、データベーススキーマ、またはリクエスト構造の変更は、この単一の大きな関数を変更する必要があり、バグを導入するリスクを高めます。
  5. 関心の分離の欠如: HTTP固有の詳細がコアアプリケーションロジックと混在しています。

段階的なリファクタリングプロセス

CreateUserHandler をより構造化された設計にリファクタリングします。

ステップ1: リクエスト検証とバインディングの抽出

最初の手順は、HTTPリクエスト固有の処理を分離することです。ShouldBindJSON およびそれに続くエラー処理は、純粋にHTTP関連です。gin.Context は既にバインディングを提供していますが、ハンドラーの最初の数行を有効な入力の取得に専念させることで、ハンドラーを簡略化できます。このステップは、新しいサービスへの抽出というよりは、ハンドラーの意図をより明確にすることに重点を置いています。

// (以前のUser構造体、dbセットアップ、main関数は変更なし)

// CreateUserRequestは同じままです
type CreateUserRequest struct {
	Name     string `json:"name" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
}

// 検証を抽出したハンドラー
func CreateUserHandlerStep1(c *gin.Context) {
	var req CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// ... 残りのロジック
	// これで、`req`はバインディングタグに従って有効であることが保証されます。
	// ユーザー作成に関するハンドラーの残りの元のロジックがここに続きます。
	// 例として、元のロジックをコメントアウトし、プレースホルダーを呼び出すことができます：
	// handleUserCreationLogic(c, req)
}

このステップでは新しいファイルは導入されませんが、入力取得段階とコアロジックを精神的（かつ論理的）に分離します。

ステップ2: レポジトリレイヤーの導入

次に、すべてのデータベース関連操作を専用のUserRepositoryに抽出します。これにより、GORMの特定の実装をハンドラーから抽象化します。

// repository/user_repository.go
package repository

import (
	"errors"

	"gorm.io/gorm"
)

// UserはUserモデルを表します（共有またはここに定義可能）
type User struct {
	ID        uint   `json:"id" gorm:"primaryKey"`
	Name      string `json:"name"`
	Email     string `json:"email" gorm:"unique"`
	Password  string `json:"-"`
	IsActive  bool   `json:"isActive"`
	AdminData string `json:"-"`
}

//go:generate mockgen -source=user_repository.go -destination=mocks/mock_user_repository.go -package=mocks
type UserRepository interface {
	CreateUser(user *User) error
	FindByEmail(email string) (*User, error)
	// 他のユーザー関連操作を追加：GetByID, UpdateUser, DeleteUserなど
}

type userRepository struct {
	db *gorm.DB
}

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

func (r *userRepository) CreateUser(user *User) error {
	return r.db.Create(user).Error
}

func (r *userRepository) FindByEmail(email string) (*User, error) {
	var user User
	err := r.db.Where("email = ?", email).First(&user).Error
	if err != nil {
		return nil, err // gorm.ErrRecordNotFound は呼び出し元で処理
	}
	return &user, nil
}

これで、CreateUserHandler はこのリポジトリを使用できます。

// handler/user_handler.go (ハンドラー用の`handler`パッケージを想定)
package handler

import (
	"net/http"
	"log" // ログ用
	"your_module/repository" // インポートパスを調整
	"your_module/model" // User構造体が`model`パッケージにあると仮定

	"github.com/gin-gonic/gin"
	"gorm.io/gorm" // gorm.ErrRecordNotFound用
)

type CreateUserRequest struct {
	Name     string `json:"name" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
}

// ハンドラーは依存関係：UserRepositoryを必要とするようになりました
type UserHandler struct {
	userRepo repository.UserRepository
}

func NewUserHandler(userRepo repository.UserRepository) *UserHandler {
	return &UserHandler{userRepo: userRepo}
}

func (h *UserHandler) CreateUserHandlerStep2(c *gin.Context) {
	var req CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// リポジトリを使用して、ユーザーが既に存在するかチェック
	_, err := h.userRepo.FindByEmail(req.Email)
	if err == nil {
		c.JSON(http.StatusConflict, gin.H{"error": "User with this email already exists"})
		return
	} else if err != gorm.ErrRecordNotFound { // _他の_エラーをチェックすることが重要
		log.Printf("Error checking for existing user: %v", err) // 実際のエラーをログに記録
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Database error checking existing user"})
		return
	}

	// パスワードのハッシュ化（まだハンドラー内）
	hashedPassword := "hashed_" + req.Password

	newUser := &model.User{ // `model`パッケージを作成した場合はmodel.Userを使用
		Name:     req.Name,
		Email:    req.Email,
		Password: hashedPassword,
		IsActive: true,
	}

	// リポジトリを使用して、データベースにユーザーを保存
	if err := h.userRepo.CreateUser(newUser); err != nil {
		log.Printf("Error creating user: %v", err)
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create user"})
		return
	}

	log.Printf("User created: %s (%s)", newUser.Name, newUser.Email)
	go func() {
		log.Printf("Sending welcome email to %s", newUser.Email)
	}()

	c.JSON(http.StatusCreated, newUser)
}

// main.go で次のように初期化します：
/*
func main() {
	r := gin.Default()
	// ... db初期化 ...
	userRepo := repository.NewUserRepository(db)
	userHandler := handler.NewUserHandler(userRepo)
	r.POST("/users", userHandler.CreateUserHandlerStep2)
	r.Run(":8080")
}
*/

これで、CreateUserHandlerStep2 はデータベース固有の詳細についてあまり関与しなくなり、データベース操作のテスト容易性が向上します。

ステップ3: サービスレイヤーの実装

これが最も重要なステップです。重複チェック、パスワードハッシュ化、ユーザー作成のオーケストレーションといったすべてのビジネスロジックをUserServiceに抽出します。

// service/user_service.go
package service

import (
	"errors"
	"log" // サービス内のログ記録用
	"your_module/model" // User構造体が`model`パッケージにあると仮定
	"your_module/repository" // インポートパスを調整

	"gorm.io/gorm" // gormエラーのチェック用
)

// より良いエラー処理のためのカスタムエラー
var (
	ErrUserAlreadyExists = errors.New("user with this email already exists")
	ErrPasswordWeak      = errors.New("password is too weak")
)

type UserService interface {
	CreateUser(name, email, password string) (*model.User, error)
	// 他のサービスメソッドの追加：GetUser, UpdateUser, DeleteUser
}

type userService struct {
	userRepo repository.UserRepository
	// 他の依存関係（例：メールサービス、ロガーインターフェースなど）を追加
}

func NewUserService(userRepo repository.UserRepository) UserService {
	return &userService{userRepo: userRepo}
}

func (s *userService) CreateUser(name, email, password string) (*model.User, error) {
	// 1. 入力の検証（より洗練されたもの、例：メールの正規表現）
	if len(password) < 6 { // 例：パスワード強度に関するビジネスルール
		return nil, ErrPasswordWeak
	}

	// 2. 重複ユーザーのチェック
	_, err := s.userRepo.FindByEmail(email)
	if err == nil {
		return nil, ErrUserAlreadyExists
	}
	if err != gorm.ErrRecordNotFound {
		log.Printf("Error checking for existing user in service: %v", err)
		return nil, errors.New("internal server error") // データベースエラーをマスク
	}

	// 3. パスワードのハッシュ化（ビジネスロジック）
	hashedPassword := "hashed_" + password // 本番ではbcryptを使用

	// 4. ユーザーモデルの作成
	newUser := &model.User{
		Name:     name,
		Email:    email,
		Password: hashedPassword,
		IsActive: true,
	}

	// 5. ユーザーの永続化
	if err := s.userRepo.CreateUser(newUser); err != nil {
		log.Printf("Error persisting new user in service: %v", err)
		return nil, errors.New("failed to create user")
	}

	// 6. 作成後のアクション（例：ログ記録、イベント送信）
	log.Printf("User created by service: %s (%s)", newUser.Name, newUser.Email)
	// 本番アプリケーションでは、メール送信のような非同期操作のためにメッセージキューを使用する場合があります：
	go func() {
		log.Printf("Simulating sending welcome email to %s via service", newUser.Email)
		// emailService.SendWelcomeEmail(newUser.Email, newUser.Name)
	}()

	return newUser, nil
}

これで、ハンドラーは大幅にスリムになります。

// handler/user_handler.go (更新済み)
package handler

import (
	"errors"
	"net/http"
	"your_module/service" // インポートパスを調整

	"github.com/gin-gonic/gin"
)

type CreateUserRequest struct {
	Name     string `json:"name" binding:"required"`
	Email    string `json:"email" binding:"required,email"`
	Password string `json:"password" binding:"required,min=6"`
}

type UserHandler struct {
	userService service.UserService // 注入されたサービス依存関係
}

func NewUserHandler(userService service.UserService) *UserHandler {
	return &UserHandler{userService: userService}
}

func (h *UserHandler) CreateUserHandlerRefactored(c *gin.Context) {
	var req CreateUserRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// すべてのビジネスロジックをサービスレイヤーに委譲します
	user, err := h.userService.CreateUser(req.Name, req.Email, req.Password)
	if err != nil {
		if errors.Is(err, service.ErrUserAlreadyExists) {
			c.JSON(http.StatusConflict, gin.H{"error": err.Error()})
			return
		}
		if errors.Is(err, service.ErrPasswordWeak) {
			c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
			return
		}
		// その他の内部エラーを適切に処理します
		c.JSON(http.StatusInternalServerError, gin.H{"error": "Failed to create user"})
		return
	}

	// ハンドラーはHTTPリクエスト/レスポンスのみを扱います
	c.JSON(http.StatusCreated, user)
}

// main.go で：
/*
func main() {
	r := gin.Default()
	// ... データベース接続 ...
	userRepo := repository.NewUserRepository(db)
	userService := service.NewUserService(userRepo) // リポジトリをサービスに注入
	userHandler := handler.NewUserHandler(userService) // サービスをハンドラーに注入
	r.POST("/users", userHandler.CreateUserHandlerRefactored)
	r.Run(":8080")
}
*/

CreateUserHandlerRefactored は現在、驚くほどクリーンです。リクエストを受け取り、適切なサービスメソッドを呼び出し、サービスの（成功またはエラーの）結果をHTTPレスポンスに変換します。すべての複雑なビジネスロジック、データベース操作、および内部エラー処理は、サービスとリポジトリレイヤーに押し下げられています。

ステップ4: 補助的な（副作用）関数のリファクタリング

元のハンドラーの「ウェルカムメール送信」部分は副作用です。この例ではサービスレイヤーのシミュレーションで問題ありませんが、より大きなアプリケーションでは、これは別のEmailServiceであったり、イベント駆動型アーキテクチャで処理されたりする可能性があります。

// service/email_service.go （新規ファイル）
package service

import "log"

type EmailService interface {
	SendWelcomeEmail(toEmail, username string) error
	// その他のメール関連メソッド
}

type emailService struct {
	// 依存関係（例：メールクライアント、ロガー）
}

func NewEmailService() EmailService {
	return &emailService{}
}

func (s *emailService) SendWelcomeEmail(toEmail, username string) error {
	log.Printf("Successfully sent welcome email to %s for user %s", toEmail, username)
	// 本番では、サードパーティのメールAPIの呼び出しが含まれます
	return nil
}

これで、EmailService を UserService に注入します。

// service/user_service.go （更新済み）
package service

import (
	"errors"
	"log"
	"your_module/model"
	"your_module/repository"

	"gorm.io/gorm"
)

// (ErrUserAlreadyExists, ErrPasswordWeakはそのまま)

type UserService interface {
	CreateUser(name, email, password string) (*model.User, error)
}

type userService struct {
	userRepo      repository.UserRepository
	emailService EmailService // <--- 新しい依存関係
}

func NewUserService(userRepo repository.UserRepository, emailService EmailService) UserService {
	return &userService{userRepo: userRepo, emailService: emailService}
}

func (s *userService) CreateUser(name, email, password string) (*model.User, error) {
	// ... （前のステップのロジック） ...

	if err := s.userRepo.CreateUser(newUser); err != nil {
		log.Printf("Error persisting new user in service: %v", err)
		return nil, errors.New("failed to create user")
	}

	// メールサービスを使用します
	go func() { // 非同期で実行を継続
		if err := s.emailService.SendWelcomeEmail(newUser.Email, newUser.Name); err != nil {
			log.Printf("Failed to send welcome email to %s: %v", newUser.Email, err)
		}
	}()

	return newUser, nil
}

そして main.go で：

// main.go （更新済み）
package main

import (
	"log"
	"your_module/handler"
	"your_module/repository"
	"your_module/service" // すべてのパッケージがインポートされていることを確認

	"github.com/gin-gonic/gin"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

// User, db, init() (dbセットアップ用) は以前と同様

func main() {
	r := gin.Default()

	// 依存関係を初期化
	userRepo := repository.NewUserRepository(db)
	emailService := service.NewEmailService()
	userService := service.NewUserService(userRepo, emailService) // emailService を注入
	userHandler := handler.NewUserHandler(userService)

	// ルートを登録
	r.POST("/users", userHandler.CreateUserHandlerRefactored)

	log.Println("Server starting on :8080")
	if err := r.Run(":8080"); err != nil {
		log.Fatalf("Server failed to start: %v", err)
	}
}

リファクタリングされたアーキテクチャの利点

この構造化されたアプローチは、大きな利点をもたらします。

  • 可読性・理解度の向上: 各コンポーネントは明確で単一の責任を持ちます。ハンドラーは薄く、サービスはビジネスロジックを処理し、リポジトリはデータアクセスを管理します。
  • テスト容易性の向上:
    • ハンドラーは UserService インターフェースをモックすることで単体テストできます。
    • サービスは UserRepository (および EmailService) インターフェースをモックすることで単体テストできます。
    • リポジトリはインメモリデータベースに対してテストするか、gorm.DB を直接モックできます（ただし、実際のDBとの統合テストが好まれることが多いです）。これにより、包括的なテストを作成する労力が大幅に削減されます。
  • 保守性の向上: データベース技術の変更はリポジトリレイヤーのみに影響します。ビジネスルールの変更は主にサービスレイヤーに影響します。HTTP関連の変更はハンドラーに限定されます。
  • 再利用性の向上: UserService 内のビジネスロジックは、重複なしに、異なるハンドラー、CLIコマンド、またはバックグラウンドワーカーによって再利用できます。
  • スケーリングの容易化: 明確に定義されたサービスレイヤーは、マイクロサービスへの移行の足がかりとなり、個々のコンポーネントのスケーリングを容易にします。

結論

GinまたはEchoの「ファット」ハンドラーをリファクタリングすることは、単にコードを移動することではなく、構造、明瞭さ、保守性を導入することです。専用のリポジトリとサービスレイヤー、および適切な依存性注入に懸念を系統的に抽出することにより、もつれた塊を堅牢で、テスト可能で、スケーラブルなアプリケーションに変換します。このモジュール化されたアプローチにより、Goアプリケーションはアジャイルで適応性があり、要件が変化し複雑さが増しても、優雅に進化できる能力を維持できます。より小さく、焦点を絞った関数とサービスを採用して、より回復力があり、楽しい開発体験を構築しましょう。

Share this article

HackerNews

More Posts from Leapcell

cover

Goの静的アセット埋め込み vs. 従来の配信

cover

Goルーチンにおける一般的な落とし穴とアンチパターン

Popular Posts