设计模式之观察者模式

观察者模式我消化了两天，因为智商问题，理解的比较慢。。。另外恭喜我自己以科目二一百分的成绩顺利拿上驾照

言归正传，先从大神那里扒一张图，对着图看比较容易理解。

　　　　　　　　

　　　　　　　　　　　　　　　　　　　　　　（图片来自左潇龙大佬，本图片仅供仅供学习使用，希望大佬不要怪罪）

　　观察者模式又称为发布订阅模式，这个模式由被观察者、观察者组成，他们的关系是观察者观察被观察者，当被观察者的状态发生改变的时候会通知对应的观察者。

　　简单点概括成通俗的话来说，就是一个类管理着所有依赖于它的观察者类，并且它状态变化时会主动给这些依赖它的类发出通知。

　　JDK中提供了观察者模式现成的代码，贴出来说明一下。

　　

package java.util;

/**
 * A class can implement the <code>Observer</code> interface when it
 * wants to be informed of changes in observable objects.
 *上面这句话翻译过来就是，当observable对象做出改变时，希望收到信息的类必须实现此接 
 * 口
 *
 */
public interface Observer {//观察者
  //当observable对象状态改变时必须要调用此方法通知实现此接口的对象
    void update(Observable o, Object arg);
}


package java.util;


public class Observable {//被观察者
    private boolean changed = false;
    private Vector<Observer> obs;//用来管理观察者的集合 怕线程不安全使用vector

    /** Construct an Observable with zero Observers. */

    public Observable() {
        obs = new Vector<>();
    }

   //添加观察者
    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

   
    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    
   //通知观察者
    public void notifyObservers() {
        notifyObservers(null);
    }

   
    public void notifyObservers(Object arg) {
      
        Object[] arrLocal;

        synchronized (this) {
       
            if (!changed)//当被观察者状态没被改变 则终止此方法
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);//通知被观察者
    }

  
    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

 //改变被观察者状态
    protected synchronized void setChanged() {
        changed = true;
    }

    
    protected synchronized void clearChanged() {
        changed = false;
    }

   
    public synchronized boolean hasChanged() {
        return changed;
    }

  
    public synchronized int countObservers() {
        return obs.size();
    }
}

　　用前些日子比较火的直播网站来举个例子，主播就是被观察者，观众则是观察者，观众们可以点击关注自己喜欢的主播（这里这个关注的动作就是观察者模式中的观察），当主播上线开始直播的时候，网站一般会通知观众们（通知）。以上场景用代码实现如下:

首先我们需要个主播,主播有自己的名字和直播的游戏，还有一个直播打游戏的方法。

package com.java.pubsub;

import java.util.Observable;

public class Player extends Observable{
    
    public Player(String name){
        this.name = name;
        PlayerManage.getInstance().register(this);
    }
    
    public void play(){
        String title = "开播了，先"+this.game+"再吃鸡";
        this.setChanged();
        this.notifyObservers(title);
    }
    
    private String name;
    private String game;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGame() {
        return game;
    }
    public void setGame(String game) {
        this.game = game;
    }
    
    
    
}

然后是我们的观众,我们的观众有关注主播和取消关注的两个方法之外，还有个提示主播上线打游戏的方法

package com.java.pubsub;

import java.util.Observable;
import java.util.Observer;

public class Viewer1 implements Observer{
    
    public void subscribe(String playerName){
        Player player = PlayerManage.getInstance().get(playerName);
        if(player!=null){
            player.addObserver(this);
        }
    }
    
    public void unsubscribe(String playerName){
        Player player = PlayerManage.getInstance().get(playerName);
        if(player!=null){
            player.deleteObserver(this);
        }
    }
    
    
    @Override
    public void update(Observable o, Object arg) {
        String title = (String) arg;
        if(o instanceof Player){
            Player player = (Player) o;
            System.out.println("收到推送=="+player.getName()+":"+title);
            System.out.println("我去看"+player.getName()+"直播"+player.getGame()+"游戏");
        }
    }

}

在主播的代码和观众的代码中出现了个PlayerManage，主播那么多当然有个超管来管管了。。超管会在主播上线或者注册的时候开始管理主播（添加和获取），在主播播放不良内容后也可以封停主播（remove）

package com.java.pubsub;

import java.util.HashMap;
import java.util.Map;

public class PlayerManage {
    
    private Map<String,Player> playerMap = new <String,Player>HashMap();
    
    public void register(Player player){
        playerMap.put(player.getName(), player);
    }
    
    public Player get(String playerName){
        return playerMap.get(playerName);
    }
    
    public void remove(Player player){
        playerMap.remove(player.getName());
    }
    
    private PlayerManage(){}
    
    public static PlayerManage getInstance(){
        return PlayerManageInstance.manage;
    }
    
    private static class PlayerManageInstance{//全站只有一个超管- - ！
        private static PlayerManage manage=new PlayerManage();
    }
}

我们测试一下

package com.java.pubsub;

import java.util.Observable;

public class Test {
    public static void main(String[] args) {
        Player player=new Player("张三");
        player.setGame("CS:GO");
        
        Viewer1 viewer1=new Viewer1();
        viewer1.subscribe("张三");
        
        player.play();
        
    }
}

结果为：

观察者模式分离了观察者和被观察者二者的责任，这样让类之间各自维护自己的功能，专注于自己的功能，会提高系统的可维护性和可重用性。

 总结一下，定义：观察者模式（有时又被称为发布-订阅模式、模型-视图模式、源-收听者模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实作事件处理系统。