Design Patterns の実践応用記録
Socket.IO Client Library をラップする際に直面した問題シナリオと適用したデザインパターン
Photo by Daniel McCullough
はじめに
この記事は実際の要件開発において、デザインパターンを用いて問題を解決した場面の記録です。内容は要件の背景、実際に直面した問題の場面（What?）、なぜパターンを適用して問題を解決するのか（Why?）、実装でどのように使用したか（How?）を含みます。最初から読むことをおすすめします。
本記事では、この要件を開発する際に直面した4つのシナリオと、それらを解決するために適用した7つのデザインパターンを紹介します。
背景
組織構造
敝社は今年、Feature Teams（複数）と Platform Team に分割しました。前者は主にユーザー側の要件を担当し、Platform Team は社内メンバーを対象としています。その中での仕事の一つは技術導入、インフラ整備、そしてシステム統合をしっかり行い、Feature Teams が開発を進めやすい環境を整えることです。
現在の要件
Feature Teams は、元々のメッセージ機能（ページに入ってAPIでメッセージデータを取得し、最新のメッセージを更新するにはリロードが必要）を、リアルタイム通信（最新メッセージをリアルタイムで受信し、メッセージ送信も可能）に変更する必要がありました。
Platform Team の仕事
Platform Team が重視しているのは、現在のリアルタイム通信のニーズだけでなく、長期的な構築と再利用性です。検討の結果、webSocket 双方向通信の仕組みは現代のアプリに不可欠であり、今回の要件以外にも今後多くの機会で利用されるため、人的リソースが許す限り、設計とインターフェース開発の支援に注力しています。
目標：
-
Pinkoi サーバーサイドと Socket.IO 通信、認証ロジックのラップ
-
Socket.IO の複雑な操作をラップし、Pinkoi のビジネスニーズに応じた拡張可能で使いやすいインターフェースを提供する
-
統一されたクロスプラットフォームインターフェース (Socket.IO の Android と iOS クライアントライブラリは機能やインターフェースが異なる)
-
Feature チームは Socket.IO の仕組みを理解する必要がない
-
Feature チームは複雑な接続状態を管理する必要がない
-
将来的に webSocket の双方向通信のニーズがあれば直接利用可能です
時間と人員：
-
iOS と Android にそれぞれ1名ずつ配置
-
開発期間：3週間
技術的詳細情報
Web、iOS、Android の三つのプラットフォームでこの機能をサポートします。WebSocket 双方向通信プロトコルを導入して実現し、バックエンドは直接 Socket.io サービスを使用する予定です。
まず最初に言いたいのは Socket != WebSocket です
Socket と WebSocket および技術的な詳細については、以下の2つの記事をご参照ください：
簡単に言うと：
Socket は TCP/UDP トランスポート層の抽象化されたインターフェースであり、WebSocket はアプリケーション層の通信プロトコルです。
Socket と WebSocket の関係は、犬とホットドッグの関係のように、全く関係ありません。
Socket.IO は Engine.IO の上にある抽象操作のラッパーであり、Engine.IO は WebSocket の利用をラップしています。各層は上下間の通信のみを担当し、貫通操作（例：Socket.IO が直接 WebSocket 接続を操作すること）は許可されていません。
Socket.IO/Engine.IO は基本的な WebSocket 接続に加えて、多くの便利な機能（例：オフラインイベント送信機能、HTTPリクエストに似た仕組み、Room/Group 機能など）を実装しています。
Platform Team の主な役割は、Socket.IO と Pinkoi サーバーサイド間のロジックを橋渡しし、上位の Feature Teams が機能開発を行う際に利用できるようにすることです。
Socket.IO Swift Client に問題あり
-
長期間更新されておらず（最新バージョンはまだ2019年）、メンテナンスされているかは不明です。
-
クライアントとサーバーの Socket.IO バージョンを揃える必要があります。サーバー側では
{allowEIO3: true}を追加するか、クライアント側で同じバージョンを.versionで指定してください。
そうしないと、いくら試しても接続できません。 -
命名規則やインターフェース、公式サンプルの多くが一致していません。
-
Socket.IO の公式サイトの例はすべて Web を対象としていますが、実際には Swift クライアントは公式サイトの機能をすべてサポートしているわけではありません。
今回の実装で、iOS ライブラリにはオフライン時のイベント送信機能が実装されていないことが判明しました。
（私たちは独自に実装していますので、続きをご覧ください）
Socket.IO を採用する前に、実装したい機能がサポートされているか必ずテストしてください。
Socket.IO Swift Client は Starscream WebSocket ライブラリをベースにしたラッパーであり、必要に応じて Starscream を直接使用できます。
背景情報の補足はここまでです。次に本題に入ります。
デザインパターン
デザインパターンとは、ソフトウェア設計におけるよくある問題の解決策に過ぎません。必ずしもデザインパターンを使わなければ開発できないわけではなく、すべての場面に適用できるわけでもありません。また、自分で新しいデザインパターンをまとめても問題ありません。
しかし、既存の設計パターン（The 23 Gang of Four Design Patterns）はソフトウェア設計の共通知識であり、XXXパターンと言えば誰もが対応するアーキテクチャの青写真を思い浮かべるため、詳しい説明は不要です。後のメンテナンスでも文脈が把握しやすく、業界で検証された手法なのでオブジェクト依存の問題を細かく検討する必要もあまりありません。適切な場面で適切なパターンを選ぶことで、コミュニケーションやメンテナンスのコストを下げ、開発効率を向上させることができます。
デザインパターンは組み合わせて使うことができますが、既存のデザインパターンを無理に改変したり、無理やり適用したり、分類に合わないパターン（例：責任連鎖パターンでオブジェクトを生成する）を適用することは推奨しません。そうすると、使用の意義を失い、後から引き継ぐ人に誤解を与える可能性があります。
本記事で取り上げるデザインパターン：
後でそれぞれの場面で何を使い、なぜ使ったのかを順番に説明します。
本記事はデザインパターンの応用に重点を置いており、Socket.IO の操作についてではありません。説明を簡単にするため、一部の例は省略しており、実際の Socket.IO ライブラリのラッピングには適用できません。
文字数の関係で、本記事では各デザインパターンの構造について詳しく説明しません。各パターンのリンクをクリックして構造を理解してから読み進めてください。
DemoコードはSwiftで記述します。
要求シナリオ 1.
何？
-
同じ Path を使って異なるページやオブジェクトが Connection を要求する際、同じオブジェクトを再利用できるようにする。
-
Connection は抽象インターフェースであり、Socket.IO オブジェクトに直接依存しないこと。
なぜ？
-
メモリ使用量と重複接続による時間および通信コストを削減する。
-
将来的に他のフレームワークに切り替える余地を残す。
どのように？
-
Singleton Pattern ：生成に関するパターンで、オブジェクトがただ一つのインスタンスしか持たないことを保証します。
-
Flyweight Pattern ：構造型パターンで、複数のオブジェクトが同じ状態を共有し、再利用することに基づいています。
-
Factory Pattern ：生成に関するパターンで、オブジェクト生成方法を抽象化し、外部から切り替え可能にします。
実際のケース使用：
-
Singletonパターン：
ConnectionManagerはアプリのライフサイクル中に一つだけ存在し、Connectionの取得操作を管理します。 -
Flyweightパターン：
ConnectionPoolはその名の通り、Connection の共有プールであり、このプールから統一的に Connection を取得します。その中のロジックには、URL Path が同じ場合は既にプールにある Connection を直接渡す処理が含まれます。
ConnectionHandlerはConnectionの外部操作および状態管理者として機能します。 -
Factoryパターン：
ConnectionFactoryは上記の Flyweightパターン と組み合わせて、プールに再利用可能なConnectionがない場合にこのファクトリーインターフェースを使って生成します。
import Combine
import Foundation
protocol Connection {
var url: URL {get}
var id: UUID {get}
init(url: URL)
func connect()
func disconnect()
func sendEvent(_ event: String)
func onEvent(_ event: String) -> AnyPublisher<Data?, Never>
}
protocol ConnectionFactory {
func create(url: URL) -> Connection
}
class ConnectionPool {
private let connectionFactory: ConnectionFactory
private var connections: [Connection] = []
init(connectionFactory: ConnectionFactory) {
self.connectionFactory = connectionFactory
}
func getOrCreateConnection(url: URL) -> Connection {
if let connection = connections.first(where: { $0.url == url }) {
return connection
} else {
let connection = connectionFactory.create(url: url)
connections.append(connection)
return connection
}
}
}
class ConnectionHandler {
private let connection: Connection
init(connection: Connection) {
self.connection = connection
}
func getConnectionUUID() -> UUID {
return connection.id
}
}
class ConnectionManager {
static let shared = ConnectionManager(connectionPool: ConnectionPool(connectionFactory: SIOConnectionFactory()))
private let connectionPool: ConnectionPool
private init(connectionPool: ConnectionPool) {
self.connectionPool = connectionPool
}
//
func requestConnectionHandler(url: URL) -> ConnectionHandler {
let connection = connectionPool.getOrCreateConnection(url: url)
return ConnectionHandler(connection: connection)
}
}
// Socket.IO 実装
class SIOConnection: Connection {
let url: URL
let id: UUID = UUID()
required init(url: URL) {
self.url = url
//
}
func connect() {
//
}
func disconnect() {
//
}
func sendEvent(_ event: String) {
//
}
func onEvent(_ event: String) -> AnyPublisher<Data?, Never> {
//
return PassthroughSubject<Data?, Never>().eraseToAnyPublisher()
}
}
class SIOConnectionFactory: ConnectionFactory {
func create(url: URL) -> Connection {
//
return SIOConnection(url: url)
}
}
//
print(ConnectionManager.shared.requestConnectionHandler(url: URL(string: "wss://pinkoi.com/1")!).getConnectionUUID().uuidString)
print(ConnectionManager.shared.requestConnectionHandler(url: URL(string: "wss://pinkoi.com/1")!).getConnectionUUID().uuidString)
print(ConnectionManager.shared.requestConnectionHandler(url: URL(string: "wss://pinkoi.com/2")!).getConnectionUUID().uuidString)
// 出力例:
// D99F5429-1C6D-4EB5-A56E-9373D6F37307
// D99F5429-1C6D-4EB5-A56E-9373D6F37307
// 599CF16F-3D7C-49CF-817B-5A57C119FE31
要求シナリオ 2.
何？
背景技術の詳細にあるように、Socket.IO Swift Client の Send Event はオフライン送信をサポートしていません（しかし Web/Android 版のライブラリは対応しています）。そのため、iOS 側でこの機能を独自に実装する必要があります。
驚くべきことに、Socket.IO Swift Client の onEvent はオフライン購読をサポートしています。
なぜ？
-
クロスプラットフォーム機能の統一
-
コードは理解しやすいです
どのように？
- Command Pattern ：振る舞いパターンの一つで、操作をオブジェクトとしてカプセル化し、キューイング、遅延実行、キャンセルなどの一括操作を可能にします。
- Command Pattern：
SIOManagerは Socket.IO と通信する最下層のラッパーであり、その中のsend、requestメソッドはすべて Socket.IO の送信イベント操作です。現在の Socket.IO が切断状態の場合、リクエストパラメータをbufferedCommandsに格納し、接続後に順番に処理します（先入れ先出し）。
protocol BufferedCommand {
var sioManager: SIOManagerSpec? { get set }
var event: String { get }
func execute()
}
struct SendBufferedCommand: BufferedCommand {
let event: String
weak var sioManager: SIOManagerSpec?
func execute() {
sioManager?.send(event)
}
}
struct RequestBufferedCommand: BufferedCommand {
let event: String
let callback: (Data?) -> Void
weak var sioManager: SIOManagerSpec?
func execute() {
sioManager?.request(event, callback: callback)
}
}
protocol SIOManagerSpec: AnyObject {
func connect()
func disconnect()
func onEvent(event: String, callback: @escaping (Data?) -> Void)
func send(_ event: String)
func request(_ event: String, callback: @escaping (Data?) -> Void)
}
enum ConnectionState {
case created
case connected
case disconnected
case reconnecting
case released
}
class SIOManager: SIOManagerSpec {
var state: ConnectionState = .disconnected {
didSet {
if state == .connected {
executeBufferedCommands()
}
}
}
private var bufferedCommands: [BufferedCommand] = []
func connect() {
state = .connected
}
func disconnect() {
state = .disconnected
}
func send(_ event: String) {
guard state == .connected else {
appendBufferedCommands(connectionCommand: SendBufferedCommand(event: event, sioManager: self))
return
}
print("Send:\(event)")
}
func request(_ event: String, callback: @escaping (Data?) -> Void) {
guard state == .connected else {
appendBufferedCommands(connectionCommand: RequestBufferedCommand(event: event, callback: callback, sioManager: self))
return
}
print("request:\(event)")
}
func onEvent(event: String, callback: @escaping (Data?) -> Void) {
//
}
func appendBufferedCommands(connectionCommand: BufferedCommand) {
bufferedCommands.append(connectionCommand)
}
func executeBufferedCommands() {
// 先入れ先出し
bufferedCommands.forEach { connectionCommand in
connectionCommand.execute()
}
bufferedCommands.removeAll()
}
func removeAllBufferedCommands() {
bufferedCommands.removeAll()
}
}
let manager = SIOManager()
manager.send("send_event_1")
manager.send("send_event_2")
manager.request("request_event_1") { _ in
//
}
manager.state = .connected
同様に onEvent にも実装できます。
拡張：Buffer 機能を一種の Proxy として扱い、Proxy Pattern を適用することも可能です。
要求シナリオ 3.
何？
Connection は複数の状態を持ち、状態間の切り替えは順序立てられており、各状態で許可される操作が異なります。
-
Created：オブジェクトが作成され、
Connectedまたは直接Disconnectedに遷移可能 -
Connected：Socket.IOに接続済み、許可される遷移 ->
Disconnected -
Disconnected：Socket.IOとの接続が切断されました。許可される状態遷移は
Reconnectiong、Releasedです。 -
Reconnectiong：Socket.IOへの再接続を試みています。状態遷移は
ConnectedまたはDisconnectedを許可します。 -
Released：オブジェクトはメモリ解放待ちとしてマークされており、操作や状態の切り替えは許可されていません。
なぜ？
-
状態と状態の切り替えロジックおよび表現は難しいです。
-
各状態で操作メソッドを制限する必要がある場合（例：State = Released の時は Send Event を呼び出せない）、直接 if..else を使うとコードの保守性や可読性が低下します。
どのように？
-
有限状態機械 ：状態遷移を管理する
-
State Pattern ：オブジェクトの状態に応じて振る舞いを変えるパターン
-
Finite State Machine ：
SIOConnectionStateMachineは状態機の実装で、currentSIOConnectionStateは現在の状態を示します。created、connected、disconnected、reconnecting、releasedはこの状態機で可能な状態遷移を列挙しています。
enterXXXState() throwsは現在の状態から特定の状態に入る際の許可・不許可（エラーを投げる）を実装しています。 -
State Pattern ：
SIOConnectionStateはすべての状態で使用される操作メソッドのインターフェース抽象です。
protocol SIOManagerSpec: AnyObject {
func connect()
func disconnect()
func onEvent(event: String, callback: @escaping (Data?) -> Void)
func send(_ event: String)
func request(_ event: String, callback: @escaping (Data?) -> Void)
}
enum ConnectionState {
case created
case connected
case disconnected
case reconnecting
case released
}
class SIOManager: SIOManagerSpec {
var state: ConnectionState = .disconnected {
didSet {
if state == .connected {
executeBufferedCommands()
}
}
}
private var bufferedCommands: [BufferedCommand] = []
func connect() {
state = .connected
}
func disconnect() {
state = .disconnected
}
func send(_ event: String) {
guard state == .connected else {
appendBufferedCommands(connectionCommand: SendBufferedCommand(event: event, sioManager: self))
return
}
print("Send:\(event)")
}
func request(_ event: String, callback: @escaping (Data?) -> Void) {
guard state == .connected else {
appendBufferedCommands(connectionCommand: RequestBufferedCommand(event: event, callback: callback, sioManager: self))
return
}
print("request:\(event)")
}
func onEvent(event: String, callback: @escaping (Data?) -> Void) {
//
}
func appendBufferedCommands(connectionCommand: BufferedCommand) {
bufferedCommands.append(connectionCommand)
}
func executeBufferedCommands() {
// 先入れ先出し
bufferedCommands.forEach { connectionCommand in
connectionCommand.execute()
}
bufferedCommands.removeAll()
}
func removeAllBufferedCommands() {
bufferedCommands.removeAll()
}
}
let manager = SIOManager()
manager.send("send_event_1")
manager.send("send_event_2")
manager.request("request_event_1") { _ in
//
}
manager.state = .connected
//
class SIOConnectionStateMachine {
private(set) var currentSIOConnectionState: SIOConnectionState!
private var created: SIOConnectionState!
private var connected: SIOConnectionState!
private var disconnected: SIOConnectionState!
private var reconnecting: SIOConnectionState!
private var released: SIOConnectionState!
init() {
self.created = SIOConnectionCreatedState(stateMachine: self)
self.connected = SIOConnectionConnectedState(stateMachine: self)
self.disconnected = SIOConnectionDisconnectedState(stateMachine: self)
self.reconnecting = SIOConnectionReconnectingState(stateMachine: self)
self.released = SIOConnectionReleasedState(stateMachine: self)
self.currentSIOConnectionState = created
}
func enterConnected() throws {
if [created.connectionState, reconnecting.connectionState].contains(currentSIOConnectionState.connectionState) {
enter(connected)
} else {
throw SIOConnectionStateMachineError("\(currentSIOConnectionState.connectionState) は Connected に遷移できません")
}
}
func enterDisconnected() throws {
if [created.connectionState, connected.connectionState, reconnecting.connectionState].contains(currentSIOConnectionState.connectionState) {
enter(disconnected)
} else {
throw SIOConnectionStateMachineError("\(currentSIOConnectionState.connectionState) は Disconnected に遷移できません")
}
}
func enterReconnecting() throws {
if [disconnected.connectionState].contains(currentSIOConnectionState.connectionState) {
enter(reconnecting)
} else {
throw SIOConnectionStateMachineError("\(currentSIOConnectionState.connectionState) は Reconnecting に遷移できません")
}
}
func enterReleased() throws {
if [disconnected.connectionState].contains(currentSIOConnectionState.connectionState) {
enter(released)
} else {
throw SIOConnectionStateMachineError("\(currentSIOConnectionState.connectionState) は Released に遷移できません")
}
}
private func enter(_ state: SIOConnectionState) {
currentSIOConnectionState = state
}
}
protocol SIOConnectionState {
var connectionState: ConnectionState { get }
var stateMachine: SIOConnectionStateMachine { get }
init(stateMachine: SIOConnectionStateMachine)
func onConnected() throws
func onDisconnected() throws
func connect(socketManager: SIOManagerSpec) throws
func disconnect(socketManager: SIOManagerSpec) throws
func release(socketManager: SIOManagerSpec) throws
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws
func send(socketManager: SIOManagerSpec, event: String) throws
}
struct SIOConnectionStateMachineError: Error {
let message: String
init(_ message: String) {
self.message = message
}
var localizedDescription: String {
return message
}
}
class SIOConnectionCreatedState: SIOConnectionState {
let connectionState: ConnectionState = .created
let stateMachine: SIOConnectionStateMachine
required init(stateMachine: SIOConnectionStateMachine) {
self.stateMachine = stateMachine
}
func onConnected() throws {
try stateMachine.enterConnected()
}
func onDisconnected() throws {
try stateMachine.enterDisconnected()
}
func release(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("CreatedState は release できません！")
}
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func send(socketManager: SIOManagerSpec, event: String) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func connect(socketManager: SIOManagerSpec) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func disconnect(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("CreatedState は disconnect できません！")
}
}
class SIOConnectionConnectedState: SIOConnectionState {
let connectionState: ConnectionState = .connected
let stateMachine: SIOConnectionStateMachine
required init(stateMachine: SIOConnectionStateMachine) {
self.stateMachine = stateMachine
}
func onConnected() throws {
//
}
func onDisconnected() throws {
try stateMachine.enterDisconnected()
}
func release(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ConnectedState は release できません！")
}
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func send(socketManager: SIOManagerSpec, event: String) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func connect(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ConnectedState は connect できません！")
}
func disconnect(socketManager: SIOManagerSpec) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
}
class SIOConnectionDisconnectedState: SIOConnectionState {
let connectionState: ConnectionState = .disconnected
let stateMachine: SIOConnectionStateMachine
required init(stateMachine: SIOConnectionStateMachine) {
self.stateMachine = stateMachine
}
func onConnected() throws {
try stateMachine.enterConnected()
}
func onDisconnected() throws {
//
}
func release(socketManager: SIOManagerSpec) throws {
try stateMachine.enterReleased()
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func send(socketManager: SIOManagerSpec, event: String) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func connect(socketManager: SIOManagerSpec) throws {
try stateMachine.enterReconnecting()
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func disconnect(socketManager: SIOManagerSpec) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
}
class SIOConnectionReconnectingState: SIOConnectionState {
let connectionState: ConnectionState = .reconnecting
let stateMachine: SIOConnectionStateMachine
required init(stateMachine: SIOConnectionStateMachine) {
self.stateMachine = stateMachine
}
func onConnected() throws {
try stateMachine.enterConnected()
}
func onDisconnected() throws {
try stateMachine.enterDisconnected()
}
func release(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ReconnectState は release できません！")
}
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func send(socketManager: SIOManagerSpec, event: String) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
func connect(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ReconnectState は connect できません！")
}
func disconnect(socketManager: SIOManagerSpec) throws {
// 許可
// 繰り返しコードを減らすために Helper を使うことができる
// 例: helper.XXX(socketManager: SIOManagerSpec, ....)
}
}
class SIOConnectionReleasedState: SIOConnectionState {
let connectionState: ConnectionState = .released
let stateMachine: SIOConnectionStateMachine
required init(stateMachine: SIOConnectionStateMachine) {
self.stateMachine = stateMachine
}
func onConnected() throws {
throw SIOConnectionStateMachineError("ReleasedState は onConnected できません！")
}
func onDisconnected() throws {
throw SIOConnectionStateMachineError("ReleasedState は onDisconnected できません！")
}
func release(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ReleasedState は release できません！")
}
func request(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
throw SIOConnectionStateMachineError("ReleasedState は request できません！")
}
func onEvent(socketManager: SIOManagerSpec, event: String, callback: @escaping (Data?) -> Void) throws {
throw SIOConnectionStateMachineError("ReleasedState は receiveOn できません！")
}
func send(socketManager: SIOManagerSpec, event: String) throws {
throw SIOConnectionStateMachineError("ReleasedState は send できません！")
}
func connect(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ReleasedState は connect できません！")
}
func disconnect(socketManager: SIOManagerSpec) throws {
throw SIOConnectionStateMachineError("ReleasedState は disconnect できません！")
}
}
do {
let stateMachine = SIOConnectionStateMachine()
// socket.io 接続時のモック:
// socketIO.on(connect){
try stateMachine.currentSIOConnectionState.onConnected()
try stateMachine.currentSIOConnectionState.send(socketManager: manager, event: "test")
try stateMachine.currentSIOConnectionState.release(socketManager: manager)
try stateMachine.currentSIOConnectionState.send(socketManager: manager, event: "test")
// }
} catch {
print("error: \(error)")
}
// 出力:
// error: SIOConnectionStateMachineError(message: "ConnectedState は release できません！")
要求シナリオ 3.
何？
シナリオ1と2を組み合わせて、ConnectionPoolというフライウェイトプールとState Patternによる状態管理を導入しました。その上で、背景の目標にあるように、Feature側が背後のConnectionの接続メカニズムを意識しなくて済むように、定期的にConnectionPool内の強参照しているConnectionをスキャンするポーリング機能（ConnectionKeeperと命名）を作成し、以下の状況が発生した際に操作を行います：
-
Connectionが使用中で状態がConnectedでない場合：状態をReconnectingに変更し、再接続を試みる -
Connectionが未使用で状態がConnectedの場合：状態をDisconnectedに変更する -
Connectionが未使用かつ状態がDisconnectedの場合：状態をReleasedに変更し、ConnectionPoolから削除する
なぜ？
-
3つの操作は上下関係があり、相互排他です（disconnected -> released または reconnecting）
-
状態操作を柔軟に差し替え・追加可能
-
未封装の場合は、3つの判定と操作を直接メソッド内に書くしかなく（ロジックのテストが難しい）
-
例：
if !connection.isOccupie() && connection.state == .connected then
... connection.disconnected() // 切断する
else if !connection.isOccupie() && state == .released then
... connection.release() // 解放する
else if connection.isOccupie() && state == .disconnected then
... connection.reconnecting() // 再接続する
end
どのように？
- Chain Of Resposibility ：振る舞いパターンで、その名の通りチェーン状になっており、各ノードが対応する処理を持ちます。入力データを受け取ったノードは処理を行うか、次のノードに渡すかを決定します。もう一つの実例はiOS Responder Chainです。
定義によると、Chain of Responsibilityパターンでは、あるノードがすでにデータの処理を引き受けた場合、処理を完了する前に次のノードに渡すことは許されない。やるなら最後までやる、そうでなければやらない。
もし上記のシナリオに適しているのは Interceptor Pattern だと思います。
- Chain of responsibility：
ConnectionKeeperHandlerはチェーンのノードの抽象であり、特にcanExcuteメソッドを分離して、上記の「このノードが処理した後に、さらに後続のノードを呼び出して処理を続ける」状況を防いでいます。handleはチェーンのノードの連結、excuteは処理すべきロジックを示します。
ConnectionKeeperHandlerContextは使用するデータを格納し、isOccupieは Connection が使用中かどうかを表します。
enum ConnectionState {
case created // 作成済み
case connected // 接続済み
case disconnected // 切断済み
case reconnecting // 再接続中
case released // 解放済み
}
protocol Connection {
var connectionState: ConnectionState {get}
var url: URL {get}
var id: UUID {get}
init(url: URL)
func connect()
func reconnect()
func disconnect()
func sendEvent(_ event: String)
func onEvent(_ event: String) -> AnyPublisher<Data?, Never>
}
// Socket.IO 実装
class SIOConnection: Connection {
let connectionState: ConnectionState = .created
let url: URL
let id: UUID = UUID()
required init(url: URL) {
self.url = url
//
}
func connect() {
//
}
func disconnect() {
//
}
func reconnect() {
//
}
func sendEvent(_ event: String) {
//
}
func onEvent(_ event: String) -> AnyPublisher<Data?, Never> {
//
return PassthroughSubject<Data?, Never>().eraseToAnyPublisher()
}
}
//
struct ConnectionKeeperHandlerContext {
let connection: Connection
let isOccupie: Bool // 使用中かどうか
}
protocol ConnectionKeeperHandler {
var nextHandler: ConnectionKeeperHandler? { get set }
func handle(context: ConnectionKeeperHandlerContext)
func execute(context: ConnectionKeeperHandlerContext)
func canExcute(context: ConnectionKeeperHandlerContext) -> Bool
}
extension ConnectionKeeperHandler {
func handle(context: ConnectionKeeperHandlerContext) {
if canExcute(context: context) {
execute(context: context)
} else {
nextHandler?.handle(context: context)
}
}
}
class DisconnectedConnectionKeeperHandler: ConnectionKeeperHandler {
var nextHandler: ConnectionKeeperHandler?
func execute(context: ConnectionKeeperHandlerContext) {
context.connection.disconnect()
}
func canExcute(context: ConnectionKeeperHandlerContext) -> Bool {
if context.connection.connectionState == .connected && !context.isOccupie {
return true
}
return false
}
}
class ReconnectConnectionKeeperHandler: ConnectionKeeperHandler {
var nextHandler: ConnectionKeeperHandler?
func execute(context: ConnectionKeeperHandlerContext) {
context.connection.reconnect()
}
func canExcute(context: ConnectionKeeperHandlerContext) -> Bool {
if context.connection.connectionState == .disconnected && context.isOccupie {
return true
}
return false
}
}
class ReleasedConnectionKeeperHandler: ConnectionKeeperHandler {
var nextHandler: ConnectionKeeperHandler?
func execute(context: ConnectionKeeperHandlerContext) {
context.connection.disconnect()
}
func canExcute(context: ConnectionKeeperHandlerContext) -> Bool {
if context.connection.connectionState == .disconnected && !context.isOccupie {
return true
}
return false
}
}
let connection = SIOConnection(url: URL(string: "wss://pinkoi.com")!)
let disconnectedHandler = DisconnectedConnectionKeeperHandler()
let reconnectHandler = ReconnectConnectionKeeperHandler()
let releasedHandler = ReleasedConnectionKeeperHandler()
disconnectedHandler.nextHandler = reconnectHandler
reconnectHandler.nextHandler = releasedHandler
disconnectedHandler.handle(context: ConnectionKeeperHandlerContext(connection: connection, isOccupie: false))
要求シナリオ 4.
何？
私たちがラップした Connection は、使用前に setup を経る必要があります。例えば、URL Path の指定や Config の設定などです。
なぜ？
-
構築のインターフェースを柔軟に増減可能
-
再利用可能な構築ロジック
-
ラップしていない場合、外部がクラスを期待通りに操作しない可能性があります。
-
例：
❌
let connection = Connection()
connection.send(event) // 予期しないメソッド呼び出し、先に.connect()を呼ぶべき
✅
let connection = Connection()
connection.connect()
connection.send(event)
// しかし…誰が知っているだろう？？？
どのように？
- Builder Pattern ：オブジェクトを段階的に構築し、構築手順を再利用できる生成に関するパターンです。
- Builderパターン：
SIOConnectionBuilderはConnectionのビルダーであり、Connectionを構築する際に使用するデータの設定と保持を担当します。ConnectionConfiguration抽象インターフェースは、Connectionを使用する前に必ず.connect()を呼び出してConnectionの実体を取得することを保証します。
enum ConnectionState {
case created // 作成済み
case connected // 接続済み
case disconnected // 切断済み
case reconnecting // 再接続中
case released // 解放済み
}
protocol Connection {
var connectionState: ConnectionState {get}
var url: URL {get}
var id: UUID {get}
init(url: URL)
func connect()
func reconnect()
func disconnect()
func sendEvent(_ event: String)
func onEvent(_ event: String) -> AnyPublisher<Data?, Never>
}
// Socket.IO 実装
class SIOConnection: Connection {
let connectionState: ConnectionState = .created
let url: URL
let id: UUID = UUID()
required init(url: URL) {
self.url = url
//
}
func connect() {
//
}
func disconnect() {
//
}
func reconnect() {
//
}
func sendEvent(_ event: String) {
//
}
func onEvent(_ event: String) -> AnyPublisher<Data?, Never> {
//
return PassthroughSubject<Data?, Never>().eraseToAnyPublisher()
}
}
//
class SIOConnectionClient: ConnectionConfiguration {
private let url: URL
private let config: [String: Any]
init(url: URL, config: [String: Any]) {
self.url = url
self.config = config
}
func connect() -> Connection {
// 設定をセット
return SIOConnection(url: url)
}
}
protocol ConnectionConfiguration {
func connect() -> Connection
}
class SIOConnectionBuilder {
private(set) var config: [String: Any] = [:]
func setConfig(_ config: [String: Any]) -> SIOConnectionBuilder {
self.config = config
return self
}
// url は必須パラメータ
func build(url: URL) -> ConnectionConfiguration {
return SIOConnectionClient(url: url, config: self.config)
}
}
let builder = SIOConnectionBuilder().setConfig(["test":123])
let connection1 = builder.build(url: URL(string: "wss://pinkoi.com/1")!).connect()
let connection2 = builder.build(url: URL(string: "wss://pinkoi.com/1")!).connect()
拡張：ここでも Factory Pattern を適用して、工場で SIOConnection を生成できます。
完結！
以上が今回の Socket.IO 封装で直面した4つのシナリオと7つの問題解決に使われたデザインパターンです。
最後に今回の Socket.IO 封装の完全な設計図を添付します
本文中の命名や例示とは少し異なりますが、この図が実際の設計構造です；機会があれば、元設計者に設計理念やオープンソースについて共有してもらいたいです。
誰が？
これらの設計を行い、Socket.IOのラッピングプロジェクトを担当したのは誰ですか？
Sean Zheng 、PinkoiのAndroidエンジニア
主なアーキテクチャ設計者、デザインパターンの評価と適用、Android側でKotlinを使った設計の実装。
ZhgChgLi , エンジニアリード / iOSエンジニア @ Pinkoi
Platform Team プロジェクトリーダー、ペアプログラミング、iOS 側で Swift を使った設計・実装、議論や疑問提起（いわゆる口だけ参加）、そして最後にこの記事を執筆して皆さんと共有。
関連記事
Post MediumからZMediumToMarkdownで変換しました。
コメント