Go における Adapter パターンの基本概念と実装方法を解説。異なるインターフェースを統一し、既存のコードを変更せずに活用する方法を具体例を交えて紹介します。

Go における Adapter パターン - インターフェースの適用と統一

ソフトウェア開発では、異なるインターフェースを持つコンポーネント同士を統一的に扱いたい場面があります。そのような場合に役立つのが Adapter（アダプター）パターン です。
本記事では、Adapter パターンの基本概念を理解しつつ、Go 言語での具体的な実装方法を紹介します。
<h2 id="adapter-パターン">Adapter パターン</h2>
Adapter パターンは、「あるインターフェースを、別のインターフェースに適用させる」ためのデザインパターンです。既存のコードを変更せずに、新しいインターフェースで利用できるようにするのが特徴です。
Adapter パターンを適用すると、既存のコードを変更せずに新しい規格で利用可能にしたり、異なるライブラリや API を統一できたり、古いシステムと新しいシステムをつないだりできます。
<h3 id="adapter-パターンのイメージ">Adapter パターンのイメージ</h3>
Adapter パターンの考え方を、日常的な例に当てはめると「海外のコンセントと変換プラグ」がわかりやすいです。
<ul>
<li>日本の電化製品（100V, Aタイプのプラグ） を ヨーロッパのコンセント（220V, Cタイプのソケット） に挿したい。</li>
<li>直接は使えないので 変換プラグ（アダプター） を使う。</li>
</ul>
このように、異なる規格を持つものを適用させるのが Adapter パターンの役割です。
<h2 id="go-における-adapter-パターンの実装">Go における Adapter パターンの実装</h2>
先ほどイメージしたプラグを実装に落とし込んでみます。
<h3 id="1-既存のインターフェース日本の電化製品">1. 既存のインターフェース（日本の電化製品）</h3>
日本の電化製品は A タイプのプラグを使用し、日本の 100V のコンセントに接続することを前提としています。以下の実装では、日本の電化製品である <code>JapaneseDevice</code> 構造体が <code>JapanPlug</code> インターフェースを実装しており、<code>InsertIntoJapanSocket()</code> メソッドを持っています。つまりこの電化製品は、日本の規格で使われることを前提としている実装になっています。
<pre><code class="hljs language-go">package main

import "fmt"

// JapanPlug 日本の電化製品のインターフェース
type JapanPlug interface {
 InsertIntoJapanSocket()
}

// JapaneseDevice 日本の電化製品
type JapaneseDevice struct{}

func (d *JapaneseDevice) InsertIntoJapanSocket() {
 fmt.Println("コンセントに接続しました。")
}
</code></pre>
<h3 id="2-新しいインターフェースヨーロッパのコンセント">2. 新しいインターフェース（ヨーロッパのコンセント）</h3>
一方でヨーロッパのコンセントは C タイプのプラグ を使用し、220V の電圧で動作します。以下のインターフェース <code>EuropePlug</code> は、ヨーロッパの電化製品が <code>InsertIntoEuropeSocket()</code> を実装することを前提としています。
<pre><code class="hljs language-go">// EuropePlug ヨーロッパの電化製品のインターフェース
type EuropePlug interface {
 InsertIntoEuropeSocket()
}
</code></pre>
つまり、日本の電化製品（JapaneseDevice構造体）では、プラグの形状が違う（EuropePlug インターフェースを実装していない）ので、ヨーロッパのコンセントには接続できないわけですね。
<h3 id="3-アダプター変換プラグ">3. アダプター（変換プラグ）</h3>
ここで変換プラグの出番です。以下に定義した構造体 <code>PlugAdapter</code> は <code>EuropePlug</code> を実装しつつ、日本の電化製品 (<code>JapaneseDevice</code>) を内部で使用します。<code>InsertIntoEuropeSocket()</code> が呼ばれると、<code>JapaneseDevice.InsertIntoJapanSocket()</code> を内部で実行し、日本の電化製品がヨーロッパのコンセントで使えるようになります。
<pre><code class="hljs language-go">// PlugAdapter EuropePlug を JapanPlug に適合させる
type PlugAdapter struct {
 JapaneseDevice *JapaneseDevice
}

// InsertIntoEuropeSocket EuropePlug のインターフェースを満たす
func (pa *PlugAdapter) InsertIntoEuropeSocket() {
 fmt.Println("変換プラグを使用中...")
 pa.JapaneseDevice.InsertIntoJapanSocket()
}
</code></pre>
<h3 id="4-変換プラグを使って日本の電化製品をヨーロッパで使用する">4. 変換プラグを使って日本の電化製品をヨーロッパで使用する</h3>
この <code>PlugAdapter</code> を使用することで、日本の電化製品をヨーロッパのコンセントに適用させることができます。
<pre><code class="hljs language-go">func main() {
 japanDevice := &#x26;JapaneseDevice{}
 adapter := &#x26;PlugAdapter{JapaneseDevice: japanDevice}

 // ヨーロッパのコンセント（EuropePlug）のインターフェースで、日本の電化製品を使う
 adapter.InsertIntoEuropeSocket()
}

// 変換プラグを使用中...
// コンセントに接続しました。
</code></pre>
このように、Adapter パターンを利用することで、本来互換性のないインターフェース同士を橋渡しし、異なる規格のものを統一的に扱えるようになります。まるで通訳が異なる言語を話す人々の間を取り持つように、Adapter は異なるインターフェースの間でデータのやり取りを可能にします。Go における Adapter パターンの実装では、特定のインターフェースに適合しない既存の構造体を、新しい環境で使えるように変換する仕組みを提供することで、コードの再利用性と柔軟性を向上させることができます。
<h2 id="adapter-パターンの実践例-ロギングライブラリの統一">Adapter パターンの実践例: ロギングライブラリの統一</h2>
Adapter パターンは、異なるインターフェースを統一するために非常に便利です。実際の開発では、異なるライブラリや外部 API を統一的に扱いたい状況があるかもしれません。例えば、Go には Logrus や Zap など複数のロギングライブラリがあり、それぞれ異なる API を持っています。




















<table><thead><tr><th>ロギングライブラリ</th><th>メソッド名の違い</th><th>使い方の違い</th></tr></thead><tbody><tr><td><code>Logrus</code></td><td><code>Info(message string)</code></td><td>直接メソッドを呼び出す</td></tr><tr><td><code>Zap</code></td><td><code>Log(level string, message string)</code></td><td>ログレベルを引数で指定する</td></tr></tbody></table>
例: Logrus のコード
<pre><code class="hljs language-go">logrus := LogrusLogger{}
logrus.Info("アプリケーションが起動しました")
logrus.Error("エラーが発生しました")
</code></pre>
例: Zap のコード
<pre><code class="hljs language-go">zap := ZapLogger{}
zap.Log("INFO", "アプリケーションが起動しました")
zap.Log("ERROR", "エラーが発生しました")
</code></pre>
このままでは、アプリケーションで異なるロガーを利用する際に、コードの変更が必要になります。そこで、Adapter パターンを使って両者を統一し、共通のインターフェースで扱えるようにします。
<h3 id="1-共通のインターフェースの定義">1. 共通のインターフェースの定義</h3>
まず、すべてのロギングライブラリを統一する 共通のインターフェース <code>Logger</code> を定義します。
<pre><code class="hljs language-go">// Logger 共通のロギングインターフェース
type Logger interface {
 Info(message string)
 Error(message string)
}
</code></pre>
<h3 id="2-既存のロギングライブラリの実装">2. 既存のロギングライブラリの実装</h3>
次に、異なるロギングライブラリを定義します。
<pre><code class="hljs language-go">package main

import "fmt"

// LogrusLogger ログライブラリ A の実装
type LogrusLogger struct{}

func (l *LogrusLogger) Info(message string) {
 fmt.Println("[Logrus INFO]:", message)
}

func (l *LogrusLogger) Error(message string) {
 fmt.Println("[Logrus ERROR]:", message)
}

// ZapLogger ログライブラリ B の実装
type ZapLogger struct{}

func (z *ZapLogger) Log(level string, message string) {
 fmt.Printf("[Zap %s]: %s\n", level, message)
}
</code></pre>
<h3 id="3-adapter-の実装">3. Adapter の実装</h3>
各ロギングライブラリを <code>Logger</code> インターフェースに適合させる Adapter を実装します。
<pre><code class="hljs language-go">// LogrusAdapter Logrus を共通インターフェースに適用
type LogrusAdapter struct {
 logrus *LogrusLogger
}

func (l *LogrusAdapter) Info(message string) {
 l.logrus.Info(message)
}

func (l *LogrusAdapter) Error(message string) {
 l.logrus.Error(message)
}

// ZapAdapter Zap を共通インターフェースに適用
type ZapAdapter struct {
 zap *ZapLogger
}

func (z *ZapAdapter) Info(message string) {
 z.zap.Log("INFO", message)
}

func (z *ZapAdapter) Error(message string) {
 z.zap.Log("ERROR", message)
}
</code></pre>
<h3 id="4-adapter-を利用する">4. Adapter を利用する</h3>
Adapter を利用すると、異なるロギングライブラリを <code>Logger</code> インターフェースを通じて統一的に扱うことができます。
<pre><code class="hljs language-go">func main() {
 // 異なるログシステムを統一
 logrusAdapter := &#x26;LogrusAdapter{logrus: &#x26;LogrusLogger{}}
 zapAdapter := &#x26;ZapAdapter{zap: &#x26;ZapLogger{}}

 // 共通の Logger インターフェースを利用
 loggers := []Logger{logrusAdapter, zapAdapter}

 for _, logger := range loggers {
 logger.Info("アプリケーションが起動しました")
 logger.Error("エラーが発生しました")
 }
}
</code></pre>
出力結果:
<pre><code class="hljs language-console">[Logrus INFO]: アプリケーションが起動しました
[Logrus ERROR]: エラーが発生しました
[Zap INFO]: アプリケーションが起動しました
[Zap ERROR]: エラーが発生しました
</code></pre>
このように、Adapter パターンを使うことで 異なるロギングライブラリの API を統一し、アプリケーションのコードを変更せずに扱えるようになりました。
<ul>
<li>Adapter パターンを使うことで、異なるロギングライブラリの API を統一できた</li>
<li>Logger インターフェースを定義し、LogrusAdapter と ZapAdapter を実装することで、異なるライブラリを一貫した方法で扱えるようになった</li>
<li>Adapter パターンを適用することで、アプリケーションのコードを変更せずにロギングライブラリを差し替えたり、追加したりできる</li>
</ul>
<h2 id="まとめ">まとめ</h2>
Adapter パターンの基本概念と Go における実装方法をご紹介しました。Adapter パターンを適用すると、互換性のないインターフェースを統一し、異なるシステムやライブラリを柔軟に扱うことが可能になります。実際の開発では、外部 API の統一やライブラリの置き換えなど、多くの場面で活用できます。
より柔軟でメンテナブルなコードを実現していきたいですね。

Author