JAVA设计模式-09-观察者模式

参考：http://blog.****.net/pengjunlee/article/details/51707104

一、什么是观察者模式

观察者(Observer)模式是行为模式之一，它的作用是当一个被观察对象的状态发生变化时，能够自动通知相关的观察者对象，自动更新观察者对象中被观察对象的状态。它提供给关联对象一种同步通信的手段，使某个对象与依赖它的其他对象之间保持状态同步。


二、观察者模式的典型应用

观察者(Observer)模式多被应用于以下场景：
- 侦听事件驱动程序设计中的外部事件

- 侦听/监视某个对象的状态变化

- 发布者/订阅者(publisher/subscriber)模型中，当一个外部事件（新的产品，消息的出现等等）被触发时，通知邮件列表中的订阅者

三、观察者模式的结构

观察者模式中的角色及其职责如下：

抽象被观察者（Subject）角色：被观察对象的抽象类，为所有具体被观察者角色提供了一个统一接口，主要包括添加、删除、通知观察者对象方法，其内包含一个用以储存所有观察者对象的容器（Collection），当被观察者的状态发生变化时，需要通知容器中所有观察者对象，并维护（添加，删除，通知）观察者对象列表。

具体被观察者（ConcreteSubject）角色：被观察者的具体实现，包含一些基本的属性状态及其他操作，当具体被观察者的状态发生变化时，会给注册的所有观察者对象发送通知，以提示观察者对象们对其内被观察对象的状态进行更新。

抽象观察者（Observer）角色：这是一个抽象角色，通常被定义为一个接口，声明所有的具体观察者需实现的方法，当收到被观察对象状态发生变化的通知时更新自己。

具体观察者（ConcreteObserver）角色：观察者的具体实现，得到通知后将对内部被观察对象的状态进行更新，并完成一些具体的业务逻辑处理。

观察者模式结构示意源代码如下：

抽象被观察者（Subject）角色



[java] view plain copy
 


public abstract class Subject {  
    //用来保存注册过的观察者  
    private List<Observer> observers=new ArrayList<Observer>();  
    //注册一个观察者  
    public void registerObserver(Observer observer){  
        this.observers.add(observer);  
    }  
    //删除一个观察者  
    public void unregisterObserver(Observer observer){  
        this.observers.remove(observer);  
    }  
    //通知所有观察者进行状态更新  
    public void notifyObservers(Subject subject){  
        for(Observer o:observers){  
            o.update(subject);  
        }  
    }  
}

具体被观察者（ConcreteSubject）角色



[java] view plain copy
 


public class ConcreteSubject extends Subject {  
    //具体被观察者类可以具有自己的属性或状态  
    private String state;  
      
    public String getState() {  
        return state;  
    }  
    public void setState(String newState){  
          
        this.state = newState;  
          
        System.out.println("被观察者自身状态更新为：" + this.state);  
          
        //状态发生改变，通知所有观察者  
        this.notifyObservers(this);  
    }  
}

抽象观察者（Observer）角色



[java] view plain copy
 


public interface Observer{  
    //更新观察者的状态  
    public void update(Subject subject);  
}

具体观察者（ConcreteObserver）角色



[java] view plain copy
 


public class ConcreteObserverA implements Observer {  
    private ConcreteSubject subject;  
    public ConcreteSubject getSubject() {  
        return subject;  
    }  
    public void setSubject(ConcreteSubject subject) {  
        this.subject = subject;  
    }  
    @Override  
    public void update(Subject subject) {  
        this.subject=(ConcreteSubject)subject;  
        System.out.println("观察者A中被观察对象的状态更新为："+this.subject.getState());  
    }  
}



[java] view plain copy
 


public class ConcreteObserverB implements Observer {  
    private ConcreteSubject subject;  
    public ConcreteSubject getSubject() {  
        return subject;  
    }  
    public void setSubject(ConcreteSubject subject) {  
        this.subject = subject;  
    }  
    @Override  
    public void update(Subject subject) {  
        this.subject=(ConcreteSubject)subject;  
        System.out.println("观察者B中被观察对象的状态更新为："+this.subject.getState());  
    }  
}

编写一个客户端来测试一番。



[java] view plain copy
 


public class Client {  
    public static void main(String[] args) {  
        //创建被观察者对象  
        ConcreteSubject subject=new ConcreteSubject();  
        //创建观察者对象  
        ConcreteObserverA observerA=new ConcreteObserverA();  
        ConcreteObserverB observerB=new ConcreteObserverB();  
        //为被观察者对象注册观察者  
        subject.registerObserver(observerA);  
        subject.registerObserver(observerB);  
        subject.setState("复活中...");  
        System.out.println();  
        System.out.println("*************一千年以后...*************");  
        System.out.println();  
        subject.setState("疯狂杀戮中...");  
    }  
}

运行程序打印结果如下：



[html] view plain copy
 


被观察者自身状态更新为：复活中...  
观察者A中被观察对象的状态更新为：复活中...  
观察者B中被观察对象的状态更新为：复活中...  
*************一千年以后...*************  
被观察者自身状态更新为：疯狂杀戮中...  
观察者A中被观察对象的状态更新为：疯狂杀戮中...  
观察者B中被观察对象的状态更新为：疯狂杀戮中...


四、Java对观察者模式的支持

在JAVA语言的java.util库里面有一个Observable类和一个Observer接口，通过两者配合使用可以实现观察者模式。

Observable类：

Observable中文意思“可以被观察的”，即Observable类是可以被观察的，想要实现观察者模式只需将你想要被观察的类继承自Observable类即可。

一个 Observable对象可以有一个或多个观察者，观察者可以是实现了Observer接口的任意对象。一个Observable对象状态改变后,会调用notifyObservers()方法来通知观察者。

以下是Observable类提供的一些常用方法：



[java] view plain copy
 


public void addObserver(Observer o)    //向观察者集合中添加观察者  
public void deleteObserver(Observer o)    //从观察者集合中删除某一个观察者  
public void notifyObservers(Object arg)    //如果hasChanged方法指示对象已改变，则通知其所有观察者，并调用 clearChanged 方法来清除对象的已改变标记。此方法可不带参数，仅将Observable对象传递给update()方法，此时update方法中arg参数为Null。  
public void deleteObservers()    //清除观察者列表，使此对象不再有任何观察者  
protected void setChanged()    //标记Observable对象已经改变  
protected void clearChanged()    //清除Observable对象已改变标记  
public boolean hasChanged()    //测试对象是否改变  
public int countObservers()    //返回Observable对象的观察者数目

Observer接口：

Observer接口只包含一个update()方法,该方法仅接受两个参数：继承自Observable类的被观察对象和传递给notifyObservers() 方法的参数。当Observable(被观察者)对象状态发生改变时将通过notifyObservers()方法向所有的Observer(观察者)发送更新通知，Observer(观察者)对象在收到通知后即调用此方法完成状态更新。




[java] view plain copy
 


void update(Observable o,  
            Object arg)  


接下来我们举个简单的例子来演示一下如何使用Observable类和Observer接口实现观察者模式，去年2015年是牛市，炒股的基本都发家了，在此我们以炒股为例。

在炒股这个例子中，不用我说，相信你也想的到：股票Stock就是我们的被观察者。




[java] view plain copy
 


import java.util.Observable;  
public class Stock extends Observable{  
    //为股票的状态创建一个枚举类：RISE 涨,FALL 跌  
    public enum StockState{  
        RISE,FALL  
    }  
    //股票涨跌状态  
    private StockState state;  
    //股票的价格  
    private double price;  
    //股票的历史最低价格  
    private double LowestPrice;  
    //股票无参的构造方法  
    public Stock(){  
    }  
    //股票的带参数构造方法  
    public Stock(StockState state, double price, double lowestPrice) {  
        super();  
        this.state = state;  
        this.price = price;  
        LowestPrice = lowestPrice;  
    }  
    public StockState getState() {  
        return state;  
    }  
    private void setState(StockState state) {  
        this.state = state;  
    }  
    public double getPrice() {  
        return price;  
    }  
    public void setPrice(double price) {  
        if(price<this.price){  
            setState(StockState.FALL);  
        }  
        else{  
            setState(StockState.RISE);  
        }  
        if(price<this.LowestPrice){  
            setLowestPrice(price);  
        }  
        this.price = price;  
        //更新股票状态标记为已改变  
        this.setChanged();  
        //通知观察者  
        notifyObservers();  
    }  
    public double getLowestPrice() {  
        return LowestPrice;  
    }  
    private void setLowestPrice(double lowestPrice) {  
        LowestPrice = lowestPrice;  
    }  
}  


我们这些只有韭菜命的股民自然就是观察者了。




[java] view plain copy
 


import java.util.Observable;  
import java.util.Observer;  
import com.ibeifeng.news.Stock.StockState;  
public class Investor implements Observer {  
    public void update(Observable o, Object arg) {  
        Stock stock=(Stock)o;  
        if(stock.getPrice()==stock.getLowestPrice())  
        {  
            System.out.println("股票已经跌到历史最低了，我得赶紧抄底...");  
        }  
        else{  
            if(stock.getState().equals(StockState.RISE)){  
                System.out.println("股票在涨，目前价格："+stock.getPrice());  
            }  
            else{  
                System.out.println("股票在跌，目前价格："+stock.getPrice());  
            }  
        }  
    }  
}  


在客户端里面测试一下。




[java] view plain copy
 


public class Client{  
    public static void main(String[] args) {  
        Stock stock=new Stock(StockState.FALL,14.7D,13.2D);  
        stock.addObserver(new Investor());  
        stock.setPrice(13.7);  
        stock.setPrice(12.6);  
        stock.setPrice(14.0);  
    }  
}  


运行程序打印结果如下：




[html] view plain copy
 


股票在跌，目前价格：13.7  
股票已经跌到历史最低了，我得赶紧抄底...  
股票在涨，目前价格：14.0



五、观察者模式的优点

观察者Observer模式解决了对象之间一对多的复杂依赖关系问题，并使得程序易于维护与扩展。

JAVA设计模式-09-观察者模式

一、什么是观察者模式

二、观察者模式的典型应用

三、观察者模式的结构

四、Java对观察者模式的支持

五、观察者模式的优点

相关推荐