浅谈java中内置的观察者模式与动态代理的实现-白红宇

一.关于观察者模式

1.将观察者与被观察者分离开来，当被观察者发生变化时，将通知所有观察者，观察者会根据这些变化做出对应的处理。

2.jdk里已经提供对应的Observer接口(观察者接口)与Observable(被观察者类)用于实现观察者模式

3.关于Observer接口，该接口只有一个update方法，当被观察者发生相关变化时，会通知所有的观察者，观察者接受到通知时，调用update方法进行处理。贴出源代码：

1 /* 2  * Copyright (c) 1994, 1998, Oracle and/or its affiliates. All rights reserved. 3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. 4  * 5  * 6  * 7  * 8  * 9  *10  *11  *12  *13  *14  *15  *16  *17  *18  *19  *20  *21  *22  *23  *24  */25 package java.util;26 27 /**28  * A class can implement the Observer interface when it29  * wants to be informed of changes in observable objects.30  *31  * @author  Chris Warth32  * @see     java.util.Observable33  * @since   JDK1.034  */35 public interface Observer {36     /**37      * This method is called whenever the observed object is changed. An38      * application calls an Observable object's39      * notifyObservers method to have all the object's40      * observers notified of the change.41      *42      * @param   o     the observable object.43      * @param   arg   an argument passed to the notifyObservers44      *                 method.45      */46     void update(Observable o, Object arg);47 }

View Code

4：关于被观察者Observable的常用方法：

1. public synchronized void addObserver(Observer o)；//添加观察者对象

2. public void notifyObservers()；//通知所有观察者

3. protected synchronized void setChanged()；//设置观察项已经做出改变，此方法很重要

贴出源代码，注意内部实现：

1 /*  2  * Copyright (c) 1994, 2012, Oracle and/or its affiliates. All rights reserved.  3  * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.  4  *  5  *  6  *  7  *  8  *  9  * 10  * 11  * 12  * 13  * 14  * 15  * 16  * 17  * 18  * 19  * 20  * 21  * 22  * 23  * 24  */ 25  26 package java.util; 27  28 /** 29  * This class represents an observable object, or "data" 30  * in the model-view paradigm. It can be subclassed to represent an 31  * object that the application wants to have observed. 32  *  33  * An observable object can have one or more observers. An observer 34  * may be any object that implements interface Observer. After an 35  * observable instance changes, an application calling the 36  * Observable's notifyObservers method 37  * causes all of its observers to be notified of the change by a call 38  * to their update method. 39  * 
 40  * The order in which notifications will be delivered is unspecified. 41  * The default implementation provided in the Observable class will 42  * notify Observers in the order in which they registered interest, but 43  * subclasses may change this order, use no guaranteed order, deliver 44  * notifications on separate threads, or may guarantee that their 45  * subclass follows this order, as they choose. 46  * 
 47  * Note that this notification mechanism has nothing to do with threads 48  * and is completely separate from the wait and notify 49  * mechanism of class Object. 50  * 
 51  * When an observable object is newly created, its set of observers is 52  * empty. Two observers are considered the same if and only if the 53  * equals method returns true for them. 54  * 55  * @author  Chris Warth 56  * @see     java.util.Observable#notifyObservers() 57  * @see     java.util.Observable#notifyObservers(java.lang.Object) 58  * @see     java.util.Observer 59  * @see     java.util.Observer#update(java.util.Observable, java.lang.Object) 60  * @since   JDK1.0 61  */ 62 public class Observable { 63     private boolean changed = false; 64     private Vector
       
         obs; 65  66     /** Construct an Observable with zero Observers. */ 67  68     public Observable() { 69         obs = new Vector<>(); 70     } 71  72     /** 73      * Adds an observer to the set of observers for this object, provided 74      * that it is not the same as some observer already in the set. 75      * The order in which notifications will be delivered to multiple 76      * observers is not specified. See the class comment. 77      * 78      * @param   o   an observer to be added. 79      * @throws NullPointerException   if the parameter o is null. 80      */ 81     public synchronized void addObserver(Observer o) { 82         if (o == null) 83             throw new NullPointerException(); 84         if (!obs.contains(o)) { 85             obs.addElement(o); 86         } 87     } 88  89     /** 90      * Deletes an observer from the set of observers of this object. 91      * Passing 
        null to this method will have no effect. 92      * @param   o   the observer to be deleted. 93      */ 94     public synchronized void deleteObserver(Observer o) { 95         obs.removeElement(o); 96     } 97  98     /** 99      * If this object has changed, as indicated by the100      * 
        hasChanged method, then notify all of its observers101      * and then call the 
        clearChanged method to102      * indicate that this object has no longer changed.103      * 
       
104      * Each observer has its update method called with two105      * arguments: this observable object and null. In other106      * words, this method is equivalent to:107      * 
      
       108      * notifyObservers(null)
      
109      *110      * @see     java.util.Observable#clearChanged()111      * @see     java.util.Observable#hasChanged()112      * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)113      */114     public void notifyObservers() {115         notifyObservers(null);116     }117 118     /**119      * If this object has changed, as indicated by the120      * hasChanged method, then notify all of its observers121      * and then call the clearChanged method to indicate122      * that this object has no longer changed.123      * 124      * Each observer has its update method called with two125      * arguments: this observable object and the arg argument.126      *127      * @param   arg   any object.128      * @see     java.util.Observable#clearChanged()129      * @see     java.util.Observable#hasChanged()130      * @see     java.util.Observer#update(java.util.Observable, java.lang.Object)131      */132     public void notifyObservers(Object arg) {133         /*134          * a temporary array buffer, used as a snapshot of the state of135          * current Observers.136          */137         Object[] arrLocal;138 139         synchronized (this) {140             /* We don't want the Observer doing callbacks into141              * arbitrary code while holding its own Monitor.142              * The code where we extract each Observable from143              * the Vector and store the state of the Observer144              * needs synchronization, but notifying observers145              * does not (should not).  The worst result of any146              * potential race-condition here is that:147              * 1) a newly-added Observer will miss a148              *   notification in progress149              * 2) a recently unregistered Observer will be150              *   wrongly notified when it doesn't care151              */152             if (!changed)153                 return;154             arrLocal = obs.toArray();155             clearChanged();156         }157 158         for (int i = arrLocal.length-1; i>=0; i--)159             ((Observer)arrLocal[i]).update(this, arg);160     }161 162     /**163      * Clears the observer list so that this object no longer has any observers.164      */165     public synchronized void deleteObservers() {166         obs.removeAllElements();167     }168 169     /**170      * Marks this Observable object as having been changed; the171      * hasChanged method will now return true.172      */173     protected synchronized void setChanged() {174         changed = true;175     }176 177     /**178      * Indicates that this object has no longer changed, or that it has179      * already notified all of its observers of its most recent change,180      * so that the hasChanged method will now return false.181      * This method is called automatically by the182      * notifyObservers methods.183      *184      * @see     java.util.Observable#notifyObservers()185      * @see     java.util.Observable#notifyObservers(java.lang.Object)186      */187     protected synchronized void clearChanged() {188         changed = false;189     }190 191     /**192      * Tests if this object has changed.193      *194      * @return  true if and only if the setChanged195      *          method has been called more recently than the196      *          clearChanged method on this object;197      *          false otherwise.198      * @see     java.util.Observable#clearChanged()199      * @see     java.util.Observable#setChanged()200      */201     public synchronized boolean hasChanged() {202         return changed;203     }204 205     /**206      * Returns the number of observers of this Observable object.207      *208      * @return  the number of observers of this object.209      */210     public synchronized int countObservers() {211         return obs.size();212     }213 }

View Code

5.举一个例子吧：当婴儿哭泣时，则通知家人来哄宝宝，那么这里很明显婴儿是一个被观察者，当婴儿哭泣时，立刻通知家人(观察者)

package com.bdqn.s2.javaoop.study.proxy;import java.lang.reflect.Proxy;import java.util.Observable;import java.util.Observer;/** * 婴儿类，被观察者 */public class Baby extends Observable {    private int hungry;    private String name;    public String getName() {        return name;    }    public Baby(String name, int hungry) {        this.hungry = hungry;        this.name = name;        addObserver(new Parents());//添加观察者对象，需要家长监管    }    /**     * 婴儿开始哭泣     */    public void cry() {        if (hungry < 100) {            System.out.printf("baby%s饿了，开始哭泣...%n", name);            setChanged();//饥饿值过低，触发变化，此方法必须被调用            notifyObservers();//通知观察者        }    }}/** * 家长，观察者 */class Parents implements Observer {    @Override    public void update(Observable o, Object arg) {        if (o instanceof Baby) {            Baby baby = (Baby) o;            System.out.println(baby.getName()+"开始哭泣，赶紧哄宝宝啦");        }    }}public class Main {    public static void main(String[] args) {        Baby baby = new Baby("豆豆",9);        baby.cry();    }}/*输出结果baby豆豆饿了，开始哭泣...豆豆开始哭泣，赶紧哄宝宝啦*/

二关于动态代理模式

1）代理模式是设计模式中非常常见的一种模式，这种模式可以实现对原有方法的扩展，举个例子经纪人可以替明星们办理一些事情，那么此时经纪人可以视为明星的代理。

2）代理模式可以分为静态代理和动态代理，在这里我们只对JDK提供的动态代理进行讨论。

3）由于JDK提供的代理模式所代理的类继承了Proxy，因此我们只能接口进行代理，针对类的代理可以自行参考cglib框架

4）InvocationHandler:是代理实例的调用处理程序 实现的接口。每个代理实例都具有一个关联的调用处理程序。对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

//proxy:代理类，method：代理执行的方法 args:方法参数public Object invoke(Object proxy, Method method, Object[] args);

5）Proxy:该类主要是获取或者新创建动态代理对象

//该方法主要用于获取代理对象，注意一定是针对接口进行代理 public static Object newProxyInstance(ClassLoader loader,                                          Class
     [] interfaces,                                          InvocationHandler h)        throws IllegalArgumentException

6）针对上述例子进行改造：添加保姆类并改造Baby类的构造方法：

package com.bdqn.s2.javaoop.study.proxy;import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.util.Observer;/** * 保姆类 */public class Nanny implements InvocationHandler {    private Observer parents;    public Nanny(){        parents = new Parents();    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("保姆开始照顾孩子");        Object object = method.invoke(parents, args);        return object;    }}

Baby类构造函数改造：

public Baby(String name, int hungry) {        this.hungry = hungry;        this.name = name;        addObserver((Observer) Proxy.newProxyInstance(Baby.class.getClassLoader(),new Class[]{Observer.class},new Nanny()));    }

输出结果：

baby豆豆饿了，开始哭泣...保姆开始照顾孩子豆豆开始哭泣，赶紧哄宝宝啦