良许Linux教程网 干货合集 详解观察者模式

详解观察者模式

在现实世界中,许多对象并不是独立存在的,其中一个对象的行为发生改变可能会导致一个或者多个其他对象的行为也发生改变。例如,某种商品的物价上涨时会导致部分商家高兴,而消费者伤心;还有,当我们开车到交叉路口时,遇到红灯会停,遇到绿灯会行。这样的例子还有很多,例如,股票价格与股民、微信公众号与微信用户、气象局的天气预报与听众、小偷与警察等。

在软件世界也是这样,例如,Excel 中的数据与折线图、饼状图、柱状图之间的关系;MVC 模式中的模型与视图的关系;事件模型中的事件源与事件处理者。所有这些,如果用观察者模式来实现就非常方便。

详解观察者模式

使用场景

观察者模式所做的工作其实就是在解耦,让耦合的双方都依赖于抽象而不是具体,从而使得各自的变化都不会影响另一边的变化。

当一个对象的改变需要改变其他对象的时候,而且它不知道具体有多少对象有待改变的时候,应该考虑使用观察者模式。

一个抽象模型有两方面,其中一方面依赖于另一方面,这时用观察者模式可以将这两者封装在独立的对象中使得他们各自独立地改变和复用。

举例

public interface ISubject
{
   void Notify();

   string SubjectState { get; set; }
}
public class Boss : ISubject
{
   private readonly IList _observers = new List();

   public void Attach(Observer observer)
   {
       _observers.Add(observer);
   }

   public void Detach(Observer observer)
   {
       _observers.Remove(observer);
   }

   public void Notify()
   {
       foreach (var observer in _observers)
       {
           observer.Update();
       }
   }

   public string SubjectState { get; set; }
}

public abstract class Observer
{
   protected string Name;
   protected ISubject Subject;

   protected Observer(string name, ISubject subject)
   {
       Name = name;
       Subject = subject;
   }

   public abstract void Update();
}
public class StockObserver : Observer
{
   public StockObserver(string name, ISubject subject) : base(name, subject)
   {
   }

   public override void Update()
   {
       Console.WriteLine($"{Name} {Subject.SubjectState} 关闭股票行情,继续工作");
   }
}
public class NBAObserver : Observer
{
   public NBAObserver(string name, ISubject subject) : base(name, subject)
   {
   }

   public override void Update()
   {
       Console.WriteLine($"{Name} {Subject.SubjectState} 关闭 NBA 直播,继续工作");
   }
}


var boss = new Boss();
var stockObserver = new StockObserver("魏关姹", boss);
var nbaObserver = new NBAObserver("易管查", boss);

boss.Attach(stockObserver);
boss.Attach(nbaObserver);

boss.Detach(stockObserver);

boss.SubjectState = "老板我胡汉三回来了";
boss.Notify();

借助 event(委托) 我们可以实现可以灵活的观察者模式,我们定义了一个新老板来演示事件的方式,来看下面的示例:

public class NewBoss : ISubject
{
   public event Action Update;

   public void Notify()
   {
       Update?.Invoke();
   }

   public string SubjectState { get; set; }
}

public class GamePlayerObserver
{
   private readonly string _name;
   private readonly ISubject _subject;

   public GamePlayerObserver(string name, ISubject subject)
   {
       _name = name;
       _subject = subject;
   }

   public void CloseGame()
   {
       Console.WriteLine($"{_name} {_subject.SubjectState} 关闭 LOL 游戏,继续工作");
   }
}

var newBoss = new NewBoss();
var stockObserver = new StockObserver("魏关姹", boss);
var nbaObserver = new NBAObserver("易管查", boss);
var gameObserver = new GamePlayerObserver("西门", newBoss);

// 注册通知事件
newBoss.Update += stockObserver.Update;
newBoss.Update += nbaObserver.Update;
newBoss.Update += gameObserver.CloseGame;

newBoss.Update -= stockObserver.Update;

newBoss.SubjectState = "老板我胡汉三回来了";
newBoss.Notify();

从上面这个示例可以看到,通过事件的方式,我们可以不要求显示继承于 Observer 这个抽象类,可以更加灵活,扩展性更强,这也是很多类库中会使用事件来扩展的重要原因

More

设计模式要干的事情就是解耦。创建型模式是将创建和使用代码解耦,结构型模式是将不同功能代码解耦,行为型模式是将不同的行为代码解耦,具体到观察者模式,它是将观察者和被观察者代码解耦。

根据应用场景的不同,观察者模式会对应不同的代码实现方式:有同步阻塞的实现方式,也有异步非阻塞的实现方式;有进程内的实现方式,也有跨进程的实现方式。

在对象之间定义一个一对多的依赖,当一个对象状态改变的时候,所有依赖的对象都会自动收到通知。一般情况下,被依赖的对象叫作被观察者(Observable),依赖的对象叫作观察者(Observer)。不过,在实际的项目开发中,这两种对象的称呼是比较灵活的,有各种不同的叫法,比如:Subject-Observer、Publisher-Subscriber、Producer-Consumer、EventEmitter-EventListener、Dispatcher-Listener。不管怎么称呼,只要应用场景符合刚刚给出的定义,都可以看作观察者模式。

EventBus(事件总线) 就是一个观察者模式的实际应用。

以上就是良许教程网为各位朋友分享的Linux系统相关内容。想要了解更多Linux相关知识记得关注公众号“良许Linux”,或扫描下方二维码进行关注,更多干货等着你 !

img
本文由 良许Linux教程网 发布,可自由转载、引用,但需署名作者且注明文章出处。如转载至微信公众号,请在文末添加作者公众号二维码。
良许

作者: 良许

良许,世界500强企业Linux开发工程师,公众号【良许Linux】的作者,全网拥有超30W粉丝。个人标签:创业者,CSDN学院讲师,副业达人,流量玩家,摄影爱好者。
上一篇
下一篇

发表评论

邮箱地址不会被公开。 必填项已用*标注

联系我们

联系我们

公众号:良许Linux

在线咨询: QQ交谈

邮箱: yychuyu@163.com

关注微信
微信扫一扫关注我们

微信扫一扫关注我们

关注微博
返回顶部