GoでWebSocketを使用した同じUUIDを持った異なるプラットフォーム(デバイス)同士のリアルタイム通信システム

みなさんUnity(Metaquest)とAndroid間といった2つのプラットフォーム間の通信を必要とした場面はありませんか？また，それぞれが同じUUID(固有の識別子)を持っている同士で個別の非同期通信を実現する場面はありませんか？
本記事では, GoとWebSocketを使用してUnityクライアントとAndroidクライアント間でリアルタイムな通信を実現するシステムの実装について詳しく解説します.

:::note warn
今回はサーバーの実装のみ記述します．クライアント側の実装はないので注意してください
:::

goの文法基本はここから

https://qiita.com/JavaLangRuntimeException/items/d388717fc1436bc3ec9d

## システム概要

**機能要件**
- システム全体としてQuizとActionと言った永続的に格納しておくデータが存在する．
- それぞれのQuizとActionはidと難易度(difficulty)と2択の選択肢(rig_sel,lef_sel)が存在する．Quizに関してはクイズ名としてnameが存在する．
- Android端末から難易度(QuizとAction共通の難易度)を送信する.
- 難易度に応じたクイズとアクションデータをUnityに送信する.
- WebSocketを使用してリアルタイムな双方向通信を実現する.
- UUIDベースの接続管理により, 特定のAndroidとUnityのペアリングを実現する.
- Unity側でUUIDをパスパラメータに持たせてWebsocket通信を確立した場合に限り，Android側で同じUUIDをパスパラメータに持たせてWebSocket通信を確立させられるようにする．(簡単にいうとUnity側から先にUUIDをもとに非同期通信を始めていないとAndroid側から同じUUIDで非同期通信を始められないようにしたい)

:::note info
**簡単に言うと**
- Android側からクイズの難易度を送ったらUnity側でクイズの難易度に応じたidを受け取るような非同期通信のシステムを作りたい
- ユーザごとにAndroid側からUnity側に確実にデータを送れるようにUUIDを使った接続管理やUnity側で先に接続している状態でのみAndroid側で接続できるようなシステムにしたい
:::
具体的には以下のURLと送受信するメッセージで接続できるようにしたい
**Android側からのリクエスト**
URL
```bash
ws://localhost:8080/ws/difficulty/android/{uuid}
```
例
```bash
ws://localhost:8080/ws/difficulty/android/de358130-e94a-5692-8b09-d27007ad1944
```
送信するメッセージ
```json
{
 "difficulty": 1 
}
```

**Unityでのレスポンス**
URL
```bash
ws://localhost:8080/ws/difficulty/unity/{uuid}
```
例
```bash
ws://localhost:8080/ws/difficulty/unity/de358130-e94a-5692-8b09-d27007ad1944
```
受信するメッセージ
```json
{
"quiz_id":[1,2,3],
"action_id":1
}
```

こんな感じでAmdroid，unity間で同じUUID同士でWebsocket通信ができるようにする．


**技術スタック**
- サーバーサイド: Go
- データベース: GORM (O/Rマッパー)(DBMS:PostgreSQL)
- WebSocket: gorilla/websocket
- ルーティング: gorilla/mux

バックエンドは少し複雑なのでDDDとクリーンアーキテクチャで実装しています．

:::note info
**今回使用したレイヤー構造**
わからなかったらスルーしていただいて結構です．

**1. Domain**
- **model**
    - 基本的なビジネスエンティティの定義(今回使用するデータ構造体)を作成する
- **repository**
    - データアクセスの抽象化インターフェースを定義

**2. UseCase**
- アプリケーションのビジネスロジック
- ドメインレイヤーのインターフェースを使用

**3. Interface**
- **handler**
    - WebSocket通信を処理するハンドラー（クライアント側に送信するデータの定義)を実装


**4. Infrastructure**
- **persistence**
    - データアクセスオブジェクト(DAO)の具体的な実装（データベースアクセスの具体的な実装）
:::

今回は以下のようなディレクトリ構造にしています．
```
.
├── Dockerfile
├── docker-compose.yml
├── go.mod
├── go.sum
├── main.go
├── db
│   └── migrations
│       ├── 000001_create_quiz_table.down.sql
│       ├── 000001_create_quiz_table.up.sql
│       ├── 000002_create_action_table.down.sql
│       └── 000002_create_action_table.up.sql
├── domain
│   ├── models
│   │   ├── action.go
│   │   ├── message_difficulty.go
│   │   └── quiz.go
│   └── repositories
│       ├── action_repository.go
│       └──quiz_repositpry.go
├── infrastructure
│   └── persistence
│       ├── action_persistence.go
│       └──quiz_persistence.go
├── interfaces
│   └── handlers
│       └── difficulty_handler.go
└── usecase
    └── difficulty_usecase.go
```
## 開発の見通し
1. Dockerを用いた環境構築
2. テーブルの作成をするSQLを定義
3. データを扱う構造体を定義するためのドメインモデルを作成
4. データアクセスの抽象化を行うためのインターフェースを定義するリポジトリを作成
5. データベースにデータをアクセスするための具体的な実装を定義するインフラストラクチャを作成
6. 5で定義したデータアクセス部を使用して実際に使用するビジネスロジックを定義するユースケースを作成
7. 6で定義したユースケースをクライアント側とやり取りするためのデータ形式を定義するハンドラーを作成
8. 今まで作成した関数を初期化したり，db接続を初期化したり，環境変数からデータを取得したり，ルーティングを定義するmain.goの作成
## docker系
今回はDocker系のファイルは詳しく説明しない．
今回のシステムはAir，Ginを使用する．

:::note info
**1. Air**
Airは，Goの開発環境でのホットリロードツール．ソースコードに変更を加えると，自動的にアプリケーションを再起動して変更を反映してくれる．これにより，開発中に毎回手動で再起動する手間が省け，効率的に開発を進めることができる．

**2. Gin**
Ginは、Go言語用の軽量で高性能なWebフレームワーク．
:::
Dockerfile
```Dockerfile 
FROM golang:1.23.1

RUN go install github.com/air-verse/air@latest
```
docker-compose.yml
```docker-compose.yml
version: "3.8"

services:
  go:
    container_name: app
    volumes:
      - ./:/project/
    working_dir: /project
    tty: true
    build: "./"
    ports:
      - 8080:8080
    command: sh -c 'go mod tidy && air'
```

## テーブルの作成
まず，今回データベースに作成するテーブルをSQLで記載する．
quizzesテーブルの作成
```000001_create_quiz_table.up.sql
CREATE TABLE quizzes (
                         id SERIAL PRIMARY KEY,
                         name VARCHAR(255),
                         difficulty INTEGER,
                         lef_sel VARCHAR(255),
                         rig_sel VARCHAR(255),
                         detail    VARCHAR(255)
);
```
actionsテーブル
```000002_create_action_table.up.sql
CREATE TABLE actions (
                         id SERIAL PRIMARY KEY,
                         difficulty INTEGER,
                         lef_sel VARCHAR(255),
                         rig_sel VARCHAR(255),
                         detail    VARCHAR(255)
);
```
これを直接DBにアクセスしてテーブル作成しても良いし，マイグレーションをするパッケージを使用しても良い．
マイグレーションをするパッケージを使用するならば，DROP TABLEするマイグレーションファイル(`000001_create_quiz_table.down.sql`や`000002_create_action_table.down.sql`)も必要である．
## ドメインモデルの設計
Quizモデルはゲーム内のクイズデータを表現する.

```domain/models/quiz.go
package models

type Quiz struct {
	ID         int    `json:"id" gorm:"primaryKey;autoIncrement"`
	Name       string `json:"name"`
	Difficulty int    `json:"difficulty"`
	LefSel     string `json:"lef_sel"`
	RigSel     string `json:"rig_sel"`
	Detail     string `json:"detail"`
}
```
> イメージとして以下のような属性を持っている．
ID: PrimaryKey（主キー)
Name: クイズ名
Difficulty: 難易度
LefSel: 左選択肢
RigSel: 右選択肢
Detail: クイズの詳細

同様にActionモデルを作成する．
```domain/models/action.go
package models

type Action struct {
	ID         int    `json:"id" gorm:"primaryKey;autoIncrement"`
	Difficulty int    `json:"difficulty"`
	LefSel     string `json:"lef_sel"`
	RigSel     string `json:"rig_sel"`
	Detail     string `json:"detail"`
}
```

クライアントと通信するためのメッセージの構造体を定義する．
```domain/repositories/difficulty_message.go
package models

type AndroidDifficultyMessage struct {
	Difficulty int `json:"difficulty"`
}

type UnityDifficultyMessage struct {
	QuizIDs  []int `json:"quiz_id"`
	ActionID int   `json:"action_id"`
}

```

## リポジトリの実装
データアクセスの抽象化を行うインターフェースを定義する.
まずQuizデータにアクセスするためのインターフェースを定義する．
```domain/repositories/quiz_repository.go
package repositories

import "your-module/domain/models"

type QuizRepository interface {
	FindByDifficulty(difficulty int, limit int) ([]models.Quiz, error)
}
```
同様にActionデータにアクセスするためのインターフェースを定義する．
```domain/repositories/action_repository.go
package repositories

import "your-module/domain/models"

type ActionRepository interface {
	FindOneByDifficulty(difficulty int) (*models.Action, error)
}
```
## インフラストラクチャ部の作成
データベースにQuizデータにアクセスするための具体的な実装
```infrastructure/persistence/quiz_persistence.go
package persistence

import (
	"your-module/domain/models"
	"your-module/domain/repositories"
	"gorm.io/gorm"
)

type quizRepository struct {
	db *gorm.DB
}

func NewQuizRepository(db *gorm.DB) repositories.QuizRepository {
	return &quizRepository{db: db}
}

// 実際にDifficultyをもとにquizIDをとってくる関数
func (r *quizRepository) FindByDifficulty(difficulty int, limit int) ([]models.Quiz, error) {
	var quizzes []models.Quiz
	// ORDER BY RAND()を追加してランダムに取得
	err := r.db.Where("difficulty = ?", difficulty).Order("RAND()").Limit(limit).Find(&quizzes).Error
	return quizzes, err
}


```

同様にActionデータにアクセスするための具体的な実装
```infrastructute/persistence/action_persistence.go
package persistence

import (
	"your-module/domain/models"
	"your-module/domain/repositories"
	"gorm.io/gorm"
)

type actionRepository struct {
	db *gorm.DB
}

func NewActionRepository(db *gorm.DB) repositories.ActionRepository {
	return &actionRepository{db: db}
}

// 実際にDifficultyをもとにactionIDをとってくる関数
func (r *actionRepository) FindOneByDifficulty(difficulty int) (*models.Action, error) {
	var action models.Action
	// ORDER BY RAND()を追加してランダムに取得
	err := r.db.Where("difficulty = ?", difficulty).Order("RAND()").First(&action).Error
	return &action, err
}
```

:::note info
今回はデータ量が少ないのでORDER BY RAND()を使っているが，これはDBヘの負担が多い操作なので注意．
データ量が多い場合は以下のようなクエリを実行するようなgoの実装があるといいと思う．
```sql
-- 1. まず難易度に一致するIDの範囲を取得
WITH id_range AS (
    SELECT MIN(id) as min_id, MAX(id) as max_id
    FROM quizzes
    WHERE difficulty = :difficulty
)

-- 2. その範囲内でランダムにレコードを取得
SELECT *
FROM quizzes
WHERE difficulty = :difficulty
AND id IN (
    -- ここでは例として3件取得する場合
    SELECT FLOOR(
        RAND() * ((SELECT max_id FROM id_range) - (SELECT min_id FROM id_range) + 1)
    ) + (SELECT min_id FROM id_range)
    FROM (
        SELECT 1 UNION SELECT 2 UNION SELECT 3
    ) t
)
```
:::

# ユースケース部の作成
QuizとActionの両方のデータを取得し、QuizID3つとActionIdを返す構造体をmodelsをで定義した構造体を基に作成するビジネスロジックを実装
```usecase/difficulty_usecase.go
package usecase

import (
	"HOPcardAPI/domain/models"
	"HOPcardAPI/domain/repositories"
)

type DifficultyUsecase struct {
	quizRepo   repositories.QuizRepository
	actionRepo repositories.ActionRepository
}

func NewDifficultyUsecase(qr repositories.QuizRepository, ar repositories.ActionRepository) *DifficultyUsecase {
	return &DifficultyUsecase{
		quizRepo:   qr,
		actionRepo: ar,
	}
}

func (u *DifficultyUsecase) ProcessDifficultyData(difficulty int) (*models.UnityDifficultyMessage, error) {
	// difficultyに応じたクイズを3つ取得
	quizzes, err := u.quizRepo.FindByDifficulty(difficulty, 3)
	if err != nil {
		return nil, err
	}

	// difficultyに応じたアクションを取得
	action, err := u.actionRepo.FindOneByDifficulty(difficulty)
	if err != nil {
		return nil, err
	}

	// 3つの要素を持つquizIDsを作成
	quizIDs := make([]int, len(quizzes))
	for i, quiz := range quizzes {
		quizIDs[i] = quiz.ID
	}

	// Unityに向けたレスポンスであるUnityDifficultyMessageを作成
	return &models.UnityDifficultyMessage{
		QuizIDs:  quizIDs,
		ActionID: action.ID,
	}, nil
}

```

# ハンドラーの作成
実際にクライアントとデータのやり取りをするデータの形式の定義やWebSocket通信の管理をする．

WebSocketについてはこちらでもPythonバージョンで解説している．

https://qiita.com/JavaLangRuntimeException/items/cfc187e23ea08f855250

:::note info
**Websocketとは？**
Webにおいて異なるプラットフォーム間など双方向通信を低いリソース消費で行うためのプロトコル．

**HTTPとの違い**

HTTPはWeb通信といえば...という感じ．主にHTMLテンプレートを転送するためのプロトコル．
Websocketはサーバとクライアントが一度ハンドシェイクをする **(ステータスコード101(Switching Protocols)が返ってくる)** と、その後の通信を専用のプロトコルで通信する．これで低コストにてリアルタイム通信を実現している．

**ハンドシェイクとは**

クライアント側とサーバー側でコネクションを確立すること．HTTPやWebsocketはTCPを使っているため双方向の通信が確立されてからデータ通信を開始している．
> **TCP(Transmission Control Protocol)** 
1対1のセッションによる信頼性の高い通信を行うためのプロトコル．

>`補足`
>WebSocket は基本的には TCP プロトコル上に構築されている．これは TCP の提供する信頼性や順序保証の特性を活かして，確実なデータ転送を行うためである．WebSocket は，HTTP プロトコルを使用して接続を開始するが，接続が確立されると，プロトコルが WebSocket 専用のものに**アップグレード**される．

**なぜHTTPだといけないのか**

HTTPは1つのコネクションで1つのリクエストしか送ることができず，クライアント側からのみしかリクエストを送ることができない．また，クライアント側からのトリガーによって通信を開始することになるので即時性の通信を求めると高コストでの通信になってしまう．一応HTTPで非同期通信を実装することはできるがなんとか低コストで実現することができないものか...と考えられできたプロトコルがWebsocketである．

**Websocketのメリット**

一度コネクションを確立したあと，サーバとクライアントのどちらからも通信を行うことが可能で，そのコネクション上で通信し続ける．HTTPのように通信を開始するためにコネクションを確立する必要がない．

:::
```interfaces/handlers/difficulty_handler.go
package handlers

import (
	"your-module/domain/models"         // ドメインモデルをインポート（メッセージタイプなどを含む）
	"your-module/usecase"               // ビジネスロジックを処理するユースケース層をインポート
	"github.com/gorilla/mux"            // HTTPリクエストのルーティング用にmuxをインポート
	"github.com/gorilla/websocket"      // WebSocket接続を処理するためのwebsocketパッケージをインポート
	"net/http"
	"sync"
)

// DifficultyWebSocketHandlerは、AndroidおよびUnityクライアント間のWebSocket通信を処理するための
// WebSocket接続を保持し、関連するメソッドを提供する構造体です
type DifficultyWebSocketHandler struct {
	upgrader          websocket.Upgrader      // HTTP接続をWebSocket接続にアップグレードするためのアップグレーダ．上記の補足に書いてある通り、HTTPからWebSocketにアップグレードする通信が必要
	difficultyUsecase *usecase.DifficultyUsecase // 難易度データのビジネスロジックを処理するユースケース
	androidConns      map[string]*websocket.Conn // Androidクライアントの接続を保持するマップ
	unityConns        map[string]*websocket.Conn // Unityクライアントの接続を保持するマップ
	mutex             sync.RWMutex               // 並行処理で接続マップを保護するための排他制御
}

// NewDifficultyWebSocketHandlerは、DifficultyWebSocketHandlerの新しいインスタンスを作成します
func NewDifficultyWebSocketHandler(difficultyUsecase *usecase.DifficultyUsecase) *DifficultyWebSocketHandler {
	return &DifficultyWebSocketHandler{
		upgrader: websocket.Upgrader{
			CheckOrigin: func(r *http.Request) bool {
				return true // クロスオリジンのリクエストも許可(本番環境では非推奨)
			},
		},
		difficultyUsecase: difficultyUsecase,
		androidConns:      make(map[string]*websocket.Conn),
		unityConns:        make(map[string]*websocket.Conn),
	}
}

// HandleAndroidWebSocketは、Android側のWebSocket接続を処理します
func (h *DifficultyWebSocketHandler) HandleAndroidWebSocket(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	uuid := vars["uuid"]
	if uuid == "" {
		http.Error(w, "UUIDが必要です", http.StatusBadRequest)
		return
	}

	// Unity側の接続が存在するか確認
	h.mutex.RLock() // 排他制御を用いる(参照ロック)
	_, unityExists := h.unityConns[uuid] // unity側で接続済みのuuidを取得
	h.mutex.RUnlock() // 排他制御解除(参照ロック解除)

	if !unityExists {
		http.Error(w, "一致するUnity接続がありません", http.StatusBadRequest)
		return
	}

	// WebSocket接続へのアップグレードを試行(上の補足を参照）
	conn, err := h.upgrader.Upgrade(w, r, nil)
	if err != nil {
		http.Error(w, "接続をアップグレードできませんでした", http.StatusInternalServerError)
		return
	}

	// Android側の接続をマップに保存
	h.mutex.Lock()
	h.androidConns[uuid] = conn
	h.mutex.Unlock()

	// 関数終了時に接続を削除およびクローズ.Goのdeferは最後に実行する関数を表す文法
	defer func() {
		h.mutex.Lock()
		delete(h.androidConns, uuid)
		h.mutex.Unlock()
		conn.Close()
	}()

	// メッセージの受信と処理ループ
	for {
		var androidMsg models.AndroidDifficultyMessage
		err := conn.ReadJSON(&androidMsg) // Android側からのメッセージをJSONで受信
		if err != nil {
			break
		}

		// ユースケース層で難易度データを処理．difficultyに応じたクイズを3つ，アクションを1つ取得
		unityMsg, err := h.difficultyUsecase.ProcessDifficultyData(androidMsg.Difficulty)
		if err != nil {
			continue
		}

		// Unity側の接続にメッセージを送信
		h.mutex.RLock()
		if unityConn, exists := h.unityConns[uuid]; exists {
			err = unityConn.WriteJSON(unityMsg)
		}
		h.mutex.RUnlock()

		// Android側には受信確認メッセージを送信(デバック用)
		confirmMsg := map[string]string{"status": "received"}
		err = conn.WriteJSON(confirmMsg)
		if err != nil {
			continue
		}
	}
}

// HandleUnityWebSocketは、Unity側のWebSocket接続を処理します
func (h *DifficultyWebSocketHandler) HandleUnityWebSocket(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	uuid := vars["uuid"]
	if uuid == "" {
		http.Error(w, "UUIDが必要です", http.StatusBadRequest)
		return
	}

	// WebSocket接続へのアップグレードを試行.上記の補足を参照
	conn, err := h.upgrader.Upgrade(w, r, nil)
	if err != nil {
		http.Error(w, "接続をアップグレードできませんでした", http.StatusInternalServerError)
		return
	}

	// Unity側の接続をマップに保存
	h.mutex.Lock()
	h.unityConns[uuid] = conn
	h.mutex.Unlock()

	// 関数終了時に接続を削除およびクローズ
	defer func() {
		h.mutex.Lock()
		delete(h.unityConns, uuid)
		h.mutex.Unlock()
		conn.Close()
	}()

	// メッセージの受信ループ（内容は処理せずに接続維持）
	for {
		_, _, err := conn.ReadMessage()
		if err != nil {
			break
		}
	}
}


```

# main.goの実装
infrastructure，usecase，handlerを初期化したり，db接続を初期化したり，環境変数からデータを取得したり，ルーティングを定義する．
```main.go
package main

import (
	"your-module/domain/services"
	"your-module/infrastructure/persistence"
	"your-module/interfaces/handlers"
	"your-module/usecase"
	"fmt"
	"github.com/gorilla/mux"
	"github.com/joho/godotenv"
	"gorm.io/driver/postgres"
	"gorm.io/gorm"
	"log"
	"net/http"
	"os"
)

func main() {
	// データベース接続の初期化
	db, err := initDB()
	if err != nil {
		log.Fatal(err)
	}

	//quiz,action系の初期化
	quizRepo := persistence.NewQuizRepository(db)
	actionRepo := persistence.NewActionRepository(db)

	//difficulty系の初期化
	difficultyUsecase := usecase.NewDifficultyUsecase(quizRepo, actionRepo)
	difficultyHandler := handlers.NewDifficultyWebSocketHandler(difficultyUsecase)

	// ルーティング
	r := mux.NewRouter()
	r.HandleFunc("/ws/difficulty/android/{uuid}", difficultyHandler.HandleAndroidWebSocket)
	r.HandleFunc("/ws/difficulty/unity/{uuid}", difficultyHandler.HandleUnityWebSocket)

	log.Fatal(http.ListenAndServe(":8080", r))
}

// initDBは別ファイルの方がいいのかな\(´ω` \)
func initDB() (*gorm.DB, error) {
	// .envファイルの読み込み(.envファイルにはDATABASE_URLのみ記載していることを想定)
	if err := godotenv.Load(); err != nil {
		log.Printf("Warning: .env file not found")
	}

	// 環境変数から接続情報を取得
	dbURL := os.Getenv("DATABASE_URL")

	if dbURL == "" {
		return nil, fmt.Errorf("DATABASE_URL is not set")
	}

	log.Printf("Connecting to database with URL: %s", dbURL)

	// データベースに接続
	db, err := gorm.Open(postgres.Open(dbURL), &gorm.Config{})
	if err != nil {
		return nil, fmt.Errorf("failed to connect database: %w", err)
	}
	log.Printf("Connected to database")

	return db, nil
}

```

これで以下のコマンドを実行すればサーバーを立ち上げられ，リアルタイム通信が可能になる．
```bash
docker compose up
```

今回作成した同じUUIDを持った異なるプラットフォーム(デバイス)同士のリアルタイム通信システムはさまざまな用途があると思う．例えばダイレクトメッセージのロジック作成や，マッチング機能など使い道がたくさんある．つまり，複数のプラットフォームでペアリングした通信を実装する際に有用である．