Delphi 观察者模式

RAD Studio 10.2.3 测试√

---

运行结果：

---

使用方法：

procedure TDesignPattern.Button_ObserverPatternClick(Sender: TObject);
var
  mObj001: TObserverObject_001;
  mObj002: TObserverObject_002;
begin
  // 被观察者001进行创建
  mObj001 := TObserverObject_001.Create;
  Memo_Log.Lines.Add('被观察者001第 1 次改变了状态');
  mObj001.SelfChange;
  // 然后添加期观察者 001
  mObj001.AddObserver(TObserver_001.Create);
  Memo_Log.Lines.Add('被观察者001第 2 次改变了状态');
  mObj001.SelfChange;
  // 然后添加期观察者 003
  mObj001.AddObserver(TObserver_003.Create);
  Memo_Log.Lines.Add('被观察者001第 3 次改变了状态');
  mObj001.SelfChange;

  Memo_Log.Lines.Add('------------------');

  // 被观察者002进行创建
  mObj002 := TObserverObject_002.Create;
  Memo_Log.Lines.Add('被观察者002第 1 次改变了状态');
  mObj002.SelfChange;
  // 然后添加期观察者 002
  mObj002.AddObserver(TObserver_002.Create);
  Memo_Log.Lines.Add('被观察者002第 2 次改变了状态');
  mObj002.SelfChange;
  Memo_Log.Lines.Add('------------------');
  Memo_Log.Lines.Add('被观察者001第 4 次改变了状态');
  mObj001.SelfChange;
  Memo_Log.Lines.Add('------------------');
  // 然后添加期观察者 003
  mObj002.AddObserver(TObserver_003.Create);
  Memo_Log.Lines.Add('被观察者002第 3 次改变了状态');
  mObj002.SelfChange;

  Memo_Log.Lines.Add('==================');
  // 这里将两个被观察者继续添加观察者
  mObj001.AddObserver(TObserver_002.Create);
  mObj002.AddObserver(TObserver_001.Create);
  // 这里在分别进行最后一次通知
  Memo_Log.Lines.Add('被观察者001第 5 次改变了状态');
  mObj001.SelfChange;
  Memo_Log.Lines.Add('==================');
  Memo_Log.Lines.Add('被观察者002第 4 次改变了状态');
  mObj002.SelfChange;

  // 不用了记得释放被观察者即可
  mObj001.Free;
  mObj002.Free;
end;

---

观察者模式单元：

unit uObserverPattern;

{------------------------------------------------------------------------------}
{  单元描述: 观察者模式                                                        }
{  单元作者: XiaoYin                                                           }
{  创建时间: 2021-11-04                                                        }
{  描    述: 我目前理解的观察者模式，欢迎各位大佬对我指指点点，我会加以改正    }
{                                                                              }
{            比如在一条马路上面，有来来往往的车和人，同时也会有很多的摄像头，  }
{            马路上面的所有的摄像头就是观察者，来往的车和人就是被观察者，这里  }
{            可以把每辆车或者每个人当做是观察对象，每次移动都会通知摄像头，或  }
{            是这些车和人经过某些点的时候会通知摄像头。                        }
{  总    结: 总之就是当被观察的实物发生了改变，或是触发通知，将此通知给所有的  }
{            观察者，至于观察者观察这一变动是要干啥那是观察者的事情了          }
{------------------------------------------------------------------------------}

interface

uses
  System.Generics.Collections;

type
  // 所有的观察者都需要继承这个抽象类
  TObserver = class
  public
    //抽象方法(纯虚方法)，只有定义没有实现，一个类包含一个即成抽象类，抽象类不能直接创建对象。
    procedure Update; virtual; abstract;
  end;

  // 观察者001
  TObserver_001 = class(TObserver)
  public
    procedure Update; override;     // 覆盖重写父类中的虚方法
  private
    function CheckThis: Boolean;    // 检查被观察者是否满足此观察者的触发条件
  end;

  // 观察者002
  TObserver_002 = class(TObserver)
  public
    procedure Update; override;     // 覆盖重写父类中的虚方法
  private
    function CheckThis: Boolean;    // 检查被观察者是否满足此观察者的触发条件
  end;

  // 观察者003
  TObserver_003 = class(TObserver)
  public
    procedure Update; override;     // 覆盖重写父类中的虚方法
  private
    function CheckThis: Boolean;    // 检查被观察者是否满足此观察者的触发条件
  end;

  // 这可以算是被观察者的统称，具体观察者需要继承这个类
  TSubject = class
  private
    // 这个 List 中存放所有的观察者  作用: 当被观察者发生改变通知这些观察者
    FObserverList: TList<TObserver>;
    procedure ClearList;
  public
    constructor Create;
    destructor Destroy; override;
  public
    procedure AddObserver(AObserver: TObserver);      // 将观察者添加到 List 中
    procedure NotifyObserver;      // 通知已经添加的观察者
  end;

  // 被观察的对象001
  TObserverObject_001 = class(TSubject)
  public
    constructor Create;
    destructor Destroy; override;
  public
    procedure SelfChange;      // 被观察者发生改变生了改变
  end;

  // 被观察的对象002
  TObserverObject_002 = class(TSubject)
  public
    constructor Create;
    destructor Destroy; override;
  public
    procedure SelfChange;      // 被观察者发生改变生了改变
  end;

implementation

uses
  uFrmDesignPattern;

procedure NotifyMsg(AMsgStr: string);
begin
  // 这个里面写需要在哪里通知
  DesignPattern.Memo_Log.Lines.Add(AMsgStr);
end;

{ TObserver_001 }

function TObserver_001.CheckThis: Boolean;
begin
  // 这里面写需要判断的逻辑
  Result := True;
end;

procedure TObserver_001.Update;
begin
  NotifyMsg('这是观察者001');
  if CheckThis then
    NotifyMsg('被观察者的改变满足此观察者的检测条件，观察者001进行了记录');
end;

{ TObserver_002 }

function TObserver_002.CheckThis: Boolean;
begin
  // 这里面写需要判断的逻辑
  Result := True;
end;

procedure TObserver_002.Update;
begin
  NotifyMsg('这是观察者002');
  if CheckThis then
    NotifyMsg('被观察者的改变满足此观察者的检测条件，观察者002进行了记录');
end;

{ TObserver_003 }

function TObserver_003.CheckThis: Boolean;
begin
  // 这里面写需要判断的逻辑
  Result := True;
end;

procedure TObserver_003.Update;
begin
  NotifyMsg('这是观察者003');
  if CheckThis then
    NotifyMsg('被观察者的改变满足此观察者的检测条件，观察者001进行了记录');
end;

{ TSubject }

procedure TSubject.AddObserver(AObserver: TObserver);
begin
  FObserverList.Add(AObserver);
end;

procedure TSubject.ClearList;
var
  mObserver: TObserver;
begin
  for mObserver in FObserverList do
  begin
    // 同时也不要忘记了释放 List 中存放的观察者
    mObserver.Free;
  end;
end;

constructor TSubject.Create;
begin
  FObserverList := TList<TObserver>.Create;
end;

destructor TSubject.Destroy;
begin
  ClearList;
  FObserverList.Free;
  inherited;
end;

procedure TSubject.NotifyObserver;
var
  mObserver: TObserver;
  i: Integer;
begin
  // 遍历所有添加进来的观察者
  for i := 0 to FObserverList.Count - 1 do
  begin
    mObserver := FObserverList[i];
    if Assigned(mObserver) then
      mObserver.Update;     // 告诉观察者他观察的对象已经发生了改变
  end;
end;

{ TObserverObject_001 }

constructor TObserverObject_001.Create;
begin
  inherited;

end;

destructor TObserverObject_001.Destroy;
begin

  inherited;
end;

procedure TObserverObject_001.SelfChange;
begin
  // 发生变化，进行通知
  NotifyObserver;
end;

{ TObserverObject_002 }

constructor TObserverObject_002.Create;
begin
  inherited;

end;

destructor TObserverObject_002.Destroy;
begin

  inherited;
end;

procedure TObserverObject_002.SelfChange;
begin
  // 发生变化，进行通知
  NotifyObserver;
end;

end.

---

一点点笔记，以便以后翻阅。