开发者模式查看session

    观察者模式，以前看过，今天想了一下，似乎有点模糊了

    行为模式，为实现此模式，应该具备这几个角色：被观察的主题，观察者。这是必须的！一般来说，为使构建的东西有一定的可用性，会进行进一步的分工。主题角色再分为抽象主题和具体主题，同样滴划分观察者角色为抽象观察者及具体观察者角色。这就是将在此文中提及的 Subject, ConcreteSubject, Observer, ConcreteObserver。
    按照《JAVA 与模式》书来的，实现了最简单的两个版本。
版本一：

/** 抽象主题角色，属于被观察者 */ 

    public interface Subject {
        /**
         * 登记一个新的观察者对象
         */
        public void attach(Observer observer);
        /**
         * 删除一个观察者对象
         */
        public void detach(Observer observer);
        /**
         * 通知所有登记过的观察者对象
         */
        void notifyObservers();
    } 


    /** 具体主题角色，属于被观察者 */ 

    public class ConcreteSubject implements Subject {        
        private Vector observersVector = new Vector();
        /** 这里省略了几个方法的实现，无非是往向量中添加 Observer, 没什么好写的 */  
        /** 
         * 通知所有登记过的观察者对象
         * 这里和书有一点点的不一样，我用的是 Iterator 接口来实现
         * 书上的是 Enumeration ，但大同小异。
         */
        public void notifyObservers() {
            Iterator it = observersVector.iterator();
            while(it.hasNext()) {
                ((Observer)it.next()).update();
            }
        }
    } 


    /** 抽象观察者角色 */ 

    public interface Observer {
        /**
         * 调用这个方法会更新自己
         */
        void update();
    } 


    /** 具体观察者角色 */ 

    public class ConcreteObserver implements Observer {
        /** 
         * 调用这个方法会更新自己
         */
        public void update() {
            System.out.println(this + "   I am notified");
        }
    }

    客户端的 main() 如下：

public static void main(String[] args) {
        Subject subject = new ConcreteSubject();
        Observer observer1 = new ConcreteObserver();
        Observer observer2 = new ConcreteObserver();
        subject.attach(observer1);
        subject.attach(observer2);
        subject.notifyObservers();
    }

    版本一的实现基本上与书上的没有什么不同，而版本二则有一点点的不一样。版本二只改变了版本一中的两个被观察者的一些细节。在此贴上：

/** 

     * 这是一个重量级的抽象主题角色，将子类的一些方法移至此 

     * 增加了抽象类的重量而减少了具体主题类的分量 

     */ 

    public abstract class Subject {        
        /**
         * 保存所有对观察者对象的引用
         */
        private Vector observersVector = new Vector();
        
        /**
         * 更改主题的状态
         *   在书上没有该方法，为了在客户端能够用基类声明对象，将该方法的声明移至此
         */
        public abstract void change(String newState);

        /** 在这里也把往主题角色中添加/删除观察者对象的方法省略了 */  

        /**
         * 通知所有登记过的观察者对象
         */
        public void notifyObservers() {
            Iterator it = observersVector.iterator();
            while(it.hasNext()) {
                    ((Observer)it.next()).update();
            }
        }
    }
 

    /** 

     * 轻量级的具体主题类角色 

     */ 

  
   public class ConcreteSubject extends Subject {
        
        private String state;
        
        /**
         * 更改主题的状态
         */
        public void change(String newState) {
            state = newState;
            this.notifyObservers();        
        }
    }

    客户端的代码是完全一样的。

    其实这样一个模式是相对比较简单的，当然，简单并不意味着力量不大，呵呵。用另外一个形式来表示：

public class 被观察者 {

 
        public void 通知观察者() {

 
            观察者对象.有情况发生();
 
        }
 
    }
 
public class 观察者 { 
        public void 有情况发生() {

 
            /* 在这里做你想做的事情 */
 
        }
 
    }

    当再把这两个类分解成抽象的和具体的后，一个相对完整的观察者模式的实现就出来了。