观察者模式

订阅者模式通常也成为发布-订阅模式，发布者也称为通知者，订阅者也称为观察者。通知者发出通知，各发布者则收到通知后做出相应的动作。由于存在不同的订阅者和通知者，所以将这两者抽象出来。

其实Subject和Observer是抽象类还是接口，这个是比较灵活的，取决于你的应用场景是怎样，总之就是要将它们抽象出来，方便不同的通知者和观察者来实现它们。

下面是代码实现。

首先是Subject抽象通知者。

package day_9_observer;

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

/**
 * 抽象通知者类
 * @author turbo
 *
 * 2016年9月13日
 */
public abstract class Subject {
    private List<Observer> observers = new ArrayList<Observer>();
    private String name;
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Subject(String name){
        this.name = name;
    }
    /**
     * 新增观察者
     * @param observer
     */
    public void attach(Observer observer){
        observers.add(observer);
    }
    
    /**
     * 移除观察者
     * @param observer
     */
    public void detach(Observer observer){
        observers.remove(observer);
    }
    
    /**
     * 通知观察者
     */
    public void notifyObservers(){
        for (Observer observer : observers){
            observer.update();
        }
    }
}

接着是抽象观察者。

package day_9_observer;

/**
 * 抽象订阅者
 * @author turbo
 *
 * 2016年9月13日
 */
public abstract class Observer {
    private String name;
    private Subject subject;
    
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Subject getSubject() {
        return subject;
    }

    public void setSubject(Subject subject) {
        this.subject = subject;
    }

    public Observer(String name, Subject subject){
        this.name = name;
        this.subject = subject;
    }
    
    public abstract void update();
}

下面分别是具体的通知者和订阅者。

package day_9_observer;

/**
 * 具体通知者
 * @author turbo
 *
 * 2016年9月13日
 */
public class ConcreteSubject extends Subject {
    /**
     * @param name
     */
    public ConcreteSubject(String name) {
        super(name);
    }

    private String action;        //这个在本例中并没有什么实际作用

    public String getAction() {
        return action;
    }

    public void setAction(String action) {
        this.action = action;
    }
    
}

package day_9_observer;

/**
 * 具体观察者
 * @author turbo
 *
 * 2016年9月13日
 */
public class ConcreteObserver extends Observer {
    /**
     * @param name
     * @param subject
     */
    public ConcreteObserver(String name, Subject subject) {
        super(name, subject);
    }

    /* (non-Javadoc)
     * @see day_9_observer.Observer#update()
     */
    @Override
    public void update() {
        System.out.println(super.getName() + "收到" + super.getSubject().getName() + "的通知");
    }

}

客户端代码。

package day_9_observer;

/**
 * 客户端
 * @author turbo
 *
 * 2016年9月13日
 */
public class Main {
    
    public static void main(String[] args){
        ConcreteSubject concreteSubject = new ConcreteSubject("通知者");
        ConcreteObserver observer = new ConcreteObserver("订阅者", concreteSubject);
        
        concreteSubject.attach(observer);
        concreteSubject.notifyObservers();
    }
}

输出结果：

这样我们就简单地完成了观察者模式。在《大话设计模式》中提到了，如果观察者是几个风马牛不相及的呢？我们现在是抽象成一个公共类，如果两个观察者无法抽象成一个公共类怎么办呢？《大话设计模式》中提到了利用“事件委托”来实现，由于此书是C#，但在Java中好像并没有线程的事件委托实现，在下一篇中会写利用“事件委托”来实现观察者模式，同样Java自带了Observer接口以提供对观察者模式的支持，下一篇我们也会利用JDK来实现观察者模式。