Java设计模式开发中使用观察者模式的实例教程

观察者模式是软件设计模式中的一种，使用也比较普遍，尤其是在gui编程中。关于设计模式的文章，网络上写的都比较多，而且很多文章写的也不错，虽然说有一种重复早*的嫌疑，但此*非彼*，侧重点不同，思路也不同，讲述方式也不近相同。
关键要素

主题:

主题是观察者观察的对象，一个主题必须具备下面三个特征。

• 持有监听的观察者的引用
• 支持增加和删除观察者
• 主题状态改变，通知观察者

观察者:

当主题发生变化，收到通知进行具体的处理是观察者必须具备的特征。

为什么要用这种模式

这里举一个例子来说明，牛奶送奶站就是主题，订奶客户为监听者，客户从送奶站订阅牛奶后，会每天收到牛奶。如果客户不想订阅了，可以取消，以后就不会收到牛奶。

松耦合

观察者增加或删除无需修改主题的代码，只需调用主题对应的增加或者删除的方法即可。
主题只负责通知观察者，但无需了解观察者如何处理通知。举个例子，送奶站只负责送递牛奶，不关心客户是喝掉还是洗脸。
观察者只需等待主题通知，无需观察主题相关的细节。还是那个例子，客户只需关心送奶站送到牛奶，不关心牛奶由哪个快递人员，使用何种交通工具送达。

java实现观察者模式
1. java自带的实现
类图

/** 
 * 观察目标 继承自 java.util.observable 
 * @author stone 
 * 
 */ 
public class updateobservable extends observable { 
   
  private int data; 
   
  public updateobservable(observer observer) { 
    addobserver(observer); 
    /* 
     * add other observer 
     */ 
  } 
   
  public int getdata() { 
    return data; 
  } 
   
  public void setdata(int data) { 
    if (data != this.data) { 
      this.data = data; 
      setchanged(); //标记 改变, 只有标记后才能通知到 
      notifyobservers(); //通知 
    } 
     
  } 
 
  @override 
  public synchronized void addobserver(observer o) { 
    super.addobserver(o); 
  } 
 
  @override 
  public synchronized void deleteobserver(observer o) { 
    super.deleteobserver(o); 
  } 
 
  @override 
  public void notifyobservers() { 
    super.notifyobservers(); 
  } 
 
  @override 
  public void notifyobservers(object arg) { 
    super.notifyobservers(arg); 
  } 
 
  @override 
  public synchronized void deleteobservers() { 
    super.deleteobservers(); 
  } 
 
  @override 
  protected synchronized void setchanged() { 
    super.setchanged(); 
  } 
 
  @override 
  protected synchronized void clearchanged() { 
    super.clearchanged(); 
  } 
 
  @override 
  public synchronized boolean haschanged() { 
    return super.haschanged(); 
  } 
 
  @override 
  public synchronized int countobservers() { 
    return super.countobservers(); 
  } 
   
} 

/** 
 * 观察者 实现 java.util.observer接口 
 * @author stone 
 * 
 */ 
public class updateobserver implements observer { 
 
  @override 
  public void update(observable o, object arg) { 
    system.out.println("接收到数据变化的通知:"); 
    if (o instanceof updateobservable) { 
      updateobservable uo = (updateobservable) o; 
      system.out.print("数据变更为：" + uo.getdata()); 
    } 
  } 
 
} 

2. 自定义的观察模型
类图

/** 
 * 抽象观察者  observer 
 * 观察 更新     
 * @author stone 
 * 
 */ 
public interface iwatcher { 
  /* 
   * 通知接口： 
   * 1. 简单通知 
   * 2. 观察者需要目标的变化的数据，那么可以将目标用作参数, 见java的observer和observable 
   */ 
// void update(iwatched watched); 
   
  void update(); 
   
} 

/** 
 * 抽象目标 subject 
 * 提供注册和删除观察者对象的接口, 及通知观察者进行观察的接口 
 * 及目标 自身被观察的业务的接口 
 * @author stone 
 * 
 */ 
public interface iwatchedsubject { 
   
  public void add(iwatcher watch); 
 
  public void remove(iwatcher watch); 
   
  public void notifywhatchers(); 
   
  public void update();//被观察业务变化的接口 
} 

/** 
 * 具体观察者    concrete observer 
 * 
 * @author stone 
 * 
 */ 
public class updatewatcher implements iwatcher { 
 
  @override 
  public void update() { 
    system.out.println(this + "观察到：目标已经更新了"); 
  } 
 
} 

/** 
 * 具体目标角色  concrete subject 
 * @author stone 
 * 
 */ 
public class updatewatchedsubject implements iwatchedsubject { 
  private list<iwatcher> list; 
   
  public updatewatchedsubject() { 
    this.list = new arraylist<iwatcher>(); 
  } 
   
  @override 
  public void add(iwatcher watch) { 
    this.list.add(watch); 
  } 
 
  @override 
  public void remove(iwatcher watch) { 
    this.list.remove(watch); 
  } 
 
  @override 
  public void notifywhatchers() { 
    for (iwatcher watcher : list) { 
      watcher.update(); 
    } 
  } 
   
  @override 
  public void update() { 
    system.out.println("目标更新中...."); 
    notifywhatchers(); 
  } 
 
} 

监听器是观察者的一种实现：
类图

/** 
 * 监听 用户在注册后 
 * @author stone 
 * 
 */ 
public interface iregisterlistener { 
  void onregistered(); 
} 

/** 
 * 监听 当用户登录后 
 * @author stone 
 * 
 */ 
public interface iloginlistener { 
  void onlogined(); 
} 

/* 
 * 监听器 是观察者模式的一种实现 
 * 一些需要监听的业务接口上添加 监听器，调用监听器的相应方法，实现监听 
 */ 
public class user { 
   
  public void register(iregisterlistener register) { 
    /* 
     * do ... register 
     */ 
    system.out.println("正在注册中..."); 
    //注册后 
    register.onregistered(); 
  } 
 
  public void login(iloginlistener login) { 
    /* 
     * do ... login 
     */ 
    system.out.println("正在登录中..."); 
    //登录后 
    login.onlogined(); 
  } 
 
} 

/** 
 * 观察者(observer)模式 行为型模式 
 *  观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时观察某一个目标对象。 
 *  这个目标对象在状态上发生变化时，会通知所有观察者对象，让它们能够自动更新自己 
 * 目标对象中需要有添加、移除、通知 观察者的接口 
 *  
 * @author stone 
 */ 
public class test { 
   
  public static void main(string[] args) { 
    /* 
     * 使用java自带的observer接口和observable类 
     */ 
    updateobservable observable = new updateobservable(new updateobserver()); 
    observable.setdata(99); 
    system.out.println(""); 
    system.out.println(""); 
    /* 
     * 自定义的观察者模型 
     */ 
    iwatchedsubject watched = new updatewatchedsubject(); 
    watched.add(new updatewatcher()); 
    watched.add(new updatewatcher()); 
    watched.update(); 
    system.out.println(""); 
     
    /* 
     * 子模式-监听器 
     */ 
     
    user user = new user(); 
    user.register(new iregisterlistener() { 
       
      @override 
      public void onregistered() { 
        system.out.println("监听到注册后。。。"); 
      } 
    }); 
    user.login(new iloginlistener() { 
       
      @override 
      public void onlogined() { 
        system.out.println("监听到登录后。。。"); 
      } 
    }); 
     
  } 
} 

打印

接收到数据变化的通知: 
数据变更为：99 
 
目标更新中.... 
observer.updatewatcher@457471e0观察到：目标已经更新了 
observer.updatewatcher@5fe04cbf观察到：目标已经更新了 
 
正在注册中... 
监听到注册后。。。 
正在登录中... 
监听到登录后。。。