对象心理干预中的需要层次理论（对象间的一种一对多的依赖关系）
对象心理干预中的需要层次理论（对象间的一种一对多的依赖关系）publicclassClient{ publicstaticvoidmain(String[]args){ ISubjectsubject=newSubject(); //创建观察者 Observerobserver1=newConcrereObserver("subject1"); Observerobserver2=newConcrereObserver("subject2"); Observerobserver3=newConcrereObserver("subject3"); //添加观察者 subject.addObserver(observer1); subject.addObserver(observer2); subject.addObserver(observer3); //被观察者发生变更，通知所有观察
0x01：观察者模式入门
观察者模式[ 又称发布(publish)-订阅(Subscribe)模式 ]，它定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。其实就是一种通知机制，让发送通知的一方（被观察方）和接收通知的一方（观察者）能彼此分离，互不影响。UML类图如下：
从类图上看主要包含如下角色：
- Subject（抽象主题）: 被观察者 抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
- ConcreteSubject（具体主题）：被观察者，该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
- Observer（抽象观察者）：是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
- ConcrereObserver（具体观察者）：实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。
Subject（抽象主题）：
publicinterfaceISubject{
publicvoidaddObserver(Observerobserver);
publicvoiddeleteObserver(Observerobserver);
publicvoidnotifyObserver();
}
ConcreteSubject（具体主题）：
publicclassSubjectimplementsISubject{
//观察者数组
privateVector<Observer>observers=newVector<>();
//增加一个观察者
@Override
publicvoidaddObserver(Observerobserver){
this.observers.add(observer);
}
//删除一个观察者
@Override
publicvoiddeleteObserver(Observerobserver){
this.observers.remove(observer);
}
//通知所有观察者
@Override
publicvoidnotifyObserver(){
for(Observerobserver:this.observers){
observer.update();
}
}
}
Observer（抽象观察者）
publicinterfaceObserver{
//更新
publicvoidupdate();
}
}
ConcrereObserver（具体观察者)
publicclassConcrereObserverimplementsObserver{
privateStringname;
publicConcrereObserver(Stringname){
this.name=name;
}
@Override
publicvoidupdate(){
System.out.println(name);
}
}
客户端Client：
publicclassClient{
publicstaticvoidmain(String[]args){
ISubjectsubject=newSubject();
//创建观察者
Observerobserver1=newConcrereObserver("subject1");
Observerobserver2=newConcrereObserver("subject2");
Observerobserver3=newConcrereObserver("subject3");
//添加观察者
subject.addObserver(observer1);
subject.addObserver(observer2);
subject.addObserver(observer3);
//被观察者发生变更，通知所有观察者
subject.notify();
}
}
0x02：JDK提供的观察者模式接口
以上是观察者模式的最简单介绍，其实如果大家留意的话，发现JDK已经内置了观察者模式的抽象实现，对应的类是：
java.util.Observer
java.util.Observable
java.util.Observer（观察者抽象）
packagejava.util;
publicinterfaceObserver{
voidupdate(Observableo Objectarg);
}
java.util.Observable（被观察者）
packagejava.util;
publicclassObservable{
privatebooleanchanged=false;
privateVector<Observer>obs;
publicObservable(){
obs=newVector<>();
}
publicsynchronizedvoidaddObserver(Observero){
if(o==null)
thrownewNullPointerException();
if(!obs.contains(o)){
obs.addElement(o);
}
}
publicsynchronizedvoiddeleteObserver(Observero){
obs.removeElement(o);
}
publicvoidnotifyObservers(){
notifyObservers(null);
}
publicvoidnotifyObservers(Objectarg){
Object[]arrLocal;
synchronized(this){
if(!changed)
return;
arrLocal=obs.toArray();
clearChanged();
}
for(inti=arrLocal.length-1;i>=0;i--)
((Observer)arrLocal[i]).update(this arg);
}
publicsynchronizedvoiddeleteObservers(){
obs.removeAllElements();
}
synchronizedvoidsetChanged(){
changed=true;
}
protectedsynchronizedvoidclearChanged(){
changed=false;
}
publicsynchronizedbooleanhasChanged(){
returnchanged;
}
publicsynchronizedintcountObservers(){
returnobs.size();
}
}
可以看出来与自己的设计大体一致。不过也不能不感叹JDK的设计者考虑的问题还是不自己考虑的多。JDK多设计了一个标识位，同时考虑了线程安全问题。
0x03：观察者模式的思考
从抽象被观察者代码看，里面定义了一个容器存放观察者。当被观察者发生变更时，需要循环通知观察者。如果使用观察者模式处理这样一个业务场景：观察者非常多，而且观察者的update()方法调用时间可能非常长。那一定出现业务延时的问题，这样的话就不在适合使用观察者模式了。那这样的业务场景需要采用什么解决方案呢？我觉得采用消息队列MQ非常适合
