[toc]

设计模式02-观察者者设计模式

主要来源Head First设计模式（书）
观察者设计模式是JDK中使用最多的设计模式之一

如果你了解报纸订阅是怎么回事，其实就知道观察者模式是怎么回事，知识名称不一样：出版社改为主题(Subject)，订阅者改为观察者(Observer)

书中定义：对象之间的一对多依赖，这样一来，当一个对象改变状态时，它的所有依赖者都会收到通知并自动更新。

案例分析

用户订阅报纸

1. 主题

    /**
     * 类描述：主题<br/>
     */
    interface Subject{
        //主题需要几个方法
        //添加观察者
        fun addObserver(observer: Observer)
        //删除观察者
        fun removeObserver(observer: Observer)
        //通知观察者
        fun notifyObserver(t: Any)
    }

2.观察者

    /**
     * 类描述：观察者<br/>
     */
    interface  {
        //一种观察者接收的数据应该是一样的所以可以添加泛型
        //更新数据
        fun<T> update(t: T)
    }

3.具体主题

    /**
     * 类描述：具体主题<br/>
     */
    class ConcreteSubject: Subject{
        /**
         * 观察者集合
         */
        private val mObserver by lazy {
            mutableListOf<Observer>()
        }
    
        override fun addObserver(observer: Observer) {
            mObserver.indexOf(observer)
                    .takeIf {
                        it == -1
                    }?.let {
                         mObserver.add(observer)
                    }
        }
    
        override fun removeObserver(observer: Observer) {
            mObserver.indexOf(observer)
                    .takeIf {
                        it > -1
                    }?.let {
                        mObserver.remove(observer)
                    }
        }
    
        override fun notifyObserver(t: Any) {
            mObserver.forEach {
                it.update(t)
            }
        }
    }

4.具体观察者

    /**
     * 类描述：具体观察者<br/>
     */
    class ConcreteObserver1 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "1,当前报纸内容是$t")
        }
    }
    
    /**
     * 类描述：具体观察者<br/>
     */
    class ConcreteObserver2 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "2,当前报纸内容是$t")
        }
    }
    
    /**
     * 类描述：具体观察者<br/>
     */
    class ConcreteObserver3 : Observer {
        override fun <报纸内容> update(t: 报纸内容) {
            Log.d("123===", "3,当前报纸内容是$t")
        }
    }

接收对象

    /**
     * 类描述：报纸内容<br/>
     */
    data class 报纸内容(val name: String, val content: String)

5.使用

        val a1 = 报纸内容("我是1", "haha1")
        val a2 = 报纸内容("我是2", "hehe2")
        val a3 = 报纸内容("我是3", "heihei3")

        val o1 = ConcreteObserver1()
        val o2 = ConcreteObserver2()
        val o3 = ConcreteObserver3()

        val subject = ConcreteSubject()

        subject.addObserver(o1)
        subject.addObserver(o2)
        subject.addObserver(o3)

        subject.notifyObserver(a1)
        subject.notifyObserver(a2)

        subject.removeObserver(o3)

        subject.notifyObserver(a3)

6.结果

    1,当前报纸内容是报纸内容(name=我是1, content=haha1)
    2,当前报纸内容是报纸内容(name=我是1, content=haha1)
    3,当前报纸内容是报纸内容(name=我是1, content=haha1)
    1,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    2,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    3,当前报纸内容是报纸内容(name=我是2, content=hehe2)
    1,当前报纸内容是报纸内容(name=我是3, content=heihei3)
    2,当前报纸内容是报纸内容(name=我是3, content=heihei3)

7.UML图

uml下载地址

观察者模式-01

第四个设计原则

为了交互对象之间的松耦合设计而努力。

第1.2.3设计原则(GitHub地址)

为什么：松耦合的设计之所以能让我们建立有弹性的OO系统，能够应对变化，是因为对象之间的互相依赖降到最低。

JAVA内置了观察者模式

java.util.Observable->这是一个类不是接口，从这可以看到其缺点。
java.util.Observer