観察者パターン

ソフトウェア設計およびソフトウェアエンジニアリングにおいて、オブザーバーパターンとは、サブジェクト（イベントソースまたはイベントストリームとも呼ばれる）と呼ばれるオブジェクトが、オブザーバー（イベントシンクとも呼ばれる）と呼ばれる依存オブジェクトのリストを保持し、状態の変化を自動的に通知するソフトウェア設計パターンです。通知は通常、オブザーバーのメソッドを呼び出すことによって行われます。サブジェクトは標準化されたインターフェースを通じてオブザーバーを認識し、購読リストを直接管理します。

このパターンでは、複数のオブザーバーが単一のサブジェクトを監視できる一対多の依存関係が構築されますが、結合は通常同期かつ直接的です。つまり、サブジェクトは変更が発生した際にオブザーバーのメソッドを呼び出しますが、イベントキューを使用した非同期実装も可能です。パブリッシュ/サブスクライブパターンとは異なり、仲介者は存在せず、サブジェクトとオブザーバーは互いに直接参照を持ちます。

これは、イベント駆動型プログラミング、特にGUIツールキットやMVCフレームワークなどのプロセス内システムにおいて、イベント処理システムを実装するためによく用いられます。そのため、ユーザー入力、HTTPリクエスト、GPIO信号、分散データベースからの更新、 GUIモデルの変更など、予測不可能なタイミングで到着するデータの処理に非常に適しています。

オブザーバーデザインパターンは、柔軟で再利用可能なオブジェクト指向ソフトウェアを設計するために繰り返し発生する設計上の課題に対処する、23の有名な「Gang of Four」デザインパターンの1つである振る舞いパターンであり、実装、変更、テスト、再利用が容易なオブジェクトを生み出します。^{[ 1 ]}

オブザーバーパターンは、以下の要件に対応します。^{[ 2 ]}

• オブジェクト間の1対多の依存関係は、オブジェクト同士を密接に結合させることなく定義されるべきである。
• あるオブジェクトの状態が変化すると、それに依存する多数のオブジェクトが自動的に更新される必要がある。
• あるオブジェクトは、複数の他のオブジェクトに通知することができる。

単純なアプローチとしては、1つのオブジェクト（主体）が各依存オブジェクトの特定のメソッドを直接呼び出すという方法があります。しかし、主体はすべての依存オブジェクトの具体的な型とインターフェースを把握する必要があるため、密結合が生じ、コードの柔軟性が損なわれ、拡張が困難になります。ただし、抽象化のオーバーヘッドが許容できず、コンパイル時の最適化が不可欠な、パフォーマンスが重視されるシナリオ（低レベルのカーネル構造やリアルタイムシステムなど）では、この直接的なアプローチが望ましい場合があります。

オブザーバーパターンは、標準的な通知プロトコルを確立することで、より柔軟な代替手段を提供する。

1. 標準化されたインターフェースを持つオブジェクトを定義しますSubject。Observer
2. 対象者の状態が変更されると、登録済みのすべてのオブザーバーに自動的に通知され、情報が更新されます。
3. 主体は自身の状態を管理すると同時に、オブザーバーのリストを保持し、オブザーバーのupdate()操作を呼び出すことで状態の変化を通知する。
4. 観察者の責任は、対象者との登録と登録解除を行い（状態変化の通知を受け取るため）、通知を受けた際に自身の状態を更新し（対象者の状態と同期させるため）ることである。

このアプローチでは、インターフェースの標準化を通じて、主体とオブザーバーの結合を緩やかにします。主体は、オブザーバーがメソッドを実装していることだけを知っていればよくupdate()、オブザーバーの具体的な型や内部実装の詳細を知る必要はありません。オブザーバーは実行時に独立して追加および削除できます。

オブザーバーパターンとパブリッシュ/サブスクライブパターンは、どちらもコンポーネント間の1対多の通信をサポートするため、密接に関連しており、しばしば混同されます。しかし、アーキテクチャ、結合度、および一般的なユースケースにおいて、両者は大きく異なります。

以下の表は、主な相違点をまとめたものです。

実際には、パブリッシュ/サブスクライブシステムは、オブザーバーパターンのいくつかの制約に対処するために進化しました。典型的なオブザーバー実装では、主体とそのオブザーバーの間に密結合が生じます。これは、特に分散環境において、スケーラビリティ、柔軟性、保守性を制限する可能性があります。主体とオブザーバーは共通のインターフェースに準拠する必要があり、両者は互いの存在を認識しています。

この結合度を低減するために、パブリッシュ/サブスクライブシステムでは、パブリッシャーとサブスクライバーの間を取り持つメッセージブローカーまたはイベントバスが導入されます。この追加レイヤーにより、直接参照が不要になり、システムが独立して進化できるようになります。ブローカーは、メッセージの永続性、配信保証、トピックベースのフィルタリング、非同期通信などの機能もサポートする場合があります。

システムによっては、オブザーバーパターンが内部的に使用され、パブリッシュ/サブスクライブインターフェースの背後でサブスクリプションメカニズムを実装します。その他の場合、パターンは独立して適用されます。たとえば、JavaScriptライブラリやフレームワークは、オブザーバーのようなサブスクリプション（コールバック登録など）と、分離されたパブリッシュ/サブスクライブメカニズム（イベントエミッターやシグナルなど）の両方を提供することがよくあります。^{[ 3 ] [ 4 ]}

歴史的に、 OS/2やMicrosoft Windowsのような初期のグラフィカルオペレーティングシステムでは、「publish-subscribe」や「event-driven programming」という用語は、オブザーバーパターンの同義語としてよく使われていました。^{[ 5 ]}

デザインパターン[ ^{1 ]で形式化}されたオブザーバーパターンは、購読解除、通知フィルタリング、配信保証、メッセージログなどの懸念事項を意図的に省略しています。これらの高度な機能は通常、堅牢なメッセージキューイングシステムで実装され、オブザーバーパターンは基礎的なメカニズムとして機能しますが、それだけでは十分ではありません。

関連するパターンには、メディエーターとシングルトンがあります。

ライブラリクラスは存在しますjava.util.Observerが、実装されたモデルが非常に限定的であったため、Java 9 で非推奨とjava.util.Observableなりました。

以下は、キーボード入力を受け取り、各入力行をイベントとして処理するJavaで記述された例です。 から文字列が提供されるとSystem.in、メソッドがnotifyObservers()呼び出され、すべてのオブザーバーにイベントの発生を通知します。通知方法は、各オブザーバーの更新メソッドを呼び出すことです。

パッケージorg.wikipedia.examples ;import java.util.ArrayList ; import java.util.List ; import java.util.Scanner ;interface Observer { void update ( String event ); } class EventSource { List < Observer > observers = new ArrayList <> (); public void notifyObservers ( String event ) { observers . forEach ( observer -> observer . update ( event )); } public void addObserver ( Observer observer ) { observers . add ( observer ); } public void scanSystemIn () { Scanner scanner = new Scanner ( System . in ); while ( scanner . hasNextLine ()) { String line = scanner . nextLine (); notifyObservers ( line ); } } }public class ObserverDemo { public static void main ( String [] args ) { System . out . println ( "テキストを入力してください: " ); EventSource eventSource = new EventSource (); eventSource . addObserver ( event -> System . out . printf ( "応答を受信しました: %s%n" , event ));eventSource.scanSystemIn ( ) ; } }

名前空間Wikipedia.Examples ;using System ; using System.Collections.Generic ;class Payload { internal string Message { get ; init ; } }class Subject : IObservable < Payload > { private readonly List < IObserver < Payload >> _observers = new ();IDisposable IObservable <Payload> .Subscribe ( IObserver <Payload> observer ) { if ( ! _observers.Contains ( observer ) ) { _observers.Add ( observer ) ; }​​​​​​​return new Unsubscriber ( observer , _observers ); }internal void SendMessage ( string message ) { foreach ( IObserver <Payload> observer in _observers ) { observer.OnNext ( new Payload { Message = message } ) ; } } }​​internal class Unsubscriber : IDisposable { private readonly IObserver < Payload > _observer ; private readonly ICollection < IObserver < Payload >> _observers ;internal Unsubscriber ( IObserver < Payload > observer , ICollection < IObserver < Payload >> observers ) { _observer = observer ; _observers = observers ; }void IDisposable.Dispose ( ) { if ( _observer ! = null && _observers.Contains ( _observer ) ) { _observers.Remove ( _observer ) ; } } }​​internal class Observer : IObserver < Payload > { private string _message ;public void OnCompleted () { }public void OnError ( Exception error ) { }public void OnNext ( Payload value ) { _message = value.Message ; }​​internal IDisposable Register ( IObservable < Payload > subject ) { return subject . Subscribe ( this ); } }

import std ;using std :: reference_wrapper ; using std :: vector ;class Subject ; // Observerで使用するための前方宣言class Observer { private : //デストラクタでデタッチする Subject オブジェクトへの参照Subject & subject ; public : explicit Observer ( Subject & subj ) : subject { subj } { subject.attach ( * this ) ; }virtual ~ Observer () { subject . detach ( * this ); } Observer ( const Observer & ) = delete ; Observer & operator = ( const Observer & ) = delete ;virtual void update ( Subject & s ) const = 0 ; };// Subject はイベント生成の基底クラスですclass Subject { private : vector <refObserver> observers ; public : using RefObserver = reference_wrapper < const Observer > ; //接続されているすべてのオブザーバーに通知しますvoid notify () { for ( const Observer & x : observers ) { x.get ( ). update ( * this ) ; } } //オブザーバーを追加しますvoid attach ( const Observer & observer ) { observers.push_back ( observer ); } //オブザーバーを削除しますvoid detach ( Observer & observer ) { observers.remove_if ([ & observer ]( const RefObserver & obj ) -> bool { return & obj.get ( ) == & observer ; } ) ; } } ;// 使用例class ConcreteObserver : public Observer { public : explicit ConcreteObserver ( Subject & subj ) : Observer ( subj ) {} // 通知を取得するvoid update ( Subject & ) const override { std :: println ( "通知を受け取りました" ); } };int main ( int argc , char * argv []) { Subject cs ; ConcreteObserver co1 ( cs ) ; ConcreteObserver co2 ( cs ); cs.notify ( ); }

通知を受け取りました通知を受け取りました

class EventSource { private observers = []private notifyObservers ( String event ) { observers.each { it ( event ) } }​​void addObserver ( observer ) { observers += observer }void scanSystemIn ( ) { var scanner = new Scanner ( System.in ) while ( scanner ) { var line = scanner.nextLine ( ) notifyObservers ( line ) } } }​​println 'テキストを入力してください: ' var eventSource = new EventSource ()eventSource.addObserver { event -> println "応答を受信しました: $ event " }eventSource.scanSystemIn ( )​

import java.util.Scannertypealias Observer = ( event : String ) -> Unit ;class EventSource { private var observers = mutableListOf < Observer > ()private fun notifyObservers ( event : String ) { observers.forEach { it ( event ) } }​​fun addObserver ( observer : Observer ) { observers += observer }fun scanSystemIn ( ) { val scanner = Scanner ( System.`in` ) while ( scanner.hasNext ( ) ) { val line = scanner.nextLine ( ) notifyObservers ( line ) } } }​​

fun main ( arg : List < String > ) { println ( "テキストを入力してください: " ) val eventSource = EventSource ()eventSource.addObserver { event -> println ( "応答を受信しました: $ event " ) }eventSource.scanSystemIn ( ) }​

System.Generics.Collections 、System.SysUtilsを使用します。​​​type IObserver = interface [ '{0C8F4C5D-1898-4F24-91DA-63F1DD66A692}' ] procedure Update ( const AValue : string ) ; end ;type TObserverManager = class private FObservers : TList < IObserver >; public constructor Create ; overload ; destructor Destroy ; override ; procedure NotifyObservers ( const AValue : string ) ; procedure AddObserver ( const AObserver : IObserver ) ; procedure UnregisterObserver ( const AObserver : IObserver ) ; end ;type TListener = class ( TInterfacedObject , IObserver ) private FName : string ; public constructor Create ( const AName : string ) ; reintroduce ; procedure Update ( const AValue : string ) ; end ;procedure TObserverManager.AddObserver ( const AObserver : IObserver ) ; begin if not FObservers.Contains ( AObserver ) then FObservers.Add ( AObserver ) ; end ;​​​​​​begin FreeAndNil ( FObservers ) ;継承; end ;procedure TObserverManager.NotifyObservers ( const AValue : string ) ; var i : Integer ; begin for i : = 0 to FObservers.Count - 1 do FObservers [ i ] .Update ( AValue ) ; end ;​​​​procedure TObserverManager.UnregisterObserver ( const AObserver : IObserver ) ; begin if FObservers.Contains ( AObserver ) then FObservers.Remove ( AObserver ) ; end ;​​​​​​constructor TListener . Create ( const AName : string ) ; begin inherited Create ; FName := AName ; end ;procedure TListener.Update ( const AValue : string ) ; begin WriteLn ( FName + 'リスナーが通知を受信しました: ' + AValue ) ; end ;procedure TMyForm . ObserverExampleButtonClick ( Sender : TObject ) ; var LDoorNotify : TObserverManager ; LListenerHusband : IObserver ; LListenerWife : IObserver ; begin LDoorNotify := TObserverManager . Create ; try LListenerHusband := TListener . Create ( 'Husband' ) ; LDoorNotify . AddObserver ( LListenerHusband ) ; LListenerWife := TListener . Create ( 'Wife' ) ; LDoorNotify . AddObserver ( LListenerWife ) ; LDoorNotify . NotifyObservers ( 'Someone is knocking on the door' ) ; finally FreeAndNil ( LDoorNotify ) ; end ; end ;

夫のリスナーに通知が届きました：誰かがドアをノックしています 妻のリスナーが通知を受け取った：誰かがドアをノックしている 

from typing import AnyクラスSubject : _observers : list [ Observer ]def __init__ ( self ) -> None : self . _observers = []def register_observer ( self , observer : Observer ) - > None : self._observers.append ( observer )​​​def notify_observers ( self , * args : tuple [ Any , ... ] , ** kwargs : dict [ str , Any ] ) - > None : for observer in self._observers : observer.notify ( self , * args , ** kwargs )​class Observer : def __init__ ( self , subject : Subject ) -> None : subject . register_observer ( self )def notify ( self , subject : Subject , * args : tuple [ Any , ... ], ** kwargs : dict [ str , Any ]) -> None : print ( f "Got { args } , { kwargs } from { subject } " )subject : Subject = Subject () observer : Observer = Observer ( subject ) subject . notify_observers ( "test" , kw = "python" )# 出力: Got ('test',) {'kw': 'python'} From <__main__.Observable object at 0x0000019757826FD0>

let Subject = { _state : 0 , _observers : [], add : function ( observer ) { this . _observers . push ( observer ); }, getState : function () { return this . _state ; }, setState : function ( value ) { this . _state = value ; for ( let i = 0 ; i < this . _observers . length ; i ++ ) { this . _observers [ i ]. signal ( this ); } } };let Observer = { signal : function ( subject ) { let currentValue = subject.getState ( ) ; console.log ( currentValue ) ; } }​Subject.add ( Observer ) ; Subject.setState ( 10 ) ; // console.log に出力- 10

• 暗黙の呼び出し
• クライアント・サーバーモデル
• オブザーバーパターンは、エンティティ・コンポーネント・システムパターンでよく使用されます。

• Wikibooksに掲載されている、さまざまな言語でのオブザーバー実装例