设计模式之观察者模式

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

本人对于设计模式的学习，仅供参考！

---

一、观察者模式Observer

1.简介

观察者模式中，一个目标物件管理所有相依于他的观察者物件，并且在它身本状态发生改变时，主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。
在观察者模式中，主体是通知的发布者，他发出通知时并不需要知道谁是他的观察者，可以有任意数目的观察者订阅订阅并接收通知。观察者模式不仅被广泛应用于软件界面元素之间的交互，在业务对象之间的交互、权限管理等方面也有广泛的应用。

二、代码实现

1.角色

1.抽象主题
他把所有观察者对象保存到一个聚集里，每个主题可以有任何数量的观察者。抽象主题提供一个接口，可以增加或删除观察者对象。

2.具体主题
将相关状态存入具体观察者对象，在具体主题内部状态发生改变时，给所有登记过的观察者发出通知。

3.抽象观察者
为所有的具体观察者定义一个接口，在得知主题通知时更新自己。

4.具体观察者
实现抽象观察者角色所要求的更新接口，以便使本身状态与主体协调。

5.事件类
用于记录具体事件并传入观察者。

2.代码

//具体事件
public class Event {
    //事件时间
    private Date time;
    //时间地点
    private String address;
    //被观察者
    private Children source;

    public Event(Date time, String address, Children source) {
        this.time = time;
        this.address = address;
        this.source = source;
    }
    public Date getTime() {
        return time;
    }
    public void setTime(Date time) {
        this.time = time;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Children getSource() {
        return source;
    }
    public void setSource(Children source) {
        this.source = source;
    }
}

//被观察者抽象类
public abstract class Children {
    //状态
    private  boolean cry=false;
    //持有的观察者集合
    private List<Observer> observers=new ArrayList<>();

    public List<Observer> getObservers() {
        return observers;
    }

    public void setCry(boolean cry) {
        this.cry = cry;
    }

    public boolean isCry() {
        return cry;
    }
    //由具体类实现
    abstract public void wakeupCry();
    abstract public void wakeup();
    abstract public void add(Observer observer);
}

//被观察者具体类
public class Baby extends Children {
    //将观察者放入集合中
    public void add(Observer observer){
        super.getObservers().add(observer);
    }
    //被观察者发生改变
    @Override
    public void wakeupCry() {
        super.setCry(true);
        System.out.println("呜呜呜呜呜~~~~");
        //新建具体事件
        Event event=new Event(new Date(),"bed",(Children) this);
        for (int i = 0; i < super.getObservers().size(); i++) {
            //通知观察者
            super.getObservers().get(i).update(event);
        }
    }
    //被观察者发生改变
    @Override
    public void wakeup() {
        super.setCry(false);
        //新建具体事件
        Event event=new Event(new Date(),"bed",(Children) this);
        for (int i = 0; i < super.getObservers().size(); i++) {
            //通知观察者
            super.getObservers().get(i).update(event);
        }
    }
}

//观察者接口
public interface Observer {
    public void update(Event e);
}

//观察者1
public class MumObserver implements Observer {
    @Override
    public void update(Event e) {
        if(e.getSource().isCry()){
            System.out.println("妈妈亲亲~~~~~~~~~~~~~~~~");
        }else {
            System.out.println("宝宝来和妈妈玩~~~~~~~~~~~~");
        }
    }
}

//观察者2
public class DadObserver implements Observer{
    @Override
    public void update(Event e) {
        if (e.getSource().isCry()){
            System.out.println("乖~~~~~~~~~~~~");
        }else {
            System.out.println("不许闹~~~~~~~~~");
        }
    }
}

---

总结

优点：观察者和被观察者是抽象耦合的，解除了主题和具体观察者的耦合，建立一套触发机制。
缺点：开发和调试比较复杂，而且java中消息通知默认是顺序执行，一个卡顿会影响整体效率。在这种情况下一般考虑采用异步方式。