java设计模式--事件监听器模式和观察者模式 .

监听器模式：事件源经过事件的封装传给监听器，当事件源触发事件后，监听器接收到事件对象可以回调事件的方法

观察者模式：观察者(Observer)相当于事件监听者，被观察者(Observable)相当于事件源和事件，执行逻辑时通知observer即可触发oberver的update,同时可传被观察者和参数

监听器模式demo

1、首要定义事件源对象（事件源相当于单击按钮事件当中的按钮对象、属于被监听者）：

[java] view plaincopyprint?

1. public class DemoSource {     
2.     private Vector repository = new Vector();//监听自己的监听器队列     
3.     public DemoSource(){}     
4.     public void addDemoListener(DemoListener dl) {     
5.            repository.addElement(dl);     
6.     }     
7.     public void notifyDemoEvent() {//通知所有的监听器     
8.            Enumeration enum = repository.elements();     
9.            while(enum.hasMoreElements()) {     
10.                    DemoListener dl = (DemoListener)enum.nextElement();     
11.                  dl.handleEvent(new DemoEvent(this));     
12.            }     
13.     }     
14. }    

public class DemoSource {   
    private Vector repository = new Vector();//监听自己的监听器队列   
    public DemoSource(){}   
    public void addDemoListener(DemoListener dl) {   
           repository.addElement(dl);   
    }   
    public void notifyDemoEvent() {//通知所有的监听器   
           Enumeration enum = repository.elements();   
           while(enum.hasMoreElements()) {   
                   DemoListener dl = (DemoListener)enum.nextElement();   
                 dl.handleEvent(new DemoEvent(this));   
           }   
    }   
}  

2、其次定义事件（状态）对象（ 该事件对象包装了事件源对象、作为参数传递给监听器、很薄的一层包装类）：

[java] view plaincopyprint?

1. public class DemoEvent extends java.util.EventObject {     
2.     public DemoEvent(Object source) {     
3.       super(source);//source—事件源对象—如在界面上发生的点击按钮事件中的按钮     
4.        //所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象     
5.     }     
6.     public void say() {     
7.            System.out.println("This is say method...");     
8.     }     
9. }    

public class DemoEvent extends java.util.EventObject {   
    public DemoEvent(Object source) {   
      super(source);//source—事件源对象—如在界面上发生的点击按钮事件中的按钮   
       //所有 Event 在构造时都引用了对象 "source"，在逻辑上认为该对象是最初发生有关 Event 的对象   
    }   
    public void say() {   
           System.out.println("This is say method...");   
    }   
}  

3、最后定义我们的事件侦听器接口 如下

[java] view plaincopyprint?

1. public interface DemoListener extends java.util.EventListener {     
2.     //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、     
3.     //所以事件处理方法由我们自己声明如下：      
4.     public void handleEvent(DemoEvent dm);     
5. }  

public interface DemoListener extends java.util.EventListener {   
    //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、   
    //所以事件处理方法由我们自己声明如下：   
    public void handleEvent(DemoEvent dm);   
}

监听器实现类

[java] view plaincopyprint?

1. public class DemoListener1 implements DemoListener {     
2.        public void handleEvent(DemoEvent de) {     
3.               System.out.println("Inside listener1...");     
4.               de.say();//回调      
5.        }     
6. }   

public class DemoListener1 implements DemoListener {   
       public void handleEvent(DemoEvent de) {   
              System.out.println("Inside listener1...");   
              de.say();//回调   
       }   
} 

4、测试代码

[java] view plaincopyprint?

1. public class TestDemo {     
2.    DemoSource ds;     
3.    public TestDemo(){     
4.       try{     
5.          ds = new DemoSource();     
6.          //将监听器在事件源对象中登记：      
7.          DemoListener1 listener1 = new DemoListener1();     
8.          ds.addDemoListener(listener1);     
9.          ds.addDemoListener(new DemoListener() {     
10.             public void handleEvent(DemoEvent event) {     
11.             System.out.println("Method come from 匿名类...");     
12.           }     
13.         });     
14.        ds.notifyDemoEvent();//触发事件、通知监听器     
15.      }catch(Exception ex){  
16.        ex.printStackTrace();  
17.        }     
18.     }     
19.     
20.     public static void main(String args[]) {     
21.            new TestDemo();     
22.     }     
23. }    

public class TestDemo {   
   DemoSource ds;   
   public TestDemo(){   
      try{   
         ds = new DemoSource();   
         //将监听器在事件源对象中登记：   
         DemoListener1 listener1 = new DemoListener1();   
         ds.addDemoListener(listener1);   
         ds.addDemoListener(new DemoListener() {   
            public void handleEvent(DemoEvent event) {   
            System.out.println("Method come from 匿名类...");   
          }   
        });   
       ds.notifyDemoEvent();//触发事件、通知监听器   
     }catch(Exception ex){
       ex.printStackTrace();
       }   
    }   

    public static void main(String args[]) {   
           new TestDemo();   
    }   
}  

观察者模式demo

观察者

[java] view plaincopyprint?

1. class Watcher implements java.util.Observer {     
2.   public void update(java.util.Observable obj, Object arg) {     
3.     System.out.println("Update() called, count is "      
4.                                 + ((Integer) arg).intValue());     
5. }     
6. }    

class Watcher implements java.util.Observer {   
  public void update(java.util.Observable obj, Object arg) {   
    System.out.println("Update() called, count is "    
                                + ((Integer) arg).intValue());   
}   
}  

被观察者

[java] view plaincopyprint?

1. class BeingWatched extends java.util.Observable {     
2.     void counter(int period) {     
3.         for(; period>=0; period-- ) {     
4.                 setChanged();     
5.                 notifyObservers(new Integer(period));     
6.                 try {     
7.                         Thread.sleep(100);     
8.                 } catch( InterruptedException e) {     
9.                   System.out.println("Sleep interrupeted" );     
10.                 }     
11.         }     
12. }     
13. };     

class BeingWatched extends java.util.Observable {   
    void counter(int period) {   
        for(; period>=0; period-- ) {   
                setChanged();   
                notifyObservers(new Integer(period));   
                try {   
                        Thread.sleep(100);   
                } catch( InterruptedException e) {   
                  System.out.println("Sleep interrupeted" );   
                }   
        }   
}   
};   

测试

[java] view plaincopyprint?

1. public class ObserverDemo {     
2.     public static void main(String[] args) {     
3.         BeingWatched beingWatched = new BeingWatched();//受查者     
4.         Watcher watcher = new Watcher();//观察者     
5.         beingWatched.addObserver(watcher);     
6.         beingWatched.counter(10);     
7.     }     
8. }    

public class ObserverDemo {   
    public static void main(String[] args) {   
        BeingWatched beingWatched = new BeingWatched();//受查者   
        Watcher watcher = new Watcher();//观察者   
        beingWatched.addObserver(watcher);   
        beingWatched.counter(10);   
    }   
}  

查阅了一些相关的东东 
原来这两种api可以说都是基于：订阅-发布模式的事件/消息通知模式，二者应该都算是“推”方式吧，就是被监控者将消息通知给所有监控者。 
1、订阅：Observable.addObserver；  
事件源.addDemoListener（这个方法是自己定义的）。 

2、发布：Observable需要两步 ：setChanged()、notifyObservers(newValue); 
事件源.notifyDemoEvent()（这个方法也是自己定义的）。