设计模式之观察者模式

大家上学时最害怕的是什么？是不是还被“班主任突然出现在你后面”的恐惧支配着？时不时就得往窗口、门口望一望，老师没过来就接着看小说，老师一过来当然得假装着写作业。万一我们坐在靠近里面的，不方便观察，这时候我们就只能让坐在窗边的王XX代劳了，王XX一看到老师来了，就喊一声,这时我们就明白怎么回事了。

一、定义

定义：观察者模式是软件 设计模式 的一种。在此种模式中，一个 目标物件管理所有相依于它的观察者物件 ，并且在 它本身的状态改变时主动发出通知 。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。

注意点：

1、被观察者管理观察者

2、被观察者状态改变时主动发出通知

二、UML类图

在文章开头的描述中，“王XX”看到老师来了就给其他同学发个信号，通知一下。“王XX”是被其他同学观察，即为被观察者。 其他同学则为观察者。

我们定义了一个

Oberable接口，被观察者接口，接口中定义了四个方法：

（1）teacherLeave()            用来发出消息，表示老师离开了

（2）teacherComeBack()   用来发出消息，表示老师回来了

（3）addNotificationStudent()   “王XX”同学不可能通知所有同学啊，需要通知的同学需要事先跟“王XX”同学说下。

（4）deleteNotificationStudent()  "小丫"同学，现在不需要通知了，通过这个方法让“王XX”同学不再通知她

WangStudent类，表示“王XX”，保存需要通知的同学名单，老师来了就通知这些同学。

IObservor观察者接口，有个方法用来接收“王XX”同学发来的通知。

ObersorStuLi、ObersorStuZhang，李同学、张同学，具体的观察类。

三、代码实现

被观察者接口

package com.design.observor;

public interface Observable {

    public void teacherLeave();

    public void teacherComeBack();

    public void addNotificationStudent(IObservor observor);

    public void deleteNotificationStudent(IObservor observor);

}复制代码

被观察者“王XX”同学

package com.design.observor;

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

public class WangStudent implements Observable {

    private int state;
    //需要通知的名单。管理观察者，对应定义注意点1
    private List<IObservor> obserbors;

    public WangStudent(){
        obserbors = new ArrayList<>();
    }

    //通知需要通知的同学，老师走了
    @Override
    public void teacherLeave() {
        state = 1;
        //被观察者，主动发出通知，对应定义注意点2
        Iterator<IObservor> iterator = obserbors.listIterator();
        while (iterator.hasNext()){
            iterator.next().updateOperation(state);
        }
    }

    //通知需要通知的同学，老师来了
    @Override
    public void teacherComeBack() {
        state = 0;
        Iterator<IObservor> iterator = obserbors.listIterator();
        while (iterator.hasNext()){
            iterator.next().updateOperation(state);
        }
    }
    //增加需要通知的同学
    @Override
    public void addNotificationStudent(IObservor observor) {
        obserbors.add(observor);
    }
    //删除不需要通知的同学
    @Override
    public void deleteNotificationStudent(IObservor observor) {
        obserbors.remove(obserbors);
    }
}复制代码

观察者接口

package com.design.observor;

public interface IObservor {

    public void updateOperation(int state);
}复制代码

观察者同学，“李同学”、“张同学”

package com.design.observor;

public class ObservorStuLi implements IObservor{

    @Override
    public void updateOperation(int state) {
        if(state == 0){
            System.out.println("LiXX：老师来了，把小说收了，假装做题！！");
        }else{
            System.out.println("LiXX：老师走了，继续看小说！！");
        }
    }
}
复制代码

package com.design.observor;

public class IObservorStuZhang implements IObservor {
    @Override
    public void updateOperation(int state) {
        if(state == 0){
            System.out.println("ZhangXX：老师来了，停止跟XX调情，假装做题！！");
        }else{
            System.out.println("ZhangXX：老师走了，继续跟XX调情！！");
        }
    }
}复制代码

测试类

package com.design.observor;

public class TestMain {

    public static void main(String[] args) {
        Observable wangStu = new WangStudent();

        IObservor liStu = new ObservorStuLi();
        IObservor zhangStu = new IObservorStuZhang();
        //李同学、张同学增加到需要通知的名单中
        wangStu.addNotificationStudent(liStu);
        wangStu.addNotificationStudent(zhangStu);
        //老师来了
        wangStu.teacherComeBack();
        //老师走了
        wangStu.teacherLeave();

    }
}复制代码

测试结果

好了，我们完成了这个场景的编程，老师来了、走了，“王XX”同学都通知了张同学，还有李同学，这时张同学、李同学就可以放心玩他们想玩的了。

四、总结

使用场景：当一个对象的改变需要同时改变其他对象，且不知道具体有多少对象待改变时（我们例子中需要通知的同学是通过addNotificationStudent方法动态增加进去的），可以考虑使用观察者模式（ 来自《大话设计模式》 ）

（一）、优点

1、观察者和被观察者是抽象耦合的。

（二）、缺点

1、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，导致死循环。（A通知B,B通知A,A通知B,B通知A ......）