设计模式之观察者模式

一、定义：

　　观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

二、观察者模式中需要如下几种角色：

　　　1、Subject：抽象主题（抽象被观察者），主要提供对观察者对象集合的增、删和通知方法。

　　　2、ConcreteSubject：具体主题（具体被观察者），将所有观察者放到集合里，再具体主题的内部状态发生变化时，给所有注册过的观察者发送通知。

　　　3、Observer：抽象观察者，是观察者的抽象类，它定义了一个更新方法，使得再得到被观察者通知时，即时更新自己。

　　　4、ConcrereObserver：具体观察者，实现抽象观察者的更新方法，更新自己。

三、观察者模式简单实现

1、故事情景：企业有一个人源库系统管理所有人员基本信息，还有一个是财务系统和钉钉，财务和钉钉都紧密和人员信息紧密挂钩，假设人源库是被观察者，财务和钉钉是观察者，当人员信息被修改时需要即时通知财务和钉钉更新。

2、观察者模式UML类图：

3、让我们来看看代码如何实现的

抽象观察者（Observer）

　　里面定义了一个更新的抽象方法

public interface IObserverService {
    void update(PeopleEntity peopleEntity);
}

具体观察者（ConcrereObserver）

　　不同观察者实现抽象方法

/**
 *@author : lsy
 *@description: 钉钉具体观察者 
　5 */
@Service
public class DingDingObserverImpl implements IObserverService{
    @Override
    public void update(PeopleEntity peopleEntity) {
        System.out.println("钉钉:"+peopleEntity.toString());
    }
}

/**
 *@author : lsy
 *@description: 财务具体观察者
*/
@Service
public class FinanceObserverImpl implements IObserverService{
    @Override
    public void update(PeopleEntity peopleEntity) {
        System.out.println("财务系统:"+peopleEntity.toString());
    }
}

抽象被观察者（Subject）

　　定义了新增、移除、通知观察者的抽象方法

/**
 *@author : lsy
 *@description: 抽象被观察者
*/
public interface ISubjectService {
    //增加观察者
    void attach(IObserverService observerService);

    //移除观察者
    void detach(IObserverService observerService);

    //通知观察者
    void notice(PeopleEntity peopleEntity);
}

具体被观察者（ConcreteSubject）

　　创建一个用于存放观察者List集合，并实现抽象方法

/**
 *@author : lsy
 *@description: 人源库具体被观察者 5 */
@Service
public class PeopleBasicSubjectImpl implements ISubjectService{
    private List<IObserverService> observerServiceList = new ArrayList<>();

    /**
     * 增加观察者
     * @param observerService
     */
    @Override
    public void attach(IObserverService observerService) {
        observerServiceList.add(observerService);
    }

    /**
     * 移除观察者
     * @param observerService
     */
    @Override
    public void detach(IObserverService observerService) {
        observerServiceList.remove(observerService);
    }

    /**
     * 通知观察者
     */
    @Override
    public void notice(PeopleEntity peopleEntity) {
        System.out.println("人源库新增:"+peopleEntity.toString());
        observerServiceList.forEach(observer -> observer.update(peopleEntity));
    }
}

启动类：

/**
 *@author : lsy
 *@description: 启动类 5 */
@SpringBootApplication
public class StartClass {
    public static void main(String[] args) {
        PeopleEntity peopleEntity = new PeopleEntity(1, "测试", "后端", "小菜鸟");
        //创建两个观察者
        IObserverService dingObserver = new DingDingObserverImpl();
        IObserverService financeObserver = new FinanceObserverImpl();
        //被观察者具体实现类
        ISubjectService peopleBasicSubject = new PeopleBasicSubjectImpl();
        //添加观察者
        peopleBasicSubject.attach(dingObserver);
        peopleBasicSubject.attach(financeObserver);
        //通知观察者
        peopleBasicSubject.notice(peopleEntity);

    }
}

 控制台输出：

总结：　

使用观察者模式的场景：
　　关联行为场景，需要注意的是，关联行为是可拆分的，而不是“组合”关系。
　　事件多级触发场景。
　　跨系统的消息交换场景，如消息队列、事件总线的处理机制。
优点：
　　解除耦合，让耦合的双方都依赖于抽象，从而使得各自的变换都不会影响另一边的变换。

缺点：
　　在应用观察者模式时需要考虑一下开发效率和运行效率的问题，程序中包括一个被观察者、多个观察者，开发、调试等内容会比较复杂，而且在Java中消息的通知一般是顺序执行，那么一个观察者卡顿，会影响整体的执行效率，在这种情况下，一般会采用异步实现。