愿你如阳光，明媚不忧伤。
目録
8. 观察者模式观察者模式优点和缺点观察者模式的应用场景观察者模式模式的结构观察者模式的实现观察者模式的应用实例 I9. 中介模式中介模式优点和缺点中介模式的应用场景中介模式模式的结构中介模式的实现中介模式的扩展【每日一面】说说观察者模式和中介模式的区别8. 观察者模式
Observer指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式，它是对象行为型模式。例如，某种商品的物价上涨时会导致部分商家高兴，而消费者伤心；还有，当我们开车到交叉路口时，遇到红灯会停，遇到绿灯会行；Excel 中的数据与折线图、饼状图、柱状图之间的关系。
观察者模式优点和缺点
优点降低了目标与观察者之间的耦合关系，两者之间是抽象耦合关系。符合依赖倒置原则。目标与观察者之间建立了一套触发机制。缺点目标与观察者之间的依赖关系并没有完全解除，而且有可能出现循环引用。当观察者对象很多时，通知的发布会花费很多时间，影响程序的效率。观察者模式的应用场景
对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。实现类似广播机制的功能，不需要知道具体收听者，只需分发广播，系统中感兴趣的对象会自动接收该广播。多层级嵌套使用，形成一种链式触发机制，使得事件具备跨域（跨越两种观察者类型）通知。观察者模式模式的结构
实现观察者模式时要注意具体目标对象和具体观察者对象之间不能直接调用，否则将使两者之间紧密耦合起来，这违反了面向对象的设计原则。1. 抽象主题（Subject）角色：也叫抽象目标类，它提供了一个用于保存观察者对象的聚集类和增加、删除观察者对象的方法，以及通知所有观察者的抽象方法。
2. 具体主题（Concrete Subject）角色：也叫具体目标类，它实现抽象目标中的通知方法，当具体主题的内部状态发生改变时，通知所有注册过的观察者对象。
3. 抽象观察者（Observer）角色：它是一个抽象类或接口，它包含了一个更新自己的抽象方法，当接到具体主题的更改通知时被调用。
4. 具体观察者（Concrete Observer）角色：实现抽象观察者中定义的抽象方法，以便在得到目标的更改通知时更新自身的状态。
观察者模式的实现
package com.example.demo.controller;import java.util.ArrayList;import java.util.List;public class ObserverController {public static void main(String[] args) {Observer observer1 = new ConcreteObserver1();Observer observer2 = new ConcreteObserver2();Subject subject = new ConcreteSubject();subject.add(observer1);subject.add(observer2);subject.notifyObserver();}}// 抽象观察者interface Observer {// 观察者响应方法void response();}// 具体观察者1class ConcreteObserver1 implements Observer {@Overridepublic void response() {System.out.println("具体观察者1做出反应");}}// 具体观察者2class ConcreteObserver2 implements Observer {@Overridepublic void response() {System.out.println("具体观察者2做出反应");}}// 抽象主题abstract class Subject {protected List<Observer> observerList = new ArrayList<>();// 增加观察者方法public void add(Observer observer) {observerList.add(observer);}// 删除观察者方法public void remove(Observer observer) {observerList.remove(observer);}// 通知观察者方法public void notifyObserver() {}}// 具体主题class ConcreteSubject extends Subject {@Overridepublic void notifyObserver() {System.out.println("具体主题发生改变");for (Observer observer : observerList) {observer.response();}}}-----------------------------------------------------------------・【运行结果】具体主题发生改变具体观察者1做出反应具体观察者2做出反应
观察者模式的应用实例 I
利用观察者模式设计一个学校铃声的事件处理程序。
package com.example.demo.controller;import java.util.ArrayList;import java.util.List;public class ObserverController {public static void main(String[] args) {Bell bell = new ConcreteBell();bell.add(new Student());bell.add(new Teacher());bell.ring(true);System.out.println("-----------------------");bell.ring(false);}}// 抽象事件interface EventObject {}// 铃声事件class RingEvent implements EventObject {private Boolean sound;public RingEvent(Boolean sound) {this.sound = sound;}public Boolean getSound() {return sound;}public void setSound(Boolean sound) {this.sound = sound;}}// 抽象观察者interface Observer {// 观察者响应方法void response(RingEvent ringEvent);}// 具体观察者1class Student implements Observer {@Overridepublic void response(RingEvent ringEvent) {if (ringEvent.getSound()) {System.out.println("同学们，上课了。。。");} else {System.out.println("同学们，下课了。。。");}}}// 具体观察者2class Teacher implements Observer {@Overridepublic void response(RingEvent ringEvent) {if (ringEvent.getSound()) {System.out.println("老师，上课了。。。");} else {System.out.println("老师，下课了。。。");}}}// 抽象主题abstract class Bell {protected List<Observer> observerList = new ArrayList<>();// 增加观察者方法public void add(Observer observer) {observerList.add(observer);}// 删除观察者方法public void remove(Observer observer) {observerList.remove(observer);}// 事件触发public void ring(Boolean sound) {String type = sound ? "上课铃" : "下课铃";System.out.println(type + "响");notifyObserver(new RingEvent(sound));}// 通知观察者方法public void notifyObserver(RingEvent ringEvent) {}}// 具体主题class ConcreteBell extends Bell {@Overridepublic void notifyObserver(RingEvent ringEvent) {System.out.println("ling~~~ling~~~ling~~~");for (Observer observer : observerList) {observer.response(ringEvent);}}}-----------------------------------------------------------------・【运行结果】上课铃响ling~~~ling~~~ling~~~同学们，上课了。。。老师，上课了。。。-----------------------下课铃响ling~~~ling~~~ling~~~同学们，下课了。。。老师，下课了。。。
9. 中介模式
Mediator定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。
中介模式优点和缺点
优点类之间各司其职，符合迪米特法则。降低了对象之间的耦合性，使得对象易于独立地被复用。将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。缺点中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。中介模式的应用场景
当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。当想创建一个运行于多个类之间的对象，又不想生成新的子类时。中介模式模式的结构
中介者模式实现的关键是找出“中介者”。1. 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
2. 具体中介者（Concrete Mediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。 4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
中介模式的实现
package com.example.demo.controller;import java.util.ArrayList;import java.util.List;public class MediatorController {public static void main(String[] args) {Mediator mediator = new ConcreteMediator();Colleague c1, c2;c1 = new ConcreteColleague1();c2 = new ConcreteColleague2();mediator.register(c1);mediator.register(c2);c1.send();System.out.println("-------------");c2.send();}}// 抽象中介者abstract class Mediator {public abstract void register(Colleague colleague);// 转发public abstract void relay(Colleague colleague);}// 具体中介者class ConcreteMediator extends Mediator {private final List<Colleague> colleagues = new ArrayList<>();public void register(Colleague colleague) {if (!colleagues.contains(colleague)) {colleagues.add(colleague);colleague.setMediator(this);}}public void relay(Colleague colleague) {for (Colleague ob : colleagues) {if (!ob.equals(colleague)) {ob.receive();}}}}// 抽象同事类abstract class Colleague {protected Mediator mediator;public void setMediator(Mediator mediator) {this.mediator = mediator;}public abstract void receive();public abstract void send();}// 具体同事类1class ConcreteColleague1 extends Colleague {public void receive() {System.out.println("具体同事类1收到请求。");}public void send() {System.out.println("具体同事类1发出请求。");// 请中介者转发mediator.relay(this);}}// 具体同事类2class ConcreteColleague2 extends Colleague {public void receive() {System.out.println("具体同事类2收到请求。");}public void send() {System.out.println("具体同事类2发出请求。");// 请中介者转发mediator.relay(this);}}-----------------------------------------------------------------・【运行结果】具体同事类1发出请求。具体同事类2收到请求。-------------具体同事类2发出请求。具体同事类1收到请求。
中介模式的扩展
在实际开发中，通常采用以下两种方法来简化中介者模式，使开发变得更简单。
1.不定义中介者接口，把具体中介者对象实现成为单例。
2.同事对象不持有中介者，而是在需要的时候直接获取中介者对象并调用。
简单单例中介者模式
package com.example.demo.controller;import java.util.ArrayList;import java.util.List;public class SimpleMediatorController {public static void main(String[] args) {SimpleColleague c1, c2;c1 = new SimpleConcreteColleague1();c2 = new SimpleConcreteColleague2();c1.send();System.out.println("-----------------");c2.send();}}// 简单单例中介者class SimpleMediator {private static final SimpleMediator simpleMediator = new SimpleMediator();private final List<SimpleColleague> colleagues = new ArrayList<>();private SimpleMediator() {}public static SimpleMediator getMediator() {return simpleMediator;}public void register(SimpleColleague colleague) {if (!colleagues.contains(colleague)) {colleagues.add(colleague);}}public void relay(SimpleColleague scl) {for (SimpleColleague ob : colleagues) {if (!ob.equals(scl)) {ob.receive();}}}}// 抽象同事类interface SimpleColleague {void receive();void send();}// 具体同事类1class SimpleConcreteColleague1 implements SimpleColleague {SimpleConcreteColleague1() {SimpleMediator simpleMediator = SimpleMediator.getMediator();simpleMediator.register(this);}public void receive() {System.out.println("具体同事类1：收到请求。");}public void send() {SimpleMediator simpleMediator = SimpleMediator.getMediator();System.out.println("具体同事类1：发出请求...");// 请中介者转发simpleMediator.relay(this);}}// 具体同事类2class SimpleConcreteColleague2 implements SimpleColleague {SimpleConcreteColleague2() {SimpleMediator simpleMediator = SimpleMediator.getMediator();simpleMediator.register(this);}public void receive() {System.out.println("具体同事类2：收到请求。");}public void send() {SimpleMediator simpleMediator = SimpleMediator.getMediator();System.out.println("具体同事类2：发出请求...");// 请中介者转发simpleMediator.relay(this);}}-----------------------------------------------------------------・【运行结果】具体同事类1发出请求。具体同事类2收到请求。-------------具体同事类2发出请求。具体同事类1收到请求。
【每日一面】
说说观察者模式和中介模式的区别
Observer：观察者模式，要有观察者、被观察者两类元素。指多个对象间存在一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。这种模式有时又称作发布-订阅模式、模型-视图模式。其实就是为了实现松耦合，多用于单个应用内部。只能从一的一方循环的通知，属于单向。
Mediator：中介模式，定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。可以从任一方循环通知，属于双向。
观察者模式属于单向，中介者属于双向
