java设计优化--观察者模式

• 观察者模式介绍

　　观察者模式是一种非常有用的设计模式，在软件系统中，当一个对象的行为依赖于另一个对象的状态时，观察者模式就非常有用。如果不适用观察者模式，而实现类似的功能，可能就需要另外启动一个线程不停地监听另一个对象的状态，这样会得不偿失。如果在一个复杂的系统中，可能就需要开启很多的线程来监听对象状态的变化，这样会使系统的性能产生额外的负担。而观察者模式就可以在单线程下使某一对象及时得知所依赖对象状态的变化而做出行为。

　　观察者模式的经典结构：

　　

 　　其中ISubject是观察对象（被观察者对象），它维持着一个观察者对象列表，可以增加或删除观察者。IObserver是观察者，它依赖于ISubject对象状态的变化而做出行为。当ISubject对象的状态发生变化时，它可以通过inform()方法通知观察者。

　　观察者模式的主要角色功能如下图：

　　

• 观察者实例

　　现在简单实现一个观察者的小例子。

　　主题接口：

public interface ISubject {
    void attach(IObserver observer);
    void detach(IObserver observer);
    void inform();
}

　　观察者接口：

public interface IObserver {
    void update(Event event);
}

　　事件（对应现实中的点击等事件也可以理解为上文中说到的状态变化）：

public class Event {

}

　　具体的主题实现：

public class ConcreteSubject implements ISubject {
    Vector<IObserver> obversers = new Vector<IObserver>();//观察者队列
    @Override
    public void attach(IObserver observer) {
        obversers.add(observer);
    }

    @Override
    public void detach(IObserver observer) {
        obversers.remove(observer);
    }

    @Override
    public void inform() {
        Event event = new Event();
        for(IObserver obverser:obversers){
            obverser.update(event);
        }
    }

}

　　具体的观察者：

public class ConcreteObserver implements IObserver {

    @Override
    public void update(Event event) {
        System.out.println("ConcreteObserver.update()");
    }

}

　　测试代码：

public class Test {
    public static void main(String[] args) {
        IObserver observer1 = new ConcreteObserver();
        IObserver observer2 = new ConcreteObserver();
        ISubject subject = new ConcreteSubject();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.inform();
    }
}

　　可以看出，通过被观察者状态变化而调用某一方法使观察者收到通知而做出反应，通过委托降低了代码的耦合度。

　　观察者模式十分常用，以致于JDK内部就为开发人员准备了一套观察者模式的实现。在java.util包中，就包括了Obserable类和Observer接口。在Observable中就实现了观察对象的主要功能，如：添加观察者、删除观察者和通知观察者等。Observer是观察者接口，它的update方法会在Obserable类的notifyObservers()中被回调以获得最新的状态变化。

　　以现在比较火热的购房作为观察者模式的一个例子：现在很多购房者关注房价的变化，每当房价发生变动的时候，购房者就会收到通知。这样购房者就是观察者，他们关注着房子的价格。

　　观察对象房子代码：

public class House extends Observable{
    private float price;
    
    public House(float price) {
        super();
        this.price = price;
    }

    public float getPrice() {
        return price;
    }

    public void setPrice(float price) {
        super.setChanged();//设置变化点
        super.notifyObservers(price);//价格变动
        this.price = price;
    }

    @Override
    public String toString() {
        // TODO Auto-generated method stub
        return "房子的价格为:"+this.price;
    }
}

　　观察者购房者代码：

public class CustomerObserver implements Observer{
    
    private String name;
    
    public CustomerObserver(String name) {
        super();
        this.name = name;
    }

    @Override
    public void update(Observable o, Object arg) {
        if (arg instanceof Float) {
            System.out.println(this.name+"观察到房子价格变动为:"+arg);
        }
    }
}

　　测试代码：

public class Test1 {
    public static void main(String[] args) {
        House h = new House(1000000) ;  
        CustomerObserver hpo1 = new CustomerObserver("购房者A") ;  
        CustomerObserver hpo2 = new CustomerObserver("购房者B") ;  
        CustomerObserver hpo3 = new CustomerObserver("购房者C") ;  
        h.addObserver(hpo1) ;  
        h.addObserver(hpo2) ;  
        h.addObserver(hpo3) ;  
        System.out.println(h) ; // 输出房子价格  
        h.setPrice(666666) ;    // 修改房子价格  
        System.out.println(h) ; // 输出房子价格 
    }
}

　　输出结果为：

房子价格为：1000000.0
购房者C观察到价格更改为：666666.0
购房者B观察到价格更改为：666666.0
购房者A观察到价格更改为：666666.0
房子价格为：666666.0

　　Observer源码：

public class Observable {
    private boolean changed = false;//判断观察对象是否发生变化
    private Vector 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();
    }
}

　　可以发现JDK中实现的观察者模式，用法简单功能强大，和我们上面写的观察者模式实现原理是一样的。观察者模式可以用于事件监听、通知发布等场合，可以确保观察者在不适用轮询监控的情况下，可以及时得到相关消息和事件。