观察者设计模式 Vs 事件委托

设计模式 java 事件的委托

转载请注明原博客地址： http://blog.csdn.net/gdutxiaoxu/article/details/51824769

源码下载地址： http://download.csdn.net/detail/gdutxiaoxu/9567209

本篇博客主要讲解一下几个问题

1. 什么是观察者模式
2. 观察者模式的优缺点
3. 如何看待观察者模式的缺点
4. 事件的委托

什么是观察者模式

简单来说，当有多个观察者想同时观察同一个主题对象的时候，当主题对象的 状态发生变化，观察者能够回调自身的方法去更新自己

观察者模式的类UML图

实现步骤

1. 要定义一个观察者接口
2. 观察者实现观察者接口
3. 要有一个被通知者接口，里面有addObserver（Observer observer），
   removeObserver（Observer observer）， notifyObservers（）方法
4. 在被观察者发生变化的时候，调用 notifyObservers（），遍历List，回调observer里面的方法

举例：

1. Android系统内容提供者 ，内容观察者就采用了这种观察者模式
2. RecyClerView和ListView的 Adapter就采用了观察者模式,关于RecyclerView的Adapter是怎样实现观察者模式的，可以参考我的 这篇博客 关于RecyclerView的Adapter的notifyItemInserted（）的一些分析
3. 当两个界面想同时观察下载进度的话，可以采用观察者模式来解耦。

情景实例

班主任来啦！
小A对小B说：“今天真是笑死人了，我们班一位同学在仔细的时候看NBA球赛，被班主任抓了个正着。班主任脸都绿了，哈哈，真是笑死我了。
小B说：”啊，你们怎么同学怎么敢在课上看电视啊？“
小A说：”没有的，他们那帮子男生经常自习的时候看球赛的。我们班有个女生坐在前排，那些男生就给她送写小礼物啊什么的。班主任来了，那个女生就去通知敲一下桌子。“
小B说：”好吧。这也行。那今天怎么会有人被抓？“
小A说：”这是因为刚好班主任来的时候，那个女生去上厕所了。结果一个看漫画的男生没被抓，那个看NBA球赛的男生被抓了。手机都被没收了呢！”
小B说：“好吧。你说的这个场景，让我想起了一个设计模式，叫做观察者模式。要不给你讲讲？”
小A吐血，倒地不起。。。。。。

代码示例：

• 我们先来看一下被观察者接口

public interface Subject {
    /**
     * 添加观察者
     * @param observer
     */
    void addObserver(Observer observer);
    /**
     * 移除指定的观察者
     * @param observer
     */
    void removeObserver(Observer observer);
    /**
     * 移除所有的观察者
     */
    void removeAll();
    /**
     * data 是要通知给观察者的数据
     * 因为Object是所有类的父类，可以使用多态，当然 你也可以使用 泛型
     * @param data
     */
    void notifyAllObserver(Object data);
    /**
     * 单独 通知某一个观察者
     * @param observer
     * @param data
     *  data 是要通知给观察者的数据
     * 因为Object是所有类的父类，可以使用多态，当然 你也可以使用 泛型
     */
    void notify(Observer observer,Object data);
}

• 接着我们先来看一下观察者接口

/**
 * 观察者接口
 * @author Administrator
 *
 */
public interface Observer {
    /**
     * 
     * @param subject 被观察者
     * @param data    被观察者传递给观察者的 数据
     */
    void update(Subject subject,Object data);
}

• 接下来我们来看一下ConcreteSubject是怎样实现的，
  
  1. 简单来说就是当添加观察者的时候判断是否存在当前的观察者 ，不存在的话，添加到List集合当中
  2. 移除观察者的时候直接从List集合移除
  3. 当Subject的状态发生变化的时候，遍历List，调用Observer的update方法去更新自身

/**
 * 具体的主题对象 
 * 这里就不实现线程安全的功能了，
 * 有兴趣的话可以参考java.util报下的Observable
 * @author xujun
 *
 */
public class ConcreteSubject implements Subject {
    List<Observer> mList = new ArrayList<>();
    @Override
    public void addObserver(Observer observer) {
        // 确保相同的观察者只含有一个
        if (observer == null) {
            throw new NullPointerException("observer == null");
        }
        if (!mList.contains(observer)) {
            mList.add(observer);
        }
    }
    @Override
    public void removeObserver(Observer observer) {
        mList.remove(observer);
    }
    @Override
    public void removeAll() {
       mList.clear();
    }
    @Override
    public void notifyAllObserver(Object data) {
        for (Observer observer : mList) {
            observer.update(this,data);
        }
    }
    @Override
    public void notify(Observer observer, Object data) {
        if(observer!=null){
            observer.update(this, data);
        }
    }
}

• 最后我们来看一下具体的ConcreteObserver具体做了什么?
  这里为了方便，就只是打印出当前的类名和通知者发出的消息而已，在具体的情景当中，我们可以拿着 Object data 去更新 自身的状态。

public class NBAObserver implements Observer {
    @Override
    public void update(Subject subject, Object data) {
        System.out.println( " 我是"+this.getClass().
                getSimpleName()+"，  "+data+"别看NBA了");
    }
}

public class CartoonObserver implements Observer {
    @Override
    public void update(Subject subject, Object data) {
        System.out.println( " 我是"+this.getClass().
                getSimpleName()+"，  "+data+"别看漫画了");    
    }
}

• 运行一下测试代码

public class TestObserver {
    public static void main(String[] args) {
        ConcreteSubject concreteSubject = new ConcreteSubject();
        CartoonObserver cartoonObserver = new CartoonObserver();
        NBAObserver nbaObserver = new NBAObserver();
        concreteSubject.addObserver(cartoonObserver);
        concreteSubject.addObserver(nbaObserver);
        concreteSubject.notifyAllObserver("老师来了");
    }
}

我们可以看到 输出以下的信息

我是CartoonObserver， 老师来了别看漫画了

我是NBAObserver， 老师来了别看NBA了

观察者模式的实现分析到此为止

观察者模式的优缺点

优点

很好地解耦了通知者与观察者，观察者不需要了解通知者内部是怎样实现的，方便于日后代码的修改，体现了 依赖倒转的原则。

缺点分析：

分析：

1. “上面该机的代码中抽象通知者还是依赖了抽象观察者，万一没有抽象观察者，那岂不是功能都完成不了啦！
2. 还有你这上面代码写的，所以对象更新的动作都一样的。万一我对象更新不一样呢？比如，看NBA球赛的听见班主任来了就跑去上厕所，而看漫画的听见班主任来了就继续看书。代码又应该怎么写呢？”小A，揉了揉惺忪的睡眼，疑惑地问道。
3. 小B说：“我去，我还以为你睡着了呢！原来你在听啊！我太高兴了。下面我们就利用一种叫做“事件委托”的东东去解决这个问题哈！”
4. 小A说：“我滴个神，什么叫事件委托啊？”

解决方法

1.解决方法，使用事件委托

事件委托

我们先来看一下 我们的通知者GoodNotifier是怎样实现的？

public class GoodNotifier extends Notifier {   
    @Override  
    public void addListener(Object object, String methodName, Object... args) {   
        System.out.println("有新的同学委托尽职尽责的放哨人!");   
        EventHandler handler = this.getEventHandler();
        handler.addEvent(object, methodName, args);   
    }   
    @Override  
    public void notifyX() {   
        System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
        try{   
            this.getEventHandler().notifyX();   
        }catch(Exception e){   
            e.printStackTrace();   
        }   
    }   
}   

接着我们在来 看它的父类Notifier是怎样实现的

/**
 * 通知者的 抽象类
 * @author xujun
 *
 */
public abstract class Notifier {
    private EventHandler eventHandler = new EventHandler();
    public EventHandler getEventHandler() {
        return eventHandler;
    }
    public void setEventHandler(EventHandler eventHandler) {
        this.eventHandler = eventHandler;
    }
    /**
     * 增加需要帮忙 放哨 的 学生
     * 
     * @param object 要执行方法的对象
     * @param methodName 执行方法 的方法名
     * @param args   执行方法的参数
     */
    public abstract void addListener(Object object, String methodName,
            Object... args);
    /**
     * 告诉所有要帮忙放哨的学生：老师来了
     */
    public abstract void notifyX();
}

看了上面notifier的代码以后，你是不是有一种似曾相识的感觉，是不是感觉跟我们的观察者模式中的通知者很相似

• 观察者模式我们的通知者是这样实现的

@Override
    public void notifyAllObserver(Object data) {
        for (Observer observer : mList) {
            observer.update(this,data);
        }
    }

• 在事件委托中我们是这样实现的

 @Override  
    public void notifyX() {   
        System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
        try{   
            EventHandler handler = this.getEventHandler();
            handler.notifyX();   
        }catch(Exception e){   
            e.printStackTrace();   
        }   
    }   

• 两者的区别其实即使我们将其交给EventHandler去处理

下面我们来看一下EventHandler我们是怎样实现的

/**
 * 事件的 处理者
 * @author Administrator
 *
 */
public class EventHandler {   
    //是用一个List   
    private List<Event> objects;   
    public EventHandler(){   
        objects=new ArrayList<Event>();   
    }   
    //添加某个对象要执行的事件，及需要的参数   
    public void addEvent(Object object,String methodName,Object...args){   
        objects.add(new Event(object,methodName,args));   
    }   
    //通知所有的对象执行指定的事件   
    public void notifyX() throws Exception{   
        for(Event e : objects){   
            e.invoke();   
        }   
    }   
} 

其实跟观察者 模式一样，我们把我们的事件对象存储在

objects=new ArrayList<Event>();  

当我们添加 事件的时候，把事件封装为Event对象，再添加到objects中

objects.add(new Event(object,methodName,args));   

当我们要通知事件的时候，再遍历List，通知每一个事件对象

for(Event e : objects){   
     e.invoke();   
} 

看到invoke()这个方法，你是不是想到了什么，没错，就是java的反射机制，我们封装在Event类 中，下面我们来看一下Event类是怎样实现的

/**
 * 事件对象的封装类
 * @author Administrator
 *
 */
public class Event {   
    //要执行方法的对象   
    private Object object;   
    //要执行的方法名称   
    private String methodName;   
    //要执行方法的参数   
    private Object[] params;   
    //要执行方法的参数类型   
    private Class[] paramTypes;   
    public Event(){   
    }   
    public Event(Object object,String methodName,Object...args){   
        this.object=object;   
        this.methodName=methodName;   
        this.params=args;   
        contractParamTypes(this.params);   
    }   
    //根据参数数组生成参数类型数组   
    private void contractParamTypes(Object[] params){   
        this.paramTypes=new Class[params.length];   
        for(int i=0;i<params.length;i++){   
            this.paramTypes[i]=params[i].getClass();   
        }   
    }   
    public Object getObject() {
        return object;
    }
  //这里省略了若干get和set方法
    /**
     * 根据该对象的方法名，方法参数，利用反射机制，执行该方法  
     * @throws Exception
     */
    public void invoke() throws Exception{   
        Method method=object.getClass().getMethod(this.getMethodName(),
                         this.getParamTypes());   
        if(null==method){   
            return;   
        }   
        method.invoke(this.getObject(), this.getParams());   
    }   
}

在Event类我们invoke()方法所做的工作就是根据我们的对象的方法名，方法参数，利用发射执行方法

运行一下 测试代码

//创建一个尽职尽责的放哨者   
Notifier goodNotifier=new GoodNotifier();   
//创建一个玩游戏的同学，开始玩游戏   
WatchCartoonListener playingGameListener=new WatchCartoonListener();  
//创建一个看电视的同学，开始看电视   
WatchingNBAListener watchingTVListener=new WatchingNBAListener();   
//玩游戏的同学告诉放哨的同学，老师来了告诉一下   
goodNotifier.addListener(playingGameListener, "stopPlayingGame",new Date());   
//看电视的同学告诉放哨的同学，老师来了告诉一下   
goodNotifier.addListener(watchingTVListener, "stopWatchingTV",new Date());   
try{   
     //一点时间后   
     Thread.sleep(1000);   
    }catch(Exception e){   
      e.printStackTrace();   
    }   
//老师出现，放哨的人通知所有要帮忙的同学:老师来了   
goodNotifier.notifyX();

结果 如下

WatchCartoonListener 我正在看漫画，开始时间：Mon Jul 04 13:25:34 CST 2016

WatchingNBAListener我正在看NBA,开始时间是： Mon Jul 04 13:25:34 CST 2016

有新的同学委托尽职尽责的放哨人!

有新的同学委托尽职尽责的放哨人!

尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了

WatchCartoonListener 老师来了，不要看漫画了，结束时间：Mon Jul 04 13:25:34 CST 2016

WatchingNBAListener老师来了，快关闭NBA直播 ， 结束时间是：Mon Jul 04 13:25:34 CST 2016

总结

观察者优缺点

优点
很好地解耦了代码，体现了 依赖倒转的原则

缺点:

1. 抽象通知者还是依赖了抽象观察者，当没有观察者的时候，没办法更新
2. 要求观察者的所有动作 必须一样 ，如果不一样的话，不能实现

事件委托机制 分析

1. 放哨者完全不知道做游戏者的存在，完全解耦。（当然，功劳归功于Event和EventHandler，且这两个类具有通用性）

2. 老师来了后游戏者停止游戏回到座位，看NBA者停止看NBA，看漫画这停止看漫画，玩游戏这停止玩游戏。（一次通知，执行了不同类的不同方法）

3. 扩展性很高，再来一个打篮球的学生就先写个打篮球学生类，并在测试代码中告诉放哨者一下就好，放哨者完全没有变。重用性好

PS：Java中是没有像c#delegate关键字的，所以我是通过用Java中的反射来实现，

题外话：为了写这篇博客，也是蛮累的，前前后后查阅了很多资料，不过还是很值得，加深了我对观察者模式的理解，更重要的是学会了如何在实际中运用反射机制

参考文章：http://blog.csdn.net/XIAXIA__/article/details/41803473

转载请注明原博客地址： http://blog.csdn.net/gdutxiaoxu/article/details/51824769

源码下载地址： http://download.csdn.net/detail/gdutxiaoxu/9567209