【Go】DDD + レイヤードアーキテクチャでREST APIを実装する

Go + DDD + レイヤードアーキテクチャを本やネットで調べ、実際に動かしな…

mintaku-blog.net

先日上記記事でアウトプットした知識から、より理解を深めるため、ToDoリストをイメージしたシンプルなCRUDのREST APIをDDD + レイヤードアーキテクチャで実装してみました。

おさらい

レイヤードアーキテクチャの概念であるdomain層を確立させ、そこにドメインロジックを凝集させようという発想に、DDDのDIP(依存関係逆転の原則)を用いることで、上の図のような各レイヤごとの依存関係を意識した実装を行います。

実現したい機能を抽象化し、各レイヤごとの依存関係を意識しながら実装に落とし込んでいく作業が、従来のMVCで書いていた時よりも格段に頭を使うことを実感しています。

自分が実装している範囲内ではまだまだこのアーキテクチャを活かしきれていないですが、少しづつ理解を深めてものにしていきたいです。

domain層

Domain層は、システムが扱う業務領域に関するコードを置くところです。今回ToDoリストで必要なItemモデルを定義します。

今回はシンプルなToDoリストなのでこれだけですが、実際はここに実現したいシステムの業務領域を集約させて、全体の開発に展開させていきます。

・domain/model/item.go

package model

import (
  "time"

  _ "github.com/jinzhu/gorm/dialects/mysql"
)

type Item struct {
  Id        int       `gorm:"unique;not null"`
  Name      string    `gorm:"size:255"`
  Status    int       `gorm:"not null"`
  CreatedAt time.Time
  UpdatedAt time.Time
}

repositoryはDBとのやりとりを定義しますが、技術的関心ごとはinfrastructure層に書くため、ここではインターフェースとしてメソッドを定義します。

今回のToDoリストでは一覧取得、タスク登録、タスク更新のメソッドを定義します。実際の処理はinfrastructure層に書き、domain層に依存するように実装します。

ちなみに削除も追加しようと思ったのですが、ToDoリストの場合はステータスで判断するため、削除はUpdate()で行われることを想定しています。

もし削除機能を追加する場合は、DeletedAtカラムを追加して論理削除するようにします。Gormだとdeleteするとデフォルトで論理削除し、データ取得時もDeletedAtがnullのレコードを取得するようにしてくれます。

・domain/repository/item.go

package repository

import (
  "github.com/sample/go-ddd-crud/domain/model"
)

// ItemRepository : Item における Repository のインターフェース
type ItemRepository interface {
  FindAll() (items []*model.Item, err error)
  Create(item *model.Item) (err error)
  Update(item *model.Item) (err error)
}

infrastructure層

infrastructure層ではdomain層に依存するように実装します。

先ほどdomain層でインターフェースとして定義したFindAll()、Create()、Update()の3つの技術的処理を書いていきます。

FindAll()では、ToDoリスト一覧を取得し、その結果を返すようにします。

Create()では、POSTで送られてきたパラメータを元にToDoタスクを登録します。

Update()では、PUTで送られてきたパラメータを元にToDoタスクを更新します。

・infrastructure/persistence/item.go

package persistence

import (
  "time"

  "github.com/jinzhu/gorm"

  "github.com/sample/go-ddd-crud/domain/model"
  "github.com/sample/go-ddd-crud/domain/repository"
)

type itemPersistence struct {
  Conn *gorm.DB
}

// NewItemPersistence : Item データに関する Persistence を生成
func NewItemPersistence(conn *gorm.DB) repository.ItemRepository {
  return &itemPersistence{Conn: conn}
}

// Search : DB から Item データの全件取得（ItemRepository インターフェースの Index() を実装したもの）
func (ip *itemPersistence) FindAll() (items []*model.Item, err error) {
  // DB接続
  db := ip.Conn

  if err := db.Find(&items).Error; err != nil {
    return nil, err
  }

  return items, nil
}

// Create : DB から Item データの新規登録（ItemRepository インターフェースの Create() を実装したもの）
func (ip *itemPersistence) Create(item *model.Item) (err error) {
  // DB接続
  db := ip.Conn
  now := time.Now()

  // 新規登録用Item生成
  createItem := &model.Item{
    Name: item.Name,
    Status: item.Status,
    CreatedAt: now,
    UpdatedAt: now,
  }

  // 新規登録
  if err := db.Create(&createItem).Error; err != nil {
    return err
  }

  return nil
}

// Update : DB から Item データの更新（ItemRepository インターフェースの Update() を実装したもの）
func (ip *itemPersistence) Update(item *model.Item) (err error) {
  // DB接続
  db := ip.Conn
  now := time.Now()

  // 更新対象のItem取得
  updateItem := &model.Item{}
  if err := db.First(&updateItem, item.Id).Error; err != nil {
    return err
  }

  updateItem.Name = item.Name
  updateItem.Status = item.Status
  updateItem.UpdatedAt = now

  // 更新
  if err := db.Save(&updateItem).Error; err != nil {
    return err
  }

  return nil
}

usecase層

今回はシンプルなCRUD処理しかしないので、この層の存在価値がわかりにくいですが、複雑なビジネスロジックがあるときは、この層の存在価値が発揮されるようです。

Itemの取得や登録などでDBにアクセスする時にdomain層のrepositoryを介してアクセスすることによって、infrastructure層ではなくdomain層のみに依存させています。

この層で送られてきたパラメータのバリデートしていますが、実際はこの層でバリデートするのが正しいのかちょっとまだわかっていないです。。

usecase層の責務として、interface層から情報を受け取り、domain層で定義してあるメソッドを用いてビジネスロジックを実行することを考えると、この層で行うのが正しい気がしています。

・usecase/item.go

package usecase

import (
  "errors"

  "github.com/sample/go-ddd-crud/domain/model"
  "github.com/sample/go-ddd-crud/domain/repository"
)

// ItemUseCase : Item における UseCase のインターフェース
type ItemUseCase interface {
  FindAll() (items []*model.Item, err error)
  Create(status int, name string) (err error)
  Update(id, status int, name string) (err error)
}

type itemUseCase struct {
  itemRepository repository.ItemRepository
}

// NewItemUseCase : Item データに関する UseCase を生成
func NewItemUseCase(ir repository.ItemRepository) ItemUseCase {
  return &itemUseCase{
    itemRepository: ir,
  }
}

// Search : Item データを全件取得するためのユースケース
func (iu itemUseCase) FindAll() (items []*model.Item, err error) {
  // Persistence（Repository）を呼び出し
  items, err = iu.itemRepository.FindAll()
  if err != nil {
    return nil, err
  }
  return items, nil
}

// Create : Item データを新規登録するためのユースケース
func (iu itemUseCase) Create(status int, name string) (err error) {
  // Item 引数から構造体生成
  item := &model.Item{
    Name: name,
    Status: status,
  }

  // バリデーションを呼び出し
  if err := validate(item); err != nil {
    return err
  }

  // Persistence（Repository）を呼び出し
  err = iu.itemRepository.Create(item)
  if err != nil {
    return err
  }
  return nil
}

// Update : Item データを更新するためのユースケース
func (iu itemUseCase) Update(id, status int, name string) (err error) {
  // Item 引数から構造体生成
  item := &model.Item{
    Id: id,
    Name: name,
    Status: status,
  }

  // バリデーションを呼び出し
  if err := validate(item); err != nil {
    return err
  }

  // Persistence（Repository）を呼び出し
  err = iu.itemRepository.Update(item)
  if err != nil {
    return err
  }
  return nil
}

// Validate : Item データをバリデート
func validate(item *model.Item) error {
  if len(item.Name) >= 200 {
    return errors.New("タスク名は200文字未満で書いてください。")
  }
  return nil
}

interface層

interface層は、usecase層と切り離すことでリクエストやレスポンスの形に変わってもinterface層の修正だけで済むようになります。

Index()では、usecase層のメソッドを呼び出してToDoリスト一覧を取得し、返り値をJSON形式に変換しレスポンスとして返却しています。

Create()とUpdate()では、パラメータを引数にusecase層のメソッドを呼び出し、正常に成功した場合はHTTPレスポンスコード 200 No Contentで返すようになっています。http.Error(w, “成功”, 200)のように明示的にHTTPレスポンスコードを指定してハンドリングすこともできます。

DB接続やバリデートでエラーが発生した場合は、HTTPレスポンスコード 500でerr.Error()によるエラーメッセージを返却します。

・interface/handler/item.go

package handler

import (
  "encoding/json"
  "fmt"
  "net/http"
  "strconv"

  "github.com/julienschmidt/httprouter"
  "github.com/sample/go-ddd-crud/usecase"
)

// ItemHandler : Item における Handler のインターフェース
type ItemHandler interface {
  Index(http.ResponseWriter, *http.Request, httprouter.Params)
  Create(http.ResponseWriter, *http.Request, httprouter.Params)
  Update(http.ResponseWriter, *http.Request, httprouter.Params)
}

type itemHandler struct {
  itemUseCase usecase.ItemUseCase
}

// NewItemUseCase : Item データに関する Handler を生成
func NewItemHandler(iu usecase.ItemUseCase) ItemHandler {
  return &itemHandler{
    itemUseCase: iu,
  }
}

// ItemIndex : GET /items -> Item データの全件取得結果を返す
func (ih itemHandler) Index(w http.ResponseWriter, r *http.Request, pr httprouter.Params) {
  // ユースケースの呼び出し
  items, err := ih.itemUseCase.FindAll()
  if err != nil {
    http.Error(w, err.Error(), 500)
    return
  }

  // クライアントにレスポンスを返却
  if err = json.NewEncoder(w).Encode(items); err != nil {
    http.Error(w, err.Error(), 500)
    return
  }
}

// ItemCreate : POST /items -> Item データの新規登録結果を返す
func (ih itemHandler) Create(w http.ResponseWriter, r *http.Request, pr httprouter.Params) {
  // パラメータ
  name := r.FormValue("name")
  status, _ := strconv.Atoi(r.FormValue("status"))

  // ユースケースの呼び出し
  err := ih.itemUseCase.Create(status, name)
  if err != nil {
    http.Error(w, err.Error(), 500)
    return
  }

}

// ItemUpdate : PUT /items -> Item データの更新結果を返す
func (ih itemHandler) Update(w http.ResponseWriter, r *http.Request, pr httprouter.Params) {
  // パラメータ
  id, _ := strconv.Atoi(r.FormValue("id"))
  name := r.FormValue("name")
  status, _ := strconv.Atoi(r.FormValue("status"))

  // ユースケースの呼び出し
  err := ih.itemUseCase.Update(id, status, name)
  if err != nil {
    http.Error(w, err.Error(), 500)
    return
  }
}

main.go

main.goでは依存関係の定義とルーティングを設定しています。各層の依存関係を定義することで、利用可能な状態にします。

1. DBを操作するためconfig.Connect()でDB情報をitemPersistence(repository.ItemRepositoryを満たす)に注入
2. そのitemPersistenceをusecase層のitemUsecase(repository.ItemRepositoryをフィールドに持つ)に注入
3. 生成したitemUsecaseをitemHandler(itemUsecaseをフィールドに持つ)に注入

また、サーバ起動のタイミングであわせてCORSの設定もしておきます。

・main.go

package main

import (
  "fmt"
  "log"
  "net/http"

  "github.com/julienschmidt/httprouter"
  "github.com/sample/go-ddd-crud/config"
  "github.com/sample/go-ddd-crud/infrastructure/persistence"
  handler "github.com/sample/go-ddd-crud/interfaces/handler"
  "github.com/sample/go-ddd-crud/usecase"
)

func main() {
  // 依存関係を注入
  itemPersistence := persistence.NewItemPersistence(config.Connect())
  itemUseCase := usecase.NewItemUseCase(itemPersistence)
  itemHandler := handler.NewItemHandler(itemUseCase)

  // ルーティングの設定
  router := httprouter.New()
  router.GET("/api/items", itemHandler.Index)
  router.POST("/api/items", itemHandler.Create)
  router.PUT("/api/items", itemHandler.Update)

  // サーバ起動
  fmt.Println("------------------------")
  fmt.Println("サーバ起動 http://localhost:8080")
  fmt.Println("------------------------")

  http.ListenAndServe(":8080", &Server{router})
  log.Fatal(http.ListenAndServe(":8080", router))
}

type Server struct {
  r *httprouter.Router
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  w.Header().Add("Access-Control-Allow-Origin", "*")
  w.Header().Set("Access-Control-Allow-Methods", "GET POST PUT")
  w.Header().Add("Access-Control-Allow-Headers", "Content-Type")
  w.Header().Add("Access-Control-Allow-Headers", "Origin")
  w.Header().Add("Access-Control-Allow-Headers", "X-Requested-With")
  w.Header().Add("Access-Control-Allow-Headers", "Accept")
  w.Header().Add("Access-Control-Allow-Headers", "Accept-Language")
  w.Header().Set("Content-Type", "application/json")
  s.r.ServeHTTP(w, r)
}

DB設定

開発環境と本番環境のDB設定はdatabase.goに書いています。.env.developmentと.env.productionにそれぞれの環境におけるDB情報を定義しておき実行環境変数から取得しています。

db.AutoMigrate(&model.Item{})でサーバ起動時にItemテーブル生成のマイグレーションが実行されます。

ちょっと疑問なのが、すでに生成されたテーブルのカラム変更をしたい場合はどのようにするのでしょうかね。Railsのようにマイグレーションファイルで履歴管理するみたいな感じではないので、別途マイグレーション関連のツールを導入するのが正しいのでしょうか。

→ 調べてみたら以下のようにカラムの型変更などができるみたいです。

// `User`モデルのdescriptionカラムのデータ型を`text`に変更します
db.Model(&User{}).ModifyColumn("description", "text")

参考：

GOのORMを分かりやすくまとめてみた【GORM公式ドキュメントの焼き回し】 #Go - Qiita

はじめに GORMは公式ドキュメントがすごく良いのですが、途中から分かりづらかっ…

qiita.com

・config/database.go

package config

import (
  "os"

  "github.com/sample/go-ddd-crud/domain/model"

  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
  "github.com/joho/godotenv"
)

var (
  db *gorm.DB
  err error
)

// DB接続
func Connect() *gorm.DB {
  // 実行環境取得
  env := os.Getenv("HAKEN_ENV")

  if "production" == env {
    env = "production"
  } else {
    env = "development"
  }

  // 環境変数取得
  godotenv.Load(".env." + env)
  godotenv.Load()

  // DB接続
  db, err = gorm.Open("mysql", os.Getenv("CONNECT"))

  if err != nil {
    panic(err)
  }

  autoMigration()

  return db
}

// DB終了
func Close() {
  if err := db.Close(); err != nil {
    panic(err)
  }
}

// Item マイグレーション
func autoMigration() {
  db.AutoMigrate(&model.Item{})
}

動作確認

最後にTalend API Testerを使って動作確認をします。

・POSTでToDoタスク新規登録

・GETで新規登録したToDoタスクを取得

・PUTで新規登録したToDoタスクを更新

・GETで更新したToDoタスクを取得

・バリデーションエラー時

・DB接続エラー時

参考

Goプログラミング実践入門

実践ドメイン駆動設計

【Go + レイヤードアーキテクチャ】DDDを意識してWeb APIを実装してみる - yyh-gl's Tech Blog

2019/10/30 に内容を一部更新しました

yyh-gl.github.io

DDDを意識しながらレイヤードアーキテクチャとGoでAPIサーバーを構築する #ドメイン駆動設計 - Qiita

今の現場で初めてDDDに触れたので、よく採用されるアーキテクチャとしてレイヤード…

qiita.com

今すぐ「レイヤードアーキテクチャ+DDD」を理解しよう。（golang） #Go - Qiita

今すぐ「レイヤードアーキテクチャ+DDD」を理解しよう。（golang） とはい…

qiita.com

ドメイン駆動設計の本や記事を読んでも実際に自分の手でやってみないと身につかないと思い、簡易的ですが使えるところまで実装してみました。

DDD（domain driven design）とは

DDD(ドメイン駆動設計)とはソフトウェアの設計手法であり、ドメインモデリングに着目してソフトウェアの価値を高める手法です。

ソフトウェアの核心にある複雑さに立ち向かうため、チームの共通言語である「ユビキタス言語」を用いて「ドメインモデル」を構築し、それをコードとして実装します。

また、大規模で密結合なシステムにならないように「ドメイン」と「境界づけられたコンテキスト」にシステムを分割し、「コアドメイン」という最重要領域に集中して開発を行います。

DDDについてはまだ理解が浅いので、今はこれらの用語や設計思想についてざっくりとしかイメージできていませんが、今後開発しながら知見を深めていきたいと思います。

レイヤードアーキテクチャとは

従来のMVCなどの3層アーキテクチャに比べてdomain層を確立させ、そこにドメインロジックを凝集させようという発想のアーキテクチャです。

以下の図のように各レイヤごとに責務を切り分け、依存の方向を一方向にします。

純粋なレイヤードアーキテクチャでは上の図になるのですが、DDDではDIP(依存関係逆転の原則)を用いて下の図のような依存関係になります。

レイヤードアーキテクチャが必要な理由

レイヤードアーキテクチャが必要な理由として以下の2点が挙げられます。

1. コードの依存関係を整理できる
2. レイヤ内のパッケージの凝縮度を高めることができる

また、コード量が多くなると、何がどこに影響するのか管理しづらくなり可読性が低下します。レイヤードアーキテクチャを取り入れることで、システムの保守性が低下しないようにするための効果的なアプローチとなります。

個人的に依存関係が整理されることでシステム規模が大きくなった時や新しくチームにメンバーが入った時にもスムーズに開発に入りやすい点も大きな魅力に感じました。

各レイヤの責務と役割

それぞれのレイヤの責務と役割は以下のようになります。

interface層

• HTTPを受け取り、usecaseを呼び結果を出力(JSONやHTML)

→ 基本的に薄い実装になるが、HTTPのbodyやheaderのパース処理などで薄くならないこともあります。

usecase層

• アプリケーションレイヤでシステム使用上のユースケースを表現

→ ユーザ登録、ユーザ覧表示など

• handlerから呼びされる

→ 1つのhandlerに対応する専用usecaseが1つ存在します。

• 基本的にはdomainを触る

domain層

• モデルレイヤでドメイン(システムが扱う業務領域)に関する値と振る舞いを持つ
• 他のレイヤに依存しない

infrastructure層

• 技術的関心ごとを扱うレイヤで具体的な技術に関する処理を書く

→ DBやMail操作など

• 直接handler、usecaseから呼ばれることもあるが、基本的にdomainのインターフェースによって抽象化される

ディレクトリ構成

ディレクトリ構成は以下のようになりました。docker-compose.ymlでMySQL立ち上げて使用しています。

sample-api
├── config
│ └── database.go
├── domain
│ └── model
│     └── user.go
│ └── repository
│     └── user.go
├── infrastructure
│ └── persistence
│     └── user.go
├── interface
│ └── handler
│     └── user.go
├── usecase
│ └── user.go
├── .env.development
├── .env.production
├── docker-compose.yml
└── main.go

domain層

domain層ではmodelとrepositoryに分けています。上の図でも説明した通りドメイン層はどの層にも依存せずに隔離します。

ドメインロジックを集約させ、ここをインクリメンタルに成長させながら全体の開発に展開させていきます。modelは業務領域における構造体やビジネスロジックを置きます。

ちなみに下記のような属性と値を保持するだけのオブジェクトの状態は「ドメインモデル貧血症」と呼ばれています。

オブジェクト指向において、データ(フィールド変数)とそれについての操作(メソッド)は同じクラス内にあるべきであり、この状態はそうなっていないためです(必ずダメというわけではない)。今回は検索するだけのとてもシンプルなAPIなので本来はここに処理を書いていくことになると思います。

・domain/model/user.go

package model

import (
  "time"

  _ "github.com/jinzhu/gorm/dialects/mysql"
)

type User struct {
  Id uint
  name string
  CreatedAt time.Time
}

repositoryはDBとのやりとりを定義しますが、技術的関心ごとはinfrastructure層に書くため、ここではインターフェースとしてメソッドを定義します。

実際の処理はinfrastructure層に書き、domain層に依存するように実装します。

・domain/repository/user.go

package repository

type UserRepository interface {
  Search(name string) ([]*model.User, error)
}

infrastructure層

infrastructure層ではdomain層に依存するように実装します。

domain層で定義したインターフェースから実際の技術的処理を書いていきます。

今回はユーザ名を引数にして検索を行う処理を実装しています。DBはMySQLを使用し、DB操作のORMはGORMを使用しています。

・infrastructure/persistence/user.go

package persistence

import (
  "github.com/jinzhu/gorm"

  "github.com/sample/sample-api/domain/model"
  "github.com/sample/sample-api/domain/repository"
)

// UserにおけるPersistenceのインターフェース
type userPersistence struct {
  Conn *gorm.DB
}

// Userデータに関するPersistenceを生成
func NewUserPersistence(conn *gorm.DB) repository.UserRepository {
  return &userPersistence{Conn: conn}
}

// 検索
func (up *userPersistence) Search(name string) ([]*model.User, error) {
  var user []model.User

  // DB接続確認
  if err := up.Conn.Take(&user).Error; err != nil {
    return nil, err
  }

  db := up.Conn.Find(&user)

  // 名前検索
  if name != "" {
    db = db.Where("name = ?", name).Find(&user)
  }

  return user, nil
}

usecase層

usecase層ではユースケースに沿った処理の流れを実装します。

今回は単純な処理しかしないので、この層の存在価値がわかりにくいですが、複雑なビジネスロジックがあるときは、この層の存在価値が発揮されるようです。

データの取得や保存などでDBにアクセスするときもdomain層のrepositoryを介してアクセスすることによって、infrastructure層ではなくdomain層のみに依存させています。

・usecase/user.go

package usecase

import (
  "github.com/sample/sample-api/domain/repository"
)

// UserにおけるUseCaseのインターフェース
type UserUseCase interface {
  Search(name string) ([]*model.User, error)
}

type userUseCase struct {
  userRepository repository.UserRepository
}

// Userデータに関するUseCaseを生成
func NewUserUseCase(ur repository.UserRepository) UserUseCase {
  return &userUseCase{
    userRepository: ur,
  }
}

// 検索
func (uu userUseCase) Search(name string) (user []*model.User, err error) {
  user, err = uu.userRepository.Search(name)
  if err != nil {
    return nil, err
  }
  return user, nil
}

interface層

interface層はHTTPリクエスト・レスポンスを扱う層です。

usecase層と切り離すことでリクエストやレスポンスの形に変わってもinterface層の修正だけで済むようになります。

今回はGETパラメータのnameを引数にusecase層の検索メソッドを呼び出し、返り値をJSON形式に変換しレスポンスとして返却しています。

・interface/handler/user.go

package rest

import (
  "encoding/json"
  "net/http"
  "strconv"

  "github.com/julienschmidt/httprouter"
  "github.com/sample/sample-api/usecase"
)

// userにおけるHandlerのインターフェース
type userHandler interface {
  Index(http.ResponseWriter, *http.Request, httprouter.Params)
}

type userHandler struct {
  userUseCase usecase.UserUseCase
}

// Userデータに関するHandlerを生成
func NewUserHandler(uu usecase.UserUseCase) UserHandler {
  return &userHandler{
    userUseCase: uu,
  }
}

// UserIndex : GET /users -> 検索結果を返す
func (uh userHandler) Index(w http.ResponseWriter, r *http.Request, pr httprouter.Params) {
  // GETパラメータ
  name := r.FormValue("name")

  user, err := jh.userUseCase.Search(name)
  if err != nil {
    http.Error(w, err.Error(), 500)
    return
  }

  // クライアントにレスポンスを返却
  if err = json.NewEncoder(w).Encode(user); err != nil {
    http.Error(w, err.Error(), 500)
    return
  }
}

main.go

main.goでは依存関係の定義とルーティングを設定します。各層の依存関係を定義することで、利用可能な状態にします。

infrastructure層でDBを操作するためconfig.Connect()でDB情報をセットしておきます。

また、サーバ起動のタイミングであわせてCORSの設定もしておきます。今回は例として「https://example.com」からGETのみ許可するようにしています。

・main.go

package main

import (
  "fmt"
  "log"
  "net/http"

  "github.com/julienschmidt/httprouter"
  "github.com/sample/sample-api/config"
  "github.com/sample/sample-api/infrastructure/persistence"
  handler "github.com/sample/sample-api/interfaces/handler"
  "github.com/sample/sample-api/usecase"
)

func main() {
  // 依存関係を定義
  userPersistence := persistence.NewUserPersistence(config.Connect())
  userUseCase := usecase.NewUserUseCase(userPersistence)
  userHandler := handler.NewUserHandler(userUseCase)

  // ルーティングの設定
  router := httprouter.New()
  router.GET("/api/users", userHandler.Index)

  // サーバ起動
  http.ListenAndServe(":8080", &Server{router})
  log.Fatal(http.ListenAndServe(":8080", router))
}

type Server struct {
  r *httprouter.Router
}

func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  w.Header().Add("Access-Control-Allow-Origin", "https://example.com")
  w.Header().Set("Access-Control-Allow-Methods", "GET")
  w.Header().Add("Access-Control-Allow-Headers", "Content-Type")
  w.Header().Add("Access-Control-Allow-Headers", "Origin")
  w.Header().Add("Access-Control-Allow-Headers", "X-Requested-With")
  w.Header().Add("Access-Control-Allow-Headers", "Accept")
  w.Header().Add("Access-Control-Allow-Headers", "Accept-Language")
  w.Header().Set("Content-Type", "application/json")
  s.r.ServeHTTP(w, r)
}

DB設定

開発環境と本番環境のDB設定はdatabase.goに書いています。.env.developmentと.env.productionにそれぞれの環境におけるDB情報を定義しておき実行環境変数から取得しています。

・config/database.go

package config

import (
  "os"

  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
  "github.com/joho/godotenv"
)

var (
  db *gorm.DB
  err error
)

// DB接続
func Connect() *gorm.DB {
  // 実行環境取得
  env := os.Getenv("ENV")

  if "production" == env {
    env = "production"
  } else {
    env = "development"
  }

  // 環境変数取得
  godotenv.Load(".env." + env)
  godotenv.Load()

  // DB接続
  db, err = gorm.Open("mysql", os.Getenv("CONNECT"))

  if err != nil {
    panic(err)
  }

  return db
}

// DB終了
func Close() {
  if err := db.Close(); err != nil {
    panic(err)
  }
}

まとめ

Go + DDD + レイヤードアーキテクチャでREST APIを実装してみました。今回のような簡単なAPIではあまり効果を発揮しないように思いますが、それぞれのレイヤと依存関係を実装しながら学ぶことでDDDとレイヤードアーキテクチャの理解を深めることができました。

WebメディアやサービスではMVCをベースで開発していましたが、アジャイル開発でどんどん仕様が変わり複雑化していく中でよりよい開発手法を取り入れたいとずっと思っていました。

そのため、今後新規開発していく上でアーキテクチャ選定のひとつの選択肢として積極的に取り入れていきたいと思います。

その後、こちらでCRUDのREST APIを実装してみました。

【Go】GormでシンプルなCRUDのREST APIを実装する

https://mintaku-blog.net/go-ddd/ 先日上記記事で…

mintaku-blog.net

参考

• Goプログラミング実践入門
• 実践ドメイン駆動設計
• https://yyh-gl.github.io/tech-blog/blog/go_web_api/
• https://qiita.com/ryokky59/items/6c2b35169fb6acafce15
• https://qiita.com/tono-maron/items/345c433b86f74d314c8d
• https://www.slideshare.net/masuda220/powered-by-spring
• https://www.slideshare.net/pospome/go-80591000

Cookieおさらい

正式には「HTTP cookie」でWebサイトへアクセスした際に、ユーザのデバイス(PCやスマホ)に残していくデータのことです。

サーバからHTTPレスポンスメッセージを通して送られるもので、クライアントに保管されます。次回以降はCookieとともにWebサーバーへアクセスするため、ユーザが保持していたCookieにあわせてページを表示することができます。

分類としてはセッションクッキーと永続性クッキーの2種類に分けられます。

Goにおけるtype Cookie

httpパッケージのtype Cookieは以下のような構造体になっています。

基本的にはhttp.Cookie型へのポインタ変数を用意し、NameフィールドにCookie名、ValueフィールドにCookieの値を入れて設定します。

type Cookie struct {
  Name string
  Value string

  Path string // optional
  Domain string // optional
  Expires time.Time // optional
  RawExpires string // for reading cookies only

  // MaxAge=0 means no 'Max-Age' attribute specified.
  // MaxAge<0 means delete cookie now, equivalently 'Max-Age: 0'
  // MaxAge>0 means Max-Age attribute present and given in seconds
  MaxAge int
  Secure bool
  HttpOnly bool
  SameSite SameSite // Go 1.11
  Raw string
  Unparsed []string // Raw text of unparsed attribute-value pairs
}

ExpiresとMaxAgeフィールドをしているすることで有効期限を設定することができます。

Expiresフィールドは、Cookieの期限切れとなるtime.Time型を指定します。

ex) Expires: time.Now().Add(24 * time.Hour) // 24時間後に期限切れ

MaxAgeフィールドは、ブラウザ内で生成されてからどれだけの期間有効かを指定します。ちなみに秒単位です。

ex) MaxAge: 60 * 60 // 1時間後に期限切れ

Expiresはほぼ全てのブラウザに対応しているが、HTTP1.1以降では非推奨となり、MaxAgeが推奨されています。ただ、MaxAgeはIE6、7、8で対応されていません。

参考：https://golang.org/pkg/net/http/#Cookie

Cookieの設定・送信

http.Cookie型へのポインタ変数を用意し、それぞれのフィールドに値を入れ、http.ResponseWriterとcookieを引数にセットします。

cookie := &http.Cookie{
  Name: "sample_name",
  Value: "sample_value",
  HttpOnly: true,
}
http.SetCookie(writer, cookie)

実際に使われる例として、ユーザログイン時にCookieを生成する場合だと以下のような流れになります。

メールアドレスとパスワードがPOSTされ、メールアドレスからユーザが存在するかをチェックします。ここでのdata.UserByEmailメソッド(処理は省略)はメールアドレスからユーザを取得してきています。

次にPOSTされたパスワードが取得したユーザのパスワードと一致しているかをチェックし、user.CreateSession()メソッド(処理は省略)でサーバ側で持つセッションを生成してセッションテーブルにインサートします。

その後、Cookieをセットしログイン後のページにリダイレクトさせます。

func auth(writer http.ResponseWriter, request *http.Request) {
  err := request.ParseForm()
  user, err := data.UserByEmail(request.PostFormValue("email"))
  if err != nil {
    danger(err, "ユーザが見つかりませんでした。")
  }
  if user.Password == data.Encrypt(request.PostFormValue("password")) {
    session, err := user.CreateSession()
    if err != nil {
      danger(err, "セッションを生成することができません。")
    }
    cookie := &http.Cookie{
      Name: "auth",
      Value: session.Uuid,
      HttpOnly: true,
    }
    http.SetCookie(writer, cookie)
    http.Redirect(writer, request, "/", 302)
  } else {
    http.Redirect(writer, request, "/login", 302)
  }

}

Cookieの取得

構造体RequestのCookieメソッドを使用して、HTTPリクエストからのCookieを取得できます。指定したCookieが存在しない場合はエラーを返します。

複数のCookieを取得したい場合は、Cookiesを使うことで全てのCookieをスライスに入れて取得できます。
cookie.ValueでCookieの値を取得することができます。

cookie, err := request.Cookie("sample")

if err == nil {
  v := cookie.Value
}

実際に使われる例として、クライアントとサーバ間でのCookieのやりとりの場合、以下のような流れになります。

request.Cookie()メソッド(処理は省略)でCookieを取得し、Session構造体にセットします。

その後、送られてきたセッションをチェックし、無効の場合はエラーにします。

func session(writer http.ResponseWriter, request *http.Request) (sess data.Session, err error) {
  cookie, err := request.Cookie("auth")
  if err == nil {
    sess = data.Session{Uuid: cookie.Value}
    if ok, _ := sess.Check(); !ok {
      err = errors.New("セッションが無効です")
    }
  }
  return
}

GoにおけるCookie操作についてのまとめでした。

そもそもGoの本やGoに関する情報を読んだ感じ、多くのことが標準ライブラリでまかなえるため、基本はFWやORMを使わないのが「Goらしい手法」とのことなので、次は標準ライブラリのみでも実装してみたいと思います。

参考：https://employment.en-japan.com/engineerhub/entry/2018/06/19/110000

参考：https://golang.org/doc/effective_go.html

Ginとは

Ginとは軽量かつシンプルなインターフェイスが特徴のGoのWebアプリケーションフレームワークです。

また、GoのWebアプリケーションの中では比較的初期から開発されているので安定して使われています。

Gormとは

Goでよく使われているORMの一種です。

そもそもORM(O/Rマッピング)とは、オブジェクト指向言語におけるオブジェクトと、リレーショナルデータベースにおけるレコードとを対応づけることです。

ORMによって、リレーショナルデータベースのレコードがオブジェクトとして直感的に扱えるようになり、リレーショナルデータベースにアクセスするプログラムを記述する処理を容易にすることが可能になります。

プロジェクト構成

Getパラメータで本検索をして、その結果をJSON形式で返す簡単なAPIを実装していきます。

以下の記事を参考にプロジェクト構成を組んでみました。元々Railsを書いていたこともあり、この構成が今のところしっくりきました(今後勉強していくうちによりより構成が見つかる気がします)。

参考：https://qiita.com/Asuforce/items/0bde8cabb30ac094fcb4

sample-go-api
├── controller
│ └──book_controller.go
├── db
│ └── db.go
├── entity
│ └── book.go
├── main.go
├── server
│ └── server.go
├── service
│ └── book_service.go
├── .env.development
├── .env.production
├── .gcloudignore
├── .gitgnore
├── app.yaml
├── docker-compose.yml
├── go.mod
├── go.sum
├── main.go

DB・モデル実装

ローカル用にDockerでさくっとMySQLを立ち上げてDBを作成します。

・docker-compose.yml

version: '3'
services:
  mysql:
    image: mysql:5.7
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: db
      MYSQL_USER: user
      MYSQL_PASSWORD: password
    ports:
      - "3306:3306"

docker-compose.ymlができたら、起動します。

$ docker-compose up -d

次にGormとMySQLをgo getでインストールします。

$ go get github.com/jinzhu/gorm
$ go get github.com/jinzhu/gorm/dialects/mysql

本モデルを作成します。

booksテーブルのカラムを定義します。

・entity/book.go

package entity

import (
  "time"
)

type Book struct {
  Id uint
  Title string `gorm:"size:128"`
  Category int
  Author string `gorm:"size:64"`
  CreatedAt time.Time
}

DB周りを実装していきます。今回はGAEに本番環境をデプロイするので、developmentとproductionと2つの環境を作りました。そのため、godotenvライブラリを使って実行する環境を取得します。

実行環境に合ったDB接続を行います。ローカルはDockerで立ち上げたMySQL、本番はCloud SQLを使っています。

DB初回起動時にマイグレーションが行われるようにしています。

・db/db.go

package db

import (
  "os"

  "github.com/jinzhu/gorm"
  _ "github.com/jinzhu/gorm/dialects/mysql"
  "github.com/joho/godotenv"

  "github.com/sample/sample-go-api/entity"
)

var (
  db *gorm.DB
  err error
)

// DB初期化
func Init() {
  // 実行環境取得
  env := os.Getenv("ENV")

  if "production" == env {
    env = "production"
  } else {
    env = "development"
  }

  // 環境変数取得
  godotenv.Load(".env." + env)
  godotenv.Load()

  // DB接続
  db, err = gorm.Open("mysql", os.Getenv("CONNECT"))

  if err != nil {
    panic(err)
  }

  autoMigration()
}

// DB取得
func GetDB() *gorm.DB {
  return db
}

// DB接続終了
func Close() {
  if err := db.Close(); err != nil {
    panic(err)
  }
}

// マイグレーション
func autoMigration() {
  db.AutoMigrate(&entity.Book{})
}

ローカル環境用のenv。

・.env.development

CONNECT=user:password@tcp(localhost:3306)/db?parseTime=true

本番環境用のenv。

・.env.production

CONNECT=user:password@unix(/cloudsql/sample-project:sample-zone:sample-instance)/sample_db?parseTime=true

Bookサービスの実装

検索処理を実装していきます。送られてきたGETパラメータからそれぞれのカラム検索を行います。

Gormを使っていますが、このくらいのSQLならわざわざORMを使わなくても良い気がしますね。

・service/book_service.go

package book

import (
  "github.com/sample/sample-go-api/db"
  "github.com/sample/sample-go-api/entity"
)

type Service struct{}

type book entity.Book

type Parameter struct {
  title string
  category int
  author string
}

// 検索
func (s Service) Search(title string, category int, author string) ([]Book, error) {

  // DB接続
  db := db.GetDB()

  // 本モデルから作成
  var book []Book

  // パラメータセット
  p := Parameter{title, category, author}

  // DB接続確認
  if err := db.Take(&book).Error; err != nil {
    return nil, err
  }

  // 本検索クエリ
  tx := db
  tx = tx.Find(&book)

  // タイトル
  if p.title != "" {
    tx = tx.Where("title = ?", p.title).Find(&book)
  }

  // カテゴリ
  if p.category != 0 {
    tx = tx.Where("category = ?", p.category).Find(&book)
  }

  // 著者
  if p.author != "" {
    tx = tx.Where("author = ?", p.author).Find(&book)
  }

  return book, nil
}

Bookコントローラの実装

Ginをgo getでインストールしておきます。

$ go get -u github.com/gin-gonic/gin

コントローラを実装します。*gin.ContextでGETパラメータを取得してサービスの検索メソッドに投げています。

検索結果を受け取ってJSON形式で返しています。

・controller/book_controller.go

package book

import (
  "fmt"
  "net/http"
  "strconv"

  "github.com/gin-gonic/gin"

  book "github.com/sample/sample-go-api/service"
)

type Controller struct{}

// 検索 GET /books
func (pc Controller) Index(c *gin.Context) {
  // パラメータ取得
  title := c.Query("title")
  category, _ := strconv.Atoi(c.Query("category"))
  author := c.Query("author")

  // 検索処理
  var s book.Service
  p, err := s.Search(title, category, author)

  // 検索結果を返す
  if err != nil {
    c.AbortWithStatus(http.StatusNotFound)
    fmt.Println(err)
  } else {
    c.JSON(http.StatusOK, p)
  }
}

サーバ周り実装

ルーティング・CORS設定・サーバ起動を実装しています。

・server/server.go

package server

import (
  "net/http"

  "github.com/gin-gonic/gin"

  book "github.com/sample/sample-go-api/controller"
)

// 初期化
func Init() {
  r := router()

  r.Run()
}

// ルーティング
func router() *gin.Engine {
  r := gin.Default()

  // CORS対応
  r.Use(CORS())

  // ルーティング
  u := r.Group("/books")
  {
    ctrl := book.Controller{}
    u.GET("", ctrl.Index)
  }

  return r
}

// CORS
func CORS() gin.HandlerFunc {
  return func(c *gin.Context) {
    c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
    c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
    c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
    c.Writer.Header().Set("Access-Control-Allow-Methods", "GET, OPTIONS")

    if c.Request.Method == "OPTIONS" {
      c.AbortWithStatus(http.StatusNoContent)
      return
    }

    c.Next()
  }
}

main.goの実装

最後にmain.goからDBとサーバを起動して完了です。後は.gitignoreにenvファイルを追加しておきましょう。

package main

import (
  "github.com/sample/sample-go-api/db"
  "github.com/sample/sample-go-api/server"
)

func main() {
  db.Init()
  server.Init()
}

GAEにデプロイする

完成したAPIをGAEにデプロイします。

Goのバージョンは1.12、インスタンスクラスは一番下のF1を指定します(デフォルトF1ですが)。

正規表現 /.* にパスが一致するURLへのすべてのリクエストはmainパッケージのhandle関数で処理されます。

ENVでproductionを指定することでCloud SQLに接続するようにしています。

参考：https://cloud.google.com/appengine/docs/standard/go/config/appref?hl=ja

runtime: go112
service: sample-go-api-production
instance_class: F1
handlers:
  - url: /.*
    script: auto
env_variables:
  ENV: production

以下のコマンドでGAEにデプロイして完了です。

$ gcloud app deploy