观察者模式

观察者模式的定义：

定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，它的所有的依赖者都会收到通知并自动更新。

观察者模式的类图：

根据类图自定义主题、观察者接口：

package observer;

/**
 * 主题接口
 * @author 发挥哥
 *
 */
public interface Subject {
	/**
	 * 注册观察者
	 * @param observer 观察者对象
	 */
	void registerObserver(Observer observer);
	/**
	 * 移除观察者
	 * @param observer 观察者对象
	 */
	void removeObserver(Observer observer);
	/**
	 * 通知所有观察者
	 */
	void notifyObservers();
}

package observer;

/**
 * 观察者接口
 * @author 发挥哥
 *
 */
public interface Observer {
	/**
	 * 主题通知所有观察者，执行该方法
	 * @param msg
	 */
	void update(String msg);
}

创建主题类和观察者类：

package observer;

import java.util.ArrayList;
import java.util.List;
import observer.Subject;

/**
 * 自定义主题类，实现自定义主题接口
 * @author 发挥哥
 *
 */
public class TestSubject implements Subject {
	/**
	 * 所有注册到该主题的观察者
	 */
	private List<Observer> observers=new ArrayList<>();
	/**
	 * 主题的状态
	 */
	private String msg;

	@Override
	public void registerObserver(Observer observer) {
		// TODO Auto-generated method stub
		if(observers!=null&&observer!=null)
			observers.add(observer);
	}

	@Override
	public void removeObserver(Observer observer) {
		// TODO Auto-generated method stub
		if(observers.contains(observer)) {
			observers.remove(observer);
		}
	}

	@Override
	public void notifyObservers() {
		// TODO Auto-generated method stub
		observers.stream().forEach(observer->{
			observer.update("主题更新了，大家注意:"+this.msg);
		});
	}
	
	/**
	 * 编辑主题的状态后，通知所有观察者
	 * @param msg
	 */
	public void editMsg(String msg) {
		this.msg = msg;
		notifyObservers();
	}
}

package observer;

/**
 * 观察者1
 * @author 发挥哥
 *
 */
public class Test1Observer implements Observer {
	/**
	 * 创建观察者对象时，将其注册到指定的主题
	 * @param subject
	 */
	public Test1Observer(Subject subject) {
		subject.registerObserver(this);
	}

	/**
	 * 当主题状态变化时，通过调用该方法通知观察者
	 */
	@Override
	public void update(String msg) {
		// TODO Auto-generated method stub
		System.out.println(this.getClass().getName()+"收到主题发来的消息："+msg);
	}

}

package observer;

/**
 * 观察者2（仅为测试，实现与观察者1一样）
 * @author 发挥哥
 *
 */
public class Test2Observer implements Observer {
	
	public Test2Observer(Subject subject) {
		subject.registerObserver(this);
	}

	@Override
	public void update(String msg) {
		// TODO Auto-generated method stub
		System.out.println(this.getClass().getName()+"收到主题发来的消息："+msg);
	}

}

创建测试方法：

package observer;

public class TestMain {

	public static void main(String[] args) {
		//创建主题
		TestSubject subject=new TestSubject();
		//创建观察者1并注册到主题
		Observer observer1=new Test1Observer(subject);
		//创建观察者2并注册到主题
		Observer observer2=new Test2Observer(subject);
		//主题进行2次状态修改
		subject.editMsg("第一次调整！");
		subject.editMsg("第二次调整！");
	}
}

测试结果如下：

observer.Test1Observer收到主题发来的消息：主题更新了，大家注意:第一次调整！
observer.Test2Observer收到主题发来的消息：主题更新了，大家注意:第一次调整！
observer.Test1Observer收到主题发来的消息：主题更新了，大家注意:第二次调整！
observer.Test2Observer收到主题发来的消息：主题更新了，大家注意:第二次调整！

以上是自定义主题和观察者接口及其实现，JDK中已经帮我们实现了观察者模式，借助于java.util.Observable和java.util.Observer：

package java.util;

public class Observable {
    private boolean changed = false;
    private Vector<Observer> obs;

    public Observable() {
        obs = new Vector<>();
    }

    public synchronized void addObserver(Observer o) {
        if (o == null)
            throw new NullPointerException();
        if (!obs.contains(o)) {
            obs.addElement(o);
        }
    }

    public synchronized void deleteObserver(Observer o) {
        obs.removeElement(o);
    }

    public void notifyObservers() {
        notifyObservers(null);
    }

    public void notifyObservers(Object arg) {
        Object[] arrLocal;

        synchronized (this) {
            if (!changed)
                return;
            arrLocal = obs.toArray();
            clearChanged();
        }

        for (int i = arrLocal.length-1; i>=0; i--)
            ((Observer)arrLocal[i]).update(this, arg);
    }

    public synchronized void deleteObservers() {
        obs.removeAllElements();
    }

    protected synchronized void setChanged() {
        changed = true;
    }

    protected synchronized void clearChanged() {
        changed = false;
    }

    public synchronized boolean hasChanged() {
        return changed;
    }

    public synchronized int countObservers() {
        return obs.size();
    }
}

package java.util;

public interface Observer {
    void update(Observable o, Object arg);
}

类java.util.Observable和接口java.util.Observer比较简单，直接借此创建主题和观察者类：

package observer.jdk;

import java.util.Observable;
/**
 * 主题1
 * @author 发挥哥
 *
 */
public class MySubject extends Observable {
	private String msg;

	/**
	 * 编辑主题消息，并将变动标志置true，通知所有观察者，再将标志置false
	 * @param msg
	 */
	public void editMsg(String msg) {
		if(msg==null) {
			this.msg = msg;
			setChanged();
			notifyObservers("主题将消息置空！");
			clearChanged();
			return;
		}
		if(this.msg!=null&&msg!=null&&this.msg.equals(msg)) {
			return;
		} 
		
		this.msg = msg;
		setChanged();
		notifyObservers("主题更新消息："+this.msg);
		clearChanged();		
	}
}

package observer.jdk;

import java.util.Observable;
/**
 * 主题2（仅为测试，与观察者1实现一样）
 * @author 发挥哥
 *
 */
public class OtherSubject extends Observable {
	private String msg;

	public void editMsg(String msg) {
		if(msg==null) {
			this.msg = msg;
			setChanged();
			notifyObservers("主题将消息置空！");
			clearChanged();
			return;
		}
		if(this.msg!=null&&msg!=null&&this.msg.equals(msg)) {
			return;
		} 
		
		this.msg = msg;
		setChanged();
		notifyObservers("主题更新消息："+this.msg);
		clearChanged();		
	}
}

package observer.jdk;

import java.util.Observable;
import java.util.Observer;
/**
 * 观察者
 * @author 发挥哥
 *
 */
public class MyObserver implements Observer {
	/**
	 * 通过该方法将观察者自己注册到主题
	 * @param observable
	 */
	public void registerToSubject(Observable observable) {
		observable.addObserver(this);
	}

	@Override
	public void update(Observable o, Object arg) {
		System.out.println(this.getClass().getName()+"收到主题"+o.getClass().getName()+"更新消息："+arg);
	}
}

编写测试方法：

package observer.jdk;

public class MyTest {
	public static void main(String[] args) {
		//创建主题1、主题2
		MySubject subject1=new MySubject();
		OtherSubject subject2=new OtherSubject();
		//创建观察者
		MyObserver observer=new MyObserver();
		//将观察者注册到主题1、主题2
		observer.registerToSubject(subject1);
		observer.registerToSubject(subject2);
		//主题1、主题2分别更新状态
		subject1.editMsg("主题一更新");
		subject2.editMsg("主题二更新");
	}
}

测试结果如下：

observer.jdk.MyObserver收到主题observer.jdk.MySubject更新消息：主题更新消息：主题一更新
observer.jdk.MyObserver收到主题observer.jdk.OtherSubject更新消息：主题更新消息：主题二更新

比较好的观察者模式应用是微信公众号，公众号就是我们的主题，粉丝就是观察者。功能如下：

• 1、公众号就是主题，业务就是推送新消息；
• 2、观察者订阅主题，有新的消息自动送来；
• 3、当不想要此主题消息时，取消订阅即可；

总结：

观察者模式的实现方式是在观察者调用主题的addObserver方法将自己添加到主题持有的观察者列表里，主题在需要的时候调用notifyObservers遍历观察者列表，并分别调用观察者的update方法。

打个比方，主题就是婚介所，多个观察者就是多个未婚大龄男青年，男青年注册会员之后将自己的联系方式交给婚介所，婚介所在合适的时候（比如来了适龄女青年），就会挨个给注册的男青年打电话通知。