java设计模式之观察者模式

java设计模式之观察者模式

今天终于有时间可以学习下java设计模式了，之前总是因为这样那样的原因（借口）没有仔细去看java设计模式。今天看的是java设计模式中的一个常用的设计模式–观察者模式.
下面我就自己对观察者模式的一些理解做一下总结吧.

1.观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。(需要监听的对象).
2.当这个主题对象（被观察者）在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己.
3.适当利用观察者模式，可以降低程序的耦合性，提高程序的健壮性和可维护性.
4.观察者模式就像是微信订阅号一样，用户订阅（观察者），订阅号（被观察者），当订阅号有新的内容时就推送给订阅用户（通知），订阅用户收到通知后便可查看内容（根据通知做出相应的改变）.

观察者模式主要涉及的一些对象有：

1.被观察者抽象集合对象Subject
2.具体被观察者ConcreteSubject
3.观察者对象接口Observer
4.具体观察者对象ConcreteObserver

被观察者抽象集合对象Subject:

    import java.util.ArrayList;
    import java.util.List;
    public abstract class Subject {
        private List<Observer> observers = new ArrayList<>();
        /**
         * 注册观察者
         * @param observer
         */
        public void registerObserver(Observer observer){
            observers.add(observer);
        }
        /**
         * 取消注册观察者
         * @param observer
         */
        public void unRegisterObserver(Observer observer){
            observers.remove(observer);
        }
        /**
         * 取消注册所有观察者
         */
        public void unRegisterAllObserver(){
            observers.clear();
        }
        /**
         * 通知所有已注册的观察者
         * @param newState
         */
        public void notifyObservers(String newState){
            for(Observer observer : observers){
                observer.update(newState);
            }
        }
    }

具体被观察者ConcreteSubject

    public class ConcreteSubject extends Subject{
        private String state;

        public String getState() {
            return state;
        }

        public void setState(String state) {
            this.state = state;
        }

        public ConcreteSubject(){}

        public ConcreteSubject(String state){
            this.state = state;
        }

        /**
         * 对象改变事件
         * @param newState
         */
        public void change(String newState){
            state = newState;
            System.out.println("notify state changed:"+state);
            this.notifyObservers(newState);
        }
    }

观察者对象Observer

public interface Observer {

    /**
     * 更新接口
     * @param state
     */
    public void update(String state);
}

public class ConcreteObserver implements Observer{

    private String observerState;

    @Override
    public void update(String state) {
        observerState = state;
        System.out.println("state update:"+observerState);
    }

}

测试用例：

public class Test {

    public static void main(String[] args) {
        /**
         * 被观察对象
         */
        ConcreteSubject concreteSubject = new ConcreteSubject();

        /**
         * 观察者
         */
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        Observer observer3 = new ConcreteObserver();

        /**
         * 注册观察者
         */
        concreteSubject.registerObserver(observer1);
        concreteSubject.registerObserver(observer2);
        concreteSubject.registerObserver(observer3);

        concreteSubject.setState("state");
        concreteSubject.change("new state");
    }
}

输出结果：

notify state changed:new state
state update:new state
state update:new state
state update:new state

总结：

观察者模式实现的大体思路是这样的：
首先是定义一个观察者对象(Observer),然后在被观察者的抽象类中（Subject）定义观察者的注册、注销以及通知的功能，在具体的被观察者对象中实现对该对象的状态改变（public void change(String newState)），以及调用this.notifyObservers(newState);通知所有观察者状态改变的情况，从而使得观察者做出相应的动作.

思考：

观察者模式中一个被观察对象可以有多个观察者同时观察，java中消息的通知默认是顺序执行的，如果其中一个观察者出现问题，可能会影响到整个程序的运行效率，此时应该采取什么样的方式避免呢？