设计模式-观察者模式

1.概念

观察者模式是一种行为类模式，定义对象间的一种一对多的依赖关系，当一个对象状态发生变化，则所有依赖于它的对象都会得到通知并自动更新；

有几个角色：

1>Subject

被观察者，可以是抽象类也可以是具体的类；持有一组观察者的列表，这里使用Vector而没有使用List的原因是因为Vector在多线程的情况下是线程安全的；另外还有三个方法，attach是添加观察者；detach是从容器中移除观察者；notify是通知所有观察者；

2>ConcreteSubject

具体的观察者，使用这个是为了扩展，可以在这个角色中定义具体的业务逻辑

3>Observer

观察者，一般是一个接口，只有一个update方法；在被观察者状态发生变化时，这个方法就会触发；

4>ConcreteObserver

具体的观察者；根绝实际的业务需求，可以有不同的观察者来处理不同的业务逻辑的变化；

2.观察者模式的实现

1>Subject

public abstract class Subject {  
       private Vector<Observer> obs = new Vector<Observer>();  
         
       public void addObserver(Observer obs){  
           this.obs.add(obs);  
       }  
       public void delObserver(Observer obs){  
           this.obs.remove(obs);  
       }  
       protected void notifyObserver(){  
           for(Observer o: obs){  
               o.update();  
           }  
       }  
       public abstract void doSomething();  
   }

注意，这里的notifyObserver是protected类型的，要通过子类来调用的；

2>ConcreteSubject

具体的观察者，一般会调用Subect的notifyObserver方法

public class ConcreteSubject extends Subject {  
       public void doSomething(){  
           System.out.println("被观察者事件反生");  
           this.notifyObserver();  
       }  
   }

3>Observer

观察者接口，一般只有一个update方法

public interface Observer {  
       public void update();  
   }

4>ConcreteObserver

具体的观察者，要实现update方法；里面是具体的业务逻辑

public class ConcreteObserver1 implements Observer {  
       public void update() {  
           System.out.println("观察者1收到信息，并进行处理。");  
       }  
   }  
   public class ConcreteObserver2 implements Observer {  
       public void update() {  
           System.out.println("观察者2收到信息，并进行处理。");  
       }  
   }

测试代码

public class Client {  
       public static void main(String[] args){  
           Subject sub = new ConcreteSubject();  
           sub.addObserver(new ConcreteObserver1()); //添加观察者1  
           sub.addObserver(new ConcreteObserver2()); //添加观察者2  
           sub.doSomething();  
       }  
   }

3.Java中的观察者

Java中已经有了类实现观察者模式；

Observer：观察者，抽象接口定义update方法；

Observable：被观察者，需要定义子类继承；

一个简单的demo

public class ConcreteObservable extends Observable {
    public void changeNotify(){
        setChanged();
        notifyObservers();
    }
}

public class ConcreteObserver1 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("观察者1收到信息，并进行处理。");
    }
}

public class ConcreteObserver2 implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("观察者2收到信息，并进行处理。");
    }
}

测试

public static void main(String[] args) {
        Observer concreteObserver1 = new ConcreteObserver1();
        Observer concreteObserver2 = new ConcreteObserver2();

        ConcreteObservable observable = new ConcreteObservable();
        observable.addObserver(concreteObserver1);
        observable.addObserver(concreteObserver2);
        observable.changeNotify();
    }