首页 > 代码库 > 发布-订阅（观察者）模式演变

发布-订阅（观察者）模式演变

2024-10-02 09:01:02   217人阅读

    （一）什么是观察者模式

       发布-订阅，这两个词语是对观察者的最好解释，现实生活中，这样的案例有很多，比如在篮球比赛过程中教练，喊一个暂停，然后球员和裁判都做相关的响应，还有比如OA里面发布的放假通知等等。无论是篮球比赛，还是OA的通知，都存在一个角色，它的作用就是保持对相关问题的关注，在问题发生变化的时候，是Ta把消息通知给相关各方。观察者模式也差不多这样，它抽象一类对象（观察者）专门负责"盯着"目标对象，当目标对象状态有变动的时候，每个观察者就会获得通知并迅速做出响应，观察者模式解决的也是调用通知关系所带来的依赖。

     （二）观察者模式的演变

        下面请看代码。有三个类，A,B,C想接收来自X的消息，简单的说X发生变化，他们也跟着变化。

public class A {
        public int Data;
        public void Update(int data) {
            this.Data =http://www.mamicode.com/ data;
        }
    }

    public class B {
        public int Count;
        public void NotifyCount(int data) {
            this.Count = data;
        }
    }

    public class C {
        public int N;
        public void Set(int data) {
            this.N = data;
        }
    }

    //上面这三个类，类A，B，C是希望获得X通知的类型
    public class X {
        private int data;
        public A InstanceA;
        public B InstanceB;
        public C InstanceC;
        public void SetData(int data) {
            this.data =http://www.mamicode.com/ data;
            InstanceA.Update(data);
            InstanceB.NotifyCount(data);
            InstanceC.Set(data);
        }
    }
   在我们调用的时候，应该这么做
A a = new A();
            B b = new B();
            C c = new C();
            X x = new X();
            x.InstanceA = a;
            x.InstanceB = b;
            x.InstanceC = c;
            x.SetData(10);
            Console.WriteLine("x发出消息了");
            Console.WriteLine(a.Data);
            Console.WriteLine(b.Count);
            Console.WriteLine(c.N);
对于上面这种做法，大家应该都会。下面是这个上面例子的类图关系，从这里，我们可以看得X和太多类直接关联了。已经很不符合面向对象的设计原则了。
技术分享

        经过观察，我们发现类A,B,C都有个共同之处，都是有一个类似于更新的方法，如果对他们进行抽象的话呢，就可以让类X仅仅依赖于一个抽象的类型。下面直接看代码

  public interface IUpdatableObject {
        int Data {get;}
        void Update(int newData);
    }

    public class A : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data =http://www.mamicode.com/ newData;
        }
    }

    public class B : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data =http://www.mamicode.com/ newData;
        }
    }

    public class C : IUpdatableObject {

        private int data;
        public int Data { get { return this.data; } }

        public void Update(int newData) {
            this.data =http://www.mamicode.com/ newData;
        }
    }

    public class X {
        private IUpdatableObject[] objects = new IUpdatableObject[3];

        //这个是索引器的用法
        public IUpdatableObject this[int index] { set { objects[index] = value; } }

        private int data;
        public void Update(int newData) {
            this.data =http://www.mamicode.com/ newData;
            foreach(IUpdatableObject obj in objects) {
                obj.Update(newData);
            }
        }
    }

//调用代码如下
    X x = new X();
            IUpdatableObject a = new A();
            IUpdatableObject b = new B();
            IUpdatableObject c = new C();
            x[0] = a;
            x[1] = b;
            x[2] = c;
            x.Update(10);
            Console.WriteLine("x发出了消息");
            Console.Write(a.Data);
            Console.Write(b.Data);
            Console.Write(c.Data);

通过上面我们就可以依赖于抽象了，比如当我们要新增加一个订阅者的时候，也不用去类X里面改内部代码，请看类图。

技术分享

     下面开始我们的版本的三；

先看看这幅图，以后我们把消息的发布者，叫做主题，接收着叫做观察者。主题类似于前文的X类，观察者类似于A,B,C类。

技术分享

     第二版本的时候，我们已经解决了两个对象之间的松耦合，关于观察者的一切，主题只需要知道他实现了哪个接口（前文中的IUpdatableObject接口），只要是实现了这个接口的，主题就会把他认为是观察者。

     继续这观察者模式的发展和演变，到了我们第三个版本的观察者模式。到了这步，我们想到如果有观察者要退出，不订阅这个主题了，等等操作（当主题发生变化的时候，，我们应该怎么做）。根据我们的面向对象的经验，我们应该很容易想到应该把主题对象也要抽象化。

     技术分享

        

public interface ISubject {

        int Data { get; set; } //这个Data就是类似于用来发送消息的。

        /// <summary>
        /// 追加
        /// </summary>
        /// <param name="obs"></param>
        void Attach(IObserver obs);

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="obs"></param>
        void Detach(IObserver obs);
        /// <summary>
        /// 监听
        /// </summary>
        void Notify();
    }

    public interface IObserver {
        int Data { get; set; }
        void Update(int n);
    }

    public class ConcreteSubjectA : ISubject {
        public int Data { get; set; }

        public List<IObserver> ObsList = new List<IObserver>();
        public void Attach(IObserver obs) {
            Console.WriteLine("添加观察者成功");
            ObsList.Add(obs);
        }

        public void Detach(IObserver obs) {
            Console.WriteLine("删除观察者成功");
            ObsList.Remove(obs);
        }

        public void Notify() {
            foreach(var obs in ObsList) {
                obs.Update(this.Data);
            }
        }
    }
    public class ConcreteObserverA : IObserver {

        public int Data { get; set; }
        public void Update(int n) {
            this.Data = http://www.mamicode.com/n;>



 ISubject csA = new ConcreteSubjectA();
            IObserver a = new ConcreteObserverA();
            IObserver b = new ConcreteObserverB();
            IObserver c = new ConcreteObserverC();
            csA.Attach(a);
            csA.Attach(b);
            csA.Attach(c);
            csA.Data = http://www.mamicode.com/20;"类A的数据为：{a.Data}");
            Console.WriteLine($"类B的数据为{b.Data}");
            Console.WriteLine($"类C的数据为{c.Data}");




降到这里基本上把观察者模式给讲完了，我更加喜欢叫做发布订阅模式，这样更加好理解。

      我们上面的那个例子还可以在抽象一点，利用泛型类和泛型方法来做，真正的达到抽象。下面是最终版本的实现代码（把泛型类和泛型方法用上），这个大家可以思考下怎么做？相关代码暂时不贴出来先。 

      最后，希望大家能够带带我这个菜鸟，谢谢各位。

      

发布-订阅（观察者）模式演变


联系
我们