从王者荣耀看设计模式（七.观察者模式）

从王者荣耀看设计模式（观察者模式）

一.简介：

王者荣耀是一款RGB游戏，玩家操作各种英雄协同作战以赢得比赛的胜利。在游戏中，交流机制显得尤为重要。王者荣耀存在一种简单的交流机制：在小地图旁边有一个快捷交流的按钮，在游戏中的任意玩家可通过按钮发送快捷语音，队友能实时接收消息，以配合队友赢得比赛

二.观察者模式

观察者模式(Observer Pattern)也叫发布订阅模式(Public/subscribe)，定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。)

• 观察者模式的使用场景：

1. 关联行为场景。（关联行为是可拆分的，而不是"组合"关系
2. 事件多级触发场景

• 这其中的设计原则有:

1. 体现了一个设计原则就是** 为了交互对象之间的松耦合设计而努力 **
   争取让对象之间的互相依赖降到最低

2. 观察者模式的通用类图:
   

3. 观察者模式所涉及的角色有：
   ● Observerable被观察者：定义被观察者必须实现的职责，它必须能够动态地增加、取消观察者。它一般是抽象类或者是实现类，仅仅完成作为被观察者必须实现的职责：管理观察者并通知观察者
   ● Observer观察者：观察者接收到消息后，即进行update(更新方法)操作，对接收到的信息进行处理
   ● ConcreteSubject **具体的被观察者：定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知
   ● ConcreteObserver具体的观察者：每个观察在接收到消息后的处理反应是不同，各个观察者有自己的处理逻辑

• 观察者模式的优点：

1. 观察者模式和被观察者模式之间是抽象耦合，如此设计,则不管是增加观察者还是被观察者都非常容易扩展
2. 建立一套触发机制,观察者模式可以完美实现触发链

• 观察者模式的缺点：

1. 多级触发效率较低
2. 一个被观察者，多个观察者，开发和调试比较复杂，而且在java中消息的通知默认是顺序执行，一个观察者卡壳，会影响整体的执行效率。在这种情况下，一般考虑采用异步的方式

三.结构图

四.设计类图

五.代码实现

Observerable(被观察者类)

package com.game.Observerable;

import com.game.Observer.Observer;

/***
 * 抽象被观察者接口
 * 声明了添加、删除、通知观察者方法
 *
 */

public interface Observerable {
    public void registerObserver(Observer o);
    public void removeObserver(Observer o);
    public void notifyObserver();
}

SimpleHeroGame(ConcreteSubject类)

package com.game.Observerable;

import java.util.ArrayList;
import java.util.List;

import com.game.Observer.Observer;
/**
 * 被观察者
 * 实现了Observerable接口，对Observerable接口的三个方法进行了具体实现
 *
 */

public class SimpleHeroGame implements Observerable{
    private String message;
    private String heroName;
    private List<Observer> list;
    
    public SimpleHeroGame() {
        list = new ArrayList<Observer>();
    }

    public void registerObserver(Observer o) {
        list.add(o);
    }

    public void removeObserver(Observer o) {
        if(!list.isEmpty())
            list.remove(o);
    }

    public void notifyObserver() {
        for(int i = 0;i < list.size();i++) {
            Observer observer = list.get(i);
            observer.update(message);
        }
    }
    
    public void setInformation(String name,Observer o,String s) {
        this.message = s;
        this.heroName = name;
        System.out.println("英雄[" + heroName + "]发出消息:"+ message);
        removeObserver(o);
        notifyObserver();
        list.add(o);
    }
}

Observer(观察者类)

package com.game.Observer;

/***
 * 抽象观察者
 * 定义了一个update()方法，当被观察者调用notifyObservers()方法时，观察者的update()方法会被回调。
 */

public interface Observer {
    public void update(String message);
}

Hero(具体的观察者类)

package com.game.Observer;

/**
 * 观察者
 * 实现了update方法
 *
 */

public class Hero implements Observer{
    public String name;
    public String message;
    
    public Hero(String heroName) {
        this.name = heroName;
    }
    
    public void update(String message) {
        this.message = message;
        read();
    }
    
    public void read() {
        System.out.println(name + "接受消息:" + message);
    }
}

Test(测试类)

package com.game.Test;

import com.game.Observer.Hero;
import com.game.Observer.Observer;
import com.game.Observerable.SimpleHeroGame;

public class Test {
    public static void main(String [] args) {
        SimpleHeroGame HeroGlory = new SimpleHeroGame();
        
        Observer HanXin = new Hero("韩信");
        Observer HouYi = new Hero("后羿");
        Observer DianWei = new Hero("典韦");
        Observer DaJi = new Hero("妲己");
        Observer LiuShan = new Hero("刘禅");
        
        HeroGlory.registerObserver(HanXin);
        HeroGlory.registerObserver(HouYi);
        HeroGlory.registerObserver(DianWei);
        HeroGlory.registerObserver(DaJi);
        HeroGlory.registerObserver(LiuShan);
        HeroGlory.setInformation("妲己",DaJi,"开始撤退");
        
        System.out.println("---------------------------------------------------");
        HeroGlory.setInformation("后羿",HouYi,"发起进攻");
    }
}

运行结果：

六. 自带的观察者模式

Observer对象是观察者，Observable对象是被观察者。

1. 实现观察者模式
   实现观察者模式非常简单，
   [1]创建被观察者类，它继承自java.util.Observable类；
   [2]创建观察者类，它实现java.util.Observer接口；

对于被观察者类：
添加它的观察者：
void addObserver(Observer o)
addObserver()方法把观察者对象添加到观察者对象列表中

当被观察者中的事件发生变化时，执行
setChanged();
notifyObservers();
setChange()方法用来设置一个内部标志位注明数据发生了变化；notifyObservers()方法会去调用观察者对象列表中所有的Observer的update()方法，通知它们数据发生了变化。
只有在setChange()被调用后，notifyObservers()才会去调用update()。

对于观察者类，实现Observer接口的唯一方法update
void update(Observable o, Object arg)

形参Object arg，对应一个由notifyObservers(Object arg);传递来的参数，当执行的是notifyObservers();时，arg为null。

1. 结构图
   

2. 设计类图
   

3. 代码实现
   Hero（工具类)

package com.practice.Observer;

/*
 * hero类，封装英雄属性
 * @param heroName 英雄名字
 * @param heroProfession 英雄职业
 */

public class Hero {
    private String heroName;
    private String heroProfession;
    
    public Hero(String heroName,String heroProfession) {
        this.heroName = heroName;
        this.heroProfession = heroProfession;
    }
    
    public String getHeroName() {
        return heroName;
    }
    public void setHeroName(String heroName) {
        this.heroName = heroName;
    }
    public String getHeroProfession() {
        return heroProfession;
    }
    public void setHeroProfession(String heroProfession) {
        this.heroProfession = heroProfession;
    }
}

SimpleHeroGame(被观察者类)

package com.practice.Observable;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;

import com.practice.Observer.Hero;

/*
 * SimpleHeroGame类，被观察者类 
 */

public class SimpleHeroGame extends Observable{
    private List<Hero> list;
    private String message;
    private String heroPro;
    private String heroName;
    
    public SimpleHeroGame() {
        list = new ArrayList<Hero>();
    }
    
    public void measurementsChanged() {
        setChanged();
        notifyObservers();
    }
    
    public void addHero(Hero heroMessage) {
        list.add(heroMessage);
    }
    
    public void setMeasurements(Hero hero,String message) {
        this.heroName = hero.getHeroName();
        this.message = message;
        this.heroPro = hero.getHeroProfession();
        System.out.println(heroName + "[" + heroPro + "]" + "发出消息:" + message);
        System.out.println();
        list.remove(hero);
        measurementsChanged();
        list.add(hero);
    }
    
    
    public List <Hero> getList(){
        return list;
    }
    
    public String getMessage() {
        return message;
    }
}

HeroDisplay(观察者类)

package com.practice.Observer;

import java.util.ArrayList;
import java.util.List;
import java.util.Observable;
import java.util.Observer;

import com.practice.Observable.SimpleHeroGame;

public class HeroDisplay implements Observer{
    private String heroName;
    private String heroProfession;
    private String message;
    private Observable observable;
    private List<Hero> heroMess;
    
    public HeroDisplay(Observable observable) {
        heroMess = new ArrayList<Hero>();
        this.observable = observable;
        this.observable.addObserver(this);
    }
    
    public void update(Observable obs, Object arg) {
        if(obs instanceof SimpleHeroGame) {
            SimpleHeroGame weatherData = (SimpleHeroGame) obs;
            heroMess = weatherData.getList();
            message = weatherData.getMessage();
            for(Hero heros:heroMess) {
                System.out.println(heros.getHeroName() + "["+heros.getHeroProfession()+"] 收到消息:" + message);
            }
        }
    }
}

Test(测试类)

package com.practice.Test;

import com.practice.Observable.SimpleHeroGame;
import com.practice.Observer.HeroDisplay;
import com.practice.Observer.Hero;

public class Test {
    public static void main(String [] args) {
        SimpleHeroGame wd = new SimpleHeroGame();
        HeroDisplay ccd = new HeroDisplay(wd);
        
        Hero HanXin = new Hero("韩信","刺客");
        Hero DaJi = new Hero("妲己","法师");
        Hero LiuShan = new Hero("刘禅","辅助");
        Hero Kai = new Hero("铠","战士");
        Hero HouYi = new Hero("后羿","射手");
        
        wd.addHero(HanXin);
        wd.addHero(DaJi);
        wd.addHero(LiuShan);
        wd.addHero(Kai);
        wd.addHero(HouYi);
        
        wd.setMeasurements(DaJi,"发起进攻");
        System.out.println("-------------------------------");
        wd.setMeasurements(Kai, "开始撤退");
    }
}

运行结果

从王者荣耀看设计模式（七.观察者模式）

原文：https://www.cnblogs.com/miaowulj/p/11853668.html