Go言語のクリーンアーキテクチャの基本概念と実装例！初心者でもわかる設計パターン完全ガイド

Go言語のクリーンアーキテクチャの基本概念と実装例

先生と生徒の会話形式で理解しよう

生徒

「Go言語でアプリを作っているんですが、コードがどんどん複雑になって困っています。クリーンアーキテクチャっていうのを聞いたんですが、難しそうで...」

先生

「クリーンアーキテクチャは、コードを整理して保守しやすくするための設計パターンです。最初は難しく感じるかもしれませんが、基本を理解すれば実はシンプルなんですよ。」

生徒

「どういう仕組みなんですか？普通の書き方と何が違うんですか？」

先生

「それでは、クリーンアーキテクチャの基本概念から、実際のGo言語での実装方法まで、詳しく見ていきましょう！」

1. クリーンアーキテクチャとは何か？

クリーンアーキテクチャとは、アメリカのソフトウェア工学者であるロバート・マーチン（通称アンクル・ボブ）が提唱した、ソフトウェア設計の手法です。この設計パターンの最大の特徴は、プログラムを複数の層に分けて、それぞれの層の役割を明確にすることです。

例えるなら、会社組織のようなものです。会社には営業部、開発部、総務部などがあり、それぞれが異なる役割を持っています。同じように、プログラムも役割ごとに層を分けて整理するのがクリーンアーキテクチャの考え方です。

クリーンアーキテクチャでは、プログラムを主に4つの層に分けます。外側から順に、フレームワーク層、インターフェース層、ユースケース層、エンティティ層です。最も重要なルールは、依存関係が内側に向かうということです。外側の層は内側の層を知っていますが、内側の層は外側の層を知りません。

このルールにより、データベースやWebフレームワークなどの技術的な詳細を変更しても、ビジネスロジックには影響を与えないようになります。つまり、システムの中心部分を守りながら、周辺の技術は自由に変更できるのです。

2. クリーンアーキテクチャの4つの層

クリーンアーキテクチャを構成する4つの層について、それぞれの役割を詳しく見ていきましょう。

エンティティ層（最も内側）

ビジネスルールの中核を担う層です。例えば、ユーザー情報やブログ記事など、アプリケーションの本質的なデータ構造を定義します。この層は他のどの層にも依存せず、最も変更が少ない安定した部分です。

ユースケース層

アプリケーション固有のビジネスロジックを記述する層です。例えば、ユーザー登録処理や記事投稿処理など、実際の機能を実装します。この層はエンティティ層のみに依存します。

インターフェース層

外部とのやり取りを担当する層です。HTTPハンドラー、データベースアクセス、外部APIとの通信などを実装します。この層は、ユースケース層とエンティティ層に依存します。

フレームワーク層（最も外側）

具体的なフレームワークやツールの詳細を扱う層です。Webフレームワーク、データベースドライバー、ログ出力など、技術的な実装の詳細がここに含まれます。

3. エンティティ層の実装例

それでは、実際のGo言語のコードで各層を実装してみましょう。まずは最も内側のエンティティ層からです。ここではブログシステムを例に、記事を表すエンティティを定義します。


package entity

import "time"

type Article struct {
    ID        int
    Title     string
    Content   string
    AuthorID  int
    CreatedAt time.Time
    UpdatedAt time.Time
}

func NewArticle(title, content string, authorID int) *Article {
    now := time.Now()
    return &Article{
        Title:     title,
        Content:   content,
        AuthorID:  authorID,
        CreatedAt: now,
        UpdatedAt: now,
    }
}

func (a *Article) IsValid() bool {
    return a.Title != "" && a.Content != "" && a.AuthorID > 0
}

このコードでは、Article構造体で記事の基本的なデータ構造を定義しています。NewArticle関数は新しい記事を作成するコンストラクタで、IsValidメソッドは記事が有効かどうかを検証します。エンティティ層は他のどの層にも依存していないため、非常にシンプルで理解しやすいコードになっています。

4. ユースケース層の実装例

次に、ユースケース層を実装します。ユースケース層では、実際のビジネスロジックを記述します。ここでは記事を作成するユースケースを実装してみましょう。


package usecase

import "myapp/entity"

type ArticleRepository interface {
    Save(article *entity.Article) error
    FindByID(id int) (*entity.Article, error)
}

type CreateArticleUseCase struct {
    repo ArticleRepository
}

func NewCreateArticleUseCase(repo ArticleRepository) *CreateArticleUseCase {
    return &CreateArticleUseCase{repo: repo}
}

func (uc *CreateArticleUseCase) Execute(title, content string, authorID int) error {
    article := entity.NewArticle(title, content, authorID)
    
    if !article.IsValid() {
        return errors.New("無効な記事データです")
    }
    
    return uc.repo.Save(article)
}

このコードでは、ArticleRepositoryというインターフェースを定義しています。インターフェースとは、実装の詳細を隠して、必要な機能だけを定義したものです。ユースケース層は、このインターフェースを通じてデータの保存を行います。具体的にどのようにデータベースに保存するかは、この層では気にしません。

これがクリーンアーキテクチャの重要なポイントです。ユースケース層は、データの保存方法という技術的な詳細に依存せず、インターフェースという抽象的な契約にのみ依存します。これにより、後からデータベースをMySQLからPostgreSQLに変更しても、ユースケース層のコードは変更する必要がありません。

5. インターフェース層の実装例

次に、インターフェース層を実装します。ここでは、実際にデータベースとやり取りする部分を作成します。先ほど定義したArticleRepositoryインターフェースを実装します。


package repository

import (
    "database/sql"
    "myapp/entity"
)

type MySQLArticleRepository struct {
    db *sql.DB
}

func NewMySQLArticleRepository(db *sql.DB) *MySQLArticleRepository {
    return &MySQLArticleRepository{db: db}
}

func (r *MySQLArticleRepository) Save(article *entity.Article) error {
    query := `INSERT INTO articles (title, content, author_id, created_at, updated_at) 
              VALUES (?, ?, ?, ?, ?)`
    
    _, err := r.db.Exec(query, 
        article.Title, 
        article.Content, 
        article.AuthorID,
        article.CreatedAt,
        article.UpdatedAt,
    )
    
    return err
}

func (r *MySQLArticleRepository) FindByID(id int) (*entity.Article, error) {
    query := `SELECT id, title, content, author_id, created_at, updated_at 
              FROM articles WHERE id = ?`
    
    article := &entity.Article{}
    err := r.db.QueryRow(query, id).Scan(
        &article.ID,
        &article.Title,
        &article.Content,
        &article.AuthorID,
        &article.CreatedAt,
        &article.UpdatedAt,
    )
    
    return article, err
}

このコードは、ArticleRepositoryインターフェースの具体的な実装です。MySQLデータベースを使っていますが、重要なのは、この実装を別のものに変更しても、ユースケース層には影響を与えないということです。例えば、PostgreSQLやMongoDBに変更したい場合は、この部分だけを書き換えれば済みます。

6. 依存性の注入とは？

クリーンアーキテクチャを実現する上で重要な概念が、依存性の注入（Dependency Injection）です。これは、オブジェクトが必要とする依存物を、外部から渡す手法です。

先ほどのユースケースのコードを見てください。CreateArticleUseCaseは、ArticleRepositoryというインターフェースを受け取っています。これが依存性の注入です。具体的なデータベースの実装（MySQLやPostgreSQLなど）は、外部から渡されるため、ユースケース層は具体的な実装を知る必要がありません。

依存性の注入を使うことで、テストが非常に簡単になります。実際のデータベースを使わずに、テスト用の偽物（モック）を渡すことで、ユースケースのロジックだけを独立してテストできます。


package main

import (
    "database/sql"
    "myapp/repository"
    "myapp/usecase"
)

func main() {
    db, _ := sql.Open("mysql", "user:password@/dbname")
    
    articleRepo := repository.NewMySQLArticleRepository(db)
    createArticleUC := usecase.NewCreateArticleUseCase(articleRepo)
    
    err := createArticleUC.Execute("Go言語入門", "Go言語の基礎を学ぼう", 1)
    if err != nil {
        panic(err)
    }
}

このコードでは、main関数で各層のオブジェクトを組み立てています。最初にリポジトリを作成し、それをユースケースに渡しています。このように、外部から依存物を注入することで、各層が疎結合になり、変更に強いシステムが構築できます。

7. クリーンアーキテクチャのメリット

クリーンアーキテクチャを採用することで、どのようなメリットがあるのでしょうか。実際の開発で感じられる利点を見ていきましょう。

テストがしやすい

各層が独立しているため、それぞれの層を個別にテストできます。特に、ビジネスロジックをデータベースやWebフレームワークと切り離してテストできるのは大きな利点です。

技術の変更が容易

データベースをMySQLからPostgreSQLに変更したり、WebフレームワークをGinからEchoに変更したりしても、ビジネスロジックには影響がありません。インターフェース層だけを変更すれば対応できます。

保守性が高い

責任範囲が明確に分かれているため、どこに何のコードがあるかが分かりやすくなります。バグの修正や新機能の追加が効率的に行えます。

ビジネスロジックに集中できる

技術的な詳細とビジネスロジックが分離されているため、それぞれに集中して開発できます。ビジネスルールの変更時には、ユースケース層とエンティティ層だけを修正すればよいのです。

8. クリーンアーキテクチャの注意点

クリーンアーキテクチャは多くのメリットがありますが、いくつか注意すべき点もあります。特に初心者の方は、以下の点に気をつけましょう。

小規模プロジェクトには過剰

数百行程度の小さなプログラムに、クリーンアーキテクチャを適用するのは過剰です。コード量が増え、かえって複雑になってしまいます。ある程度の規模があるプロジェクトで採用しましょう。

学習コストがかかる

クリーンアーキテクチャの概念を理解し、適切に実装できるようになるには、ある程度の経験が必要です。最初は時間がかかりますが、慣れれば自然に書けるようになります。

完璧を目指さない

最初から完璧なクリーンアーキテクチャを実装しようとしないでください。まずはシンプルに始めて、必要に応じて改善していく姿勢が大切です。

9. Go言語でのディレクトリ構成例

クリーンアーキテクチャをGo言語で実装する場合、以下のようなディレクトリ構成が推奨されます。


myapp/
├── cmd/
│   └── server/
│       └── main.go
├── internal/
│   ├── entity/
│   │   └── article.go
│   ├── usecase/
│   │   └── create_article.go
│   ├── repository/
│   │   └── article_repository.go
│   └── handler/
│       └── article_handler.go
├── pkg/
│   └── database/
│       └── connection.go
└── go.mod

このディレクトリ構成では、entityディレクトリにエンティティ層、usecaseディレクトリにユースケース層、repositoryディレクトリとhandlerディレクトリにインターフェース層を配置しています。cmdディレクトリには、アプリケーションのエントリーポイントであるmain.goを配置します。

各層を別々のディレクトリに分けることで、依存関係が視覚的にも分かりやすくなります。また、internalディレクトリを使うことで、外部のプロジェクトから誤って使用されることを防げます。

Go言語を基礎からスッキリ学びたい人や、文法だけでなく「実用的な使い方」まで押さえたい人には、定番の入門書がこちらです。

基礎からわかるGo言語をAmazonで見る

※ Amazon広告リンク

10. 実践で学ぶクリーンアーキテクチャ

クリーンアーキテクチャは、理論だけでなく実践を通じて学ぶことが重要です。最初は既存のオープンソースプロジェクトを参考にしながら、小さな機能から実装してみましょう。

例えば、簡単なTODOアプリから始めるのがおすすめです。TODOの作成、取得、更新、削除という基本的な機能を、クリーンアーキテクチャで実装してみます。エンティティ層にTODO構造体を定義し、ユースケース層に各操作のロジックを実装し、リポジトリ層でデータベースとやり取りします。

最初は層が多くて複雑に感じるかもしれませんが、実際に書いてみると、各層の役割が明確で理解しやすいことに気づくでしょう。また、テストを書くときや、機能を追加するときに、クリーンアーキテクチャの利点を実感できます。

Go言語のシンプルな思想とクリーンアーキテクチャの明確な設計原則は、非常に相性が良いです。インターフェースを活用した疎結合な設計により、保守性と拡張性の高いアプリケーションを構築できます。最初は大変かもしれませんが、一度慣れてしまえば、クリーンアーキテクチャなしでは開発できないほど便利な設計手法です。