深入浅出设计模式——从球赛中悟观察者模式

来源:
三产
最后修订:
2017年08月08日 17:08:15
 155
观察者模式,主要用来处理对象的一对多的关系,一个主题(Subject),多个观察者(Observer),当主题发生变化时观察者会及时得到通知。

本文转载自:深入浅出设计模式——从球赛中悟观察者模式

一、观察者模式概念

    观察者模式是指在对象之间定义一对多的依赖,当一个对象改变状态时,依赖它的对象都会收到通知并自动更新。

    就好比在足球比赛中,教练员会在场边发布命令,然后场上所有的队员都要根据它的命令作出响应,这时,场上的队员就是观察者,教练发出的口令就是主题。

二、使用场景

    在一个对象有改变其他依赖对象需要接到通知时

三、结构

{width=“496” height=“260”}

     从上面的UML图中我们可以看出策略模式由三个部分组成:

        1. 主题(Subject):也叫被观察者,如果主题发生改变那么观察者会接到通知

        2. 观察者(Observer)

四、实现

    在Java中可以通过继承JDK中的Observable类和实现Observer接口来实现观察者模式,但是不提倡这样做,因为Java是单继承语言,如果主题类需要用到观察者模式但同时它又继承了其他类,这样的情况就很尴尬。所以建议自己写主题类,况且这也不难实现。下面我们就从头开始自己实现观察者模式。

  1. 定义主题接口

    import observer.Observer;

    /**

    • Description: 主题

    • Designer: jack

    • Date: 2017/8/7

    • Version: 1.0.0 */ public interface Subject { void registerObserver(Observer observer); // 注册观察者

      void removeObserver(Observer observer); //删除观察者

      void notifyObservers(); //当主题改变时,调用这个方法通知所有观察者 }

    接口中包含3个方法,注册观察者,删除观察者,和通知。这里对最基础的观察者模式做了一个小的拓展,那就是观察者可以自行注册和删除,当且仅当观察者在这个主题里注册了才会收到通知。

    (1)注册观察者:观察者如需订阅这个主题那么就调用注册方法,下一次主题改变时就会收到通知。

    (2)删除观察者:观察者如果不想再收到这个主题的通知则调用这个方法,以后主题再改变时也不会收到通知。

    (3)通知:主题发生改变时,调用这个方法通知已注册的观察者。

  1. 观察者接口

    import subject.Subject;

    /**

    • Description: 观察者接口
    • Designer: jack
    • Date: 2017/8/7
    • Version: 1.0.0 */ public interface Observer { void update(T t); //当需要改变战术时将新的战术通知给对应当球员 }

    观察者接口只需要一个update方法用于接受通知并做相应的处理。

  1. 主题实现类

    package subject;

    import observer.Observer;

    import java.util.ArrayList; import java.util.stream.Collectors;

    /**

    • Description: 球员战术指示

    • Designer: jack

    • Date: 2017/8/7

    • Version: 1.0.0 */ public class PositionAndStrategy implements Subject{

      private ArrayList> observers; //观察者注册信息列表 private String strikerStrategy; //前锋战术指令 private String defenderStrategy; //后卫战术指令

      public PositionAndStrategy() {

      this.observers = new ArrayList<>();
      

      }

      @Override public void registerObserver(Observer observer) {

      this.observers.add(observer);
      

      }

      @Override public void removeObserver(Observer observer) {

      this.observers = this.observers.stream()
              .filter(observer1 -> !observer1.equals(observer))
              .collect(Collectors.toCollection(ArrayList::new));
      

      }

      @Override public void notifyObservers() {

      this.observers.forEach(observer -> observer.update(this));
      

      }

      public void setStrategy(String strikerStrategy, String defenderStrategy) {

      this.strikerStrategy = strikerStrategy;
      this.defenderStrategy = defenderStrategy;
      notifyObservers();
      

      }

      public String getStrikerStrategy() {

      return strikerStrategy;
      

      }

      public String getDefenderStrategy() {

      return defenderStrategy;
      

      } }

    主题实现类包含了所有观察者所需要的所有信息,并且在信息发生改变时(setStrategy)调用notifyObservers()方法向观察者发送通知。notifyObservers()实现的方法就是调用observers列表中的每一个观察者的update()方法。

  1. 观察者实现

    第一个观察者:前锋

import subject.PositionAndStrategy;

/**
 * Description: 前锋
 * Designer: jack
 * Date: 2017/8/7
 * Version: 1.0.0
 */
public class Striker implements Observer<PositionAndStrategy>{

    @Override
    public void update(PositionAndStrategy positionAndStrategy) {
        //他只需要执行前锋的战术就好了,不用管后卫是什么战术
        System.out.println("前锋:" + positionAndStrategy.getStrikerStrategy() );
    }

}

    第二个观察者:后卫

import subject.PositionAndStrategy;

/**
 * Description:
 * Designer: jack
 * Date: 2017/8/7
 * Version: 1.0.0
 */
public class Defender implements Observer<PositionAndStrategy>{

    @Override
    public void update(PositionAndStrategy positionAndStrategy) {
        System.out.println("后卫:" + positionAndStrategy.getDefenderStrategy() );
    }

}

    主题类将所有的信息都交给观察者,而观察者从里面取出自己需要的信息进行处理就可以了。

  1. 实现类

    import observer.Defender; import observer.Striker; import subject.PositionAndStrategy;

    public class Main {

    public static void main(String[] args) {
        //创建战术板(主题类)
        PositionAndStrategy positionAndStrategy = new PositionAndStrategy();
    
        //创建前锋和后卫(观察者)
        Striker striker = new Striker();
        Defender defender = new Defender();
    
        //在主题中注册观察者
        positionAndStrategy.registerObserver(striker);
        positionAndStrategy.registerObserver(defender);
        //主题发生变化
        System.out.println("主题第一次变化!");
        positionAndStrategy.setStrategy("进攻", "防守");
    
        //现在后卫距离太远,听不到教练的指令了(删除观察者)
        positionAndStrategy.removeObserver(defender);
        //主题发生变化
        System.out.println("
    n主题第二次变化"); positionAndStrategy.setStrategy("继续进攻", "压上支援"); //后卫现在又能听到指令了 positionAndStrategy.registerObserver(defender); //主题发生变化 System.out.println("
    n主题第三次变化"); positionAndStrategy.setStrategy("表现的不错,保持住", "后卫你们在干什么,叫你们压上支援"); }

    }

    执行main方法得到结果:

{width=“306” height=“182”}

    可以看出主题每一次变化订阅了主题的观察者都能收到相应的通知,然后他们从里面提取自己需要的信息进行处理。这就是观察者模式。

五、优点

    1. 观察者与被观察者之间的耦合度低

    2. 有一套触发机制

六、局限性

    1. 如果一个主题中观察者过多会导致效率降低。

    2. 观察者只知道主题变化的结果而不知道主题是怎么变化的。

    世界上没有十全十美的模式,每个设计模式都有它适用的地方,只要我们的使用方式得当,那么观察者模式可以帮助我们写出漂亮优雅的代码。

附源码地址:http://git.oschina.net/jack90john/observer