原型模式和观察者模式

原型模式
关键字: 原型模式
关键字: prototype
一、原型模式定义
     用原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象.

     Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节。

     工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。

 

二、如何使用
     因为Java中的提供clone()方法来实现对象的克隆,所以Prototype模式实现一下子变得很简单.

 

三、实例

Java代码
Java代码
public abstract class AbstractSpoon implements Cloneable{     
　　String spoonName;     
    
　　public void setSpoonName(String spoonName) {     
            this.spoonName = spoonName;     
      }     
　　public String getSpoonName() {return this.spoonName;}     
    
　　public Object clone(){     
　　　　Object object = null;     
　　　　try {     
　　　　　　object = super.clone();     
　　　　} catch (CloneNotSupportedException exception) {     
　　　　　　System.err.println("AbstractSpoon is not Cloneable");     
　　　　}     
　　　　return object;     
　　}     
}    
 
public abstract class AbstractSpoon implements Cloneable{  
　　String spoonName;  
 
　　public void setSpoonName(String spoonName) {  
            this.spoonName = spoonName;  
      }  
　　public String getSpoonName() {return this.spoonName;}  
 
　　public Object clone(){  
　　　　Object object = null;  
　　　　try {  
　　　　　　object = super.clone();  
　　　　} catch (CloneNotSupportedException exception) {  
　　　　　　System.err.println("AbstractSpoon is not Cloneable");  
　　　　}  
　　　　return object;  
　　}  
} 有个具体实现(ConcretePrototype):  
 
Java代码   
public class SoupSpoon extends AbstractSpoon{     
　　public SoupSpoon(){     
　　　　setSpoonName("Soup Spoon");     
　　}     
}    
 
public class SoupSpoon extends AbstractSpoon{  
　　public SoupSpoon(){  
　　　　setSpoonName("Soup Spoon");  
　　}  
}   
调用Prototype模式很简单:  
 
AbstractSpoon spoon = new SoupSpoon();  
AbstractSpoon spoon2 = spoon.clone();   
 
当然也可以结合工厂模式来创建AbstractSpoon实例。 

public abstract class AbstractSpoon implements Cloneable{  
　　String spoonName;  
 
　　public void setSpoonName(String spoonName) {  
            this.spoonName = spoonName;  
      }  
　　public String getSpoonName() {return this.spoonName;}  
 
　　public Object clone(){  
　　　　Object object = null;  
　　　　try {  
　　　　　　object = super.clone();  
　　　　} catch (CloneNotSupportedException exception) {  
　　　　　　System.err.println("AbstractSpoon is not Cloneable");  
　　　　}  
　　　　return object;  
　　}  
} 

public abstract class AbstractSpoon implements Cloneable{
　　String spoonName;

　　public void setSpoonName(String spoonName) {
            this.spoonName = spoonName;
      }
　　public String getSpoonName() {return this.spoonName;}

　　public Object clone(){
　　　　Object object = null;
　　　　try {
　　　　　　object = super.clone();
　　　　} catch (CloneNotSupportedException exception) {
　　　　　　System.err.println("AbstractSpoon is not Cloneable");
　　　　}
　　　　return object;
　　}
} 有个具体实现(ConcretePrototype):

Java代码
public class SoupSpoon extends AbstractSpoon{  
　　public SoupSpoon(){  
　　　　setSpoonName("Soup Spoon");  
　　}  
} 

public class SoupSpoon extends AbstractSpoon{
　　public SoupSpoon(){
　　　　setSpoonName("Soup Spoon");
　　}
}
调用Prototype模式很简单:

AbstractSpoon spoon = new SoupSpoon();
AbstractSpoon spoon2 = spoon.clone();

当然也可以结合工厂模式来创建AbstractSpoon实例。
在Java中Prototype模式变成clone()方法的使用，此方法执行的是该对象的“浅表复制”，而不“深层复制”操作。

 

四、说明：
克隆必须满足的条件：
a.对任何的对象x,都有：x.clone() != x,即克隆对象与原对象不是同一个对象。
b.对任何的对象x,都有：x.clone().getClass() == x.get getClass()，即克隆对象与原对象的类型是一样的。 c.如果对象x的equals()方法定义恰当的话，那么x.clone().equals(x)应当是成立的。
在java中实现clone()应该满足这三个条件。

浅复制：复制了值类型对象，对于引用类型对象，只复制了引用，它指向原来引用的对象。Java中clone为浅复制。
深复制：对值类型和引用类型的对象都生成一份新的拷贝. Java中可以通过串行化来进行深复制,前提是对象以及对象内部所引用的对象都是可串行化的，否则需要考虑将那些不可串行化的对象可否设为transient,排除           在复制过程之外。

 

 

关键字: 观察者模式
GoF说道：Observer模式的意图是“定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新”。从这段话里我们可以得到两个信息，如下：

1， 观察者（具体执行操作的对象，有多个）
2， 被观察者（顾名思义是被观察的对象，如果该对象发生某些变化则通知观察者执行对应的操）

在我们实现观察者模式的时候，我们的被观察者应该继承这个类，这个observable类把持住了被观察者所持有的观察者列表：
Java代码
Java代码
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 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 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 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);
    }
}
这里只列出了一些常用的操作，大家如有不明白可以自己看java.util包下的Observable，每一个方法前都有详细的解释。但是以上列出的方法对于这个例子来说已经够用了。

当我们自己的被观察者继承这个Observable类是，我们就自动的获取到被观察者的一切条件了。很方便是不是，这也是为什么sun要把Observable放到java.util包中的原因，就是为了方便开发者。

讲完了被观察者再让我们来看看观察者，在上面的代码中有一个addObserver(Observer o)方法，由此我们可以看出来，给被观察者添加观察者时就是用这个方法，那么也就是说观察者一定是Observer的子类或者实现，我们看一下java.util.Observer吧：
Java代码
Java代码
public interface Observer {     
    /**   
     * This method is called whenever the observed object is changed. An   
     * application calls an <tt>Observable</tt> object's   
     * <code>notifyObservers</code> method to have all the object's   
     * observers notified of the change.   
     *   
     * @param   o     the observable object.   
     * @param   arg   an argument passed to the <code>notifyObservers</code>   
     *                 method.   
     */    
    void update(Observable o, Object arg);     
}     
}    
 
public interface Observer {  
    /** 
     * This method is called whenever the observed object is changed. An 
     * application calls an <tt>Observable</tt> object's 
     * <code>notifyObservers</code> method to have all the object's 
     * observers notified of the change. 
     * 
     * @param   o     the observable object. 
     * @param   arg   an argument passed to the <code>notifyObservers</code> 
     *                 method. 
     */ 
    void update(Observable o, Object arg);  
}  
} 

public interface Observer {  
    /** 
     * This method is called whenever the observed object is changed. An 
     * application calls an <tt>Observable</tt> object's 
     * <code>notifyObservers</code> method to have all the object's 
     * observers notified of the change. 
     * 
     * @param   o     the observable object. 
     * @param   arg   an argument passed to the <code>notifyObservers</code> 
     *                 method. 
     */ 
    void update(Observable o, Object arg);  
}  
} 

public interface Observer {
    /**
     * This method is called whenever the observed object is changed. An
     * application calls an <tt>Observable</tt> object's
     * <code>notifyObservers</code> method to have all the object's
     * observers notified of the change.
     *
     * @param   o     the observable object.
     * @param   arg   an argument passed to the <code>notifyObservers</code>
     *                 method.
     */
    void update(Observable o, Object arg);
}
}很好，这是一个接口，接口中就只有一个方法，update，方法中有两个参数，Observable和一个object，第一个参数就是被观察的对象，而第二个参数就得看业务需求了，需要什么就传进去什么。我们自己的观察者类必须实现这个方法，这样在被观察者调用notifyObservers操作时被观察者所持有的所有观察者都会执行update操作了（当然如果你override这个方法，你甚至可以指定何种情况下只执行某种observer了，是不是比较像责任链模式了）。

那么到这里我们也差不多可以把观察者模式应用到项目中去了。首先让我们来实现被观察者（因为实现被观察者非常简单）

首先让我们来实现一个发送邮件的观察者：
Java代码
Java代码
/**   
 * @author 张荣华(ahuaxuan)   
* @version $Id$   
 */    
public class MailObserver implements Observer{     
    
    /**   
     * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者   
     */    
    public void update(Observable o, Object arg) {     
        System.out.println("发送邮件的观察者已经被执行");     
    }     
}    
 
/** 
 * @author 张荣华(ahuaxuan) 
* @version $Id$ 
 */ 
public class MailObserver implements Observer{  
 
    /** 
     * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者 
     */ 
    public void update(Observable o, Object arg) {  
        System.out.println("发送邮件的观察者已经被执行");  
    }  
}  
接着再让我们来实现一个发送jms消息的观察者：   
Java代码   
/**   
 * @author 张荣华(ahuaxuan)   
 * @version $Id$   
 */    
public class JMSObserver implements Observer{     
    
    public void update(Observable o, Object arg) {     
        System.out.println("发送消息给jms服务器的观察者已经被执行");     
    }     
}    
 
/** 
 * @author 张荣华(ahuaxuan) 
 * @version $Id$ 
 */ 
public class JMSObserver implements Observer{  
 
    public void update(Observable o, Object arg) {  
        System.out.println("发送消息给jms服务器的观察者已经被执行");  
    }  
}  
如上所见，观察者的实现完全跟业务相关。是否复杂就得看你得业务是否复杂了。   
 
接下来让我们再来实现被观察者，示例如下：   
Java代码   
/**   
 * @author 张荣华(ahuaxuan)   
* @version $Id$   
 */    
public class Subject extends Observable{     
         
    /**   
     * 业务方法，一旦执行某个操作，则通知观察者   
     */    
    public void doBusiness(){     
        if (true) {     
            super.setChanged();     
        }     
        notifyObservers("现在还没有的参数");     
    }     
    
         
    public static void main(String [] args) {     
        //创建一个被观察者     
        Subject subject = new Subject();     
             
        //创建两个观察者     
        Observer mailObserver = new MailObserver();     
        Observer jmsObserver = new JMSObserver();     
             
        //把两个观察者加到被观察者列表中     
        subject.addObserver(mailObserver);     
        subject.addObserver(jmsObserver);     
             
        //执行业务操作     
        subject.doBusiness();     
    }     
}    
 
/** 
 * @author 张荣华(ahuaxuan) 
* @version $Id$ 
 */ 
public class Subject extends Observable{  
      
    /** 
     * 业务方法，一旦执行某个操作，则通知观察者 
     */ 
    public void doBusiness(){  
        if (true) {  
            super.setChanged();  
        }  
        notifyObservers("现在还没有的参数");  
    }  
 
      
    public static void main(String [] args) {  
        //创建一个被观察者  
        Subject subject = new Subject();  
          
        //创建两个观察者  
        Observer mailObserver = new MailObserver();  
        Observer jmsObserver = new JMSObserver();  
          
        //把两个观察者加到被观察者列表中  
        subject.addObserver(mailObserver);  
        subject.addObserver(jmsObserver);  
          
        //执行业务操作  
        subject.doBusiness();  
    }  
} 

/** 
 * @author 张荣华(ahuaxuan) 
* @version $Id$ 
 */ 
public class MailObserver implements Observer{  
 
    /** 
     * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者 
     */ 
    public void update(Observable o, Object arg) {  
        System.out.println("发送邮件的观察者已经被执行");  
    }  
} 

/**
 * @author 张荣华(ahuaxuan)
* @version $Id$
 */
public class MailObserver implements Observer{

 /**
  * 这个类取名为MailObserver，顾名思义，她是一个用来发送邮件的观察者
  */
 public void update(Observable o, Object arg) {
  System.out.println("发送邮件的观察者已经被执行");
 }
}
接着再让我们来实现一个发送jms消息的观察者：
Java代码
/** 
 * @author 张荣华(ahuaxuan) 
 * @version $Id$ 
 */ 
public class JMSObserver implements Observer{  
 
    public void update(Observable o, Object arg) {  
        System.out.println("发送消息给jms服务器的观察者已经被执行");  
    }  
} 

/**
 * @author 张荣华(ahuaxuan)
 * @version $Id$
 */
public class JMSObserver implements Observer{

 public void update(Observable o, Object arg) {
  System.out.println("发送消息给jms服务器的观察者已经被执行");
 }
}
如上所见，观察者的实现完全跟业务相关。是否复杂就得看你得业务是否复杂了。

接下来让我们再来实现被观察者，示例如下：
Java代码
/** 
 * @author 张荣华(ahuaxuan) 
* @version $Id$ 
 */ 
public class Subject extends Observable{  
      
    /** 
     * 业务方法，一旦执行某个操作，则通知观察者 
     */ 
    public void doBusiness(){  
        if (true) {  
            super.setChanged();  
        }  
        notifyObservers("现在还没有的参数");  
    }  
 
      
    public static void main(String [] args) {  
        //创建一个被观察者  
        Subject subject = new Subject();  
          
        //创建两个观察者  
        Observer mailObserver = new MailObserver();  
        Observer jmsObserver = new JMSObserver();  
          
        //把两个观察者加到被观察者列表中  
        subject.addObserver(mailObserver);  
        subject.addObserver(jmsObserver);  
          
        //执行业务操作  
        subject.doBusiness();  
    }  
} 

/**
 * @author 张荣华(ahuaxuan)
* @version $Id$
 */
public class Subject extends Observable{
 
 /**
  * 业务方法，一旦执行某个操作，则通知观察者
  */
 public void doBusiness(){
  if (true) {
   super.setChanged();
  }
  notifyObservers("现在还没有的参数");
 }

 
 public static void main(String [] args) {
  //创建一个被观察者
  Subject subject = new Subject();
  
  //创建两个观察者
  Observer mailObserver = new MailObserver();
  Observer jmsObserver = new JMSObserver();
  
  //把两个观察者加到被观察者列表中
  subject.addObserver(mailObserver);
  subject.addObserver(jmsObserver);
  
  //执行业务操作
  subject.doBusiness();
 }
}到此为止，我们已经简单得实现了观察者模式，让我们来运行一下上面main方法，运行结果如下：

发送消息给jms服务器的观察者已经被执行
发送邮件的观察者已经被执行

有了jdk对观察者模式的支持，程序员在实现基本的观察者模式时应该说是易如反掌，这也从一个侧面反应出观察者模式的地位，它的地位应该是非常重要的，引用Nicholas Lesiecki（此人是上面所指的ibm那篇文章的作者）的话说，它是“设计模式中的皇后”。

通过上面的介绍和简单的实例，现在你也可以实现一个自己的观察者了(有时候这个简单的模型并不满足我们的需要，在这种情况下只好自己去写一个类似的但是是为业务定制的observable和observer类了，但显然这中情况并不常见)。事实上spring对观察者模式也有很好的支持（spring可以通过配置文件来执行addobserver方法，这样就可以隐式的把观察者加到被观察者的列表中去了，前提是你的被观察者是spring管理的一个bean之一，详见3楼回复，或者也可以利用afterPropertiesSet方法在被观察者这个bean初始化完成之后立刻把需要的观察者添加进去），除了spring，hibernate中也大量的使用了观察者模式，同时，如果你想再深入一点，可以看看本文第二段给的ibm技术文章的链接。