Android源码学习之观察者模式应用

主要内容：

观察者模式定义
观察者模式优势
Android交互事件的设计原理
观察者模式在Android源码中的应用

一、观察者模式定义

观察者模式定义：

Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically.

定义对象间一种一对多的依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

　　如上图所示（截取自《Head First Design Patterns》一书），主要包括四个部分：

　　1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。

　　2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。

　　3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。

　　4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。

二、观察者模式优势

观察者和被观察者之间是抽象耦合的，不管是增加观察者还是被观察者都非常容易扩展。

根据单一职责原则，每个类的职责是单一的，那么怎么把各个单一的职责串联成真实的复杂的逻辑关系呢，观察者模式可以起到桥梁作用。

观察者模式是松耦合的典型。

　　在Android源码中，其中一个经典的使用到观察者模式的就是Android控件的事件监听模型。

三、Android交互事件传输的设计原理和特征

　　交互事件，是指当用户通过按键、触摸、滑动等操作与应用进行交互时触发的相关事件。通过Android控件树可知，交互事件是沿着控件树自顶向下传播的。其中Android控件树简要图如下所示：



　　当位于控件树上层的父控件收到交互事件后，会先行判定该事件的目标控件对象，如果该事件正是自己所需要的，则会截获事件进行处理，否则就尝试将事件向下分发给对应的子控件，并对推的逐级向下传播事件，直至该事件被处理或者忽略。

　　Android在View类中定义了一系列命名为View.On***的事件函数用来接收和处理各类交互事件，如通过View.OnKeyDown函数可以接收到用户的按键操作等。每个派生自View类的子控件都可以通过重载这些事件函数，来处理该控件所需的事件。

　　例如，如果一个控件需要处理用户按返回键的操作，则可以通过重载View.onKeyDown函数来实现：

/*
* @see android.app.Activity#onKeyDown(int, android.view.KeyEvent)
*/
@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {
// 监听和处理返回操作
if(keyCode == KeyEvent.KEYCODE_BACK) {
doSomething();
return true;
}
return false;
}

　　事件函数的返回值是控制事件传播的重要手段。如果事件函数返回true，则说明该控件已经接收并完成了该事件的处理，无须将该事件进一步传递；反之，如果事件函数返回false，则说明该控件对象未能处理该事件（或虽然做过处理，但仍需要进一步处理），需要继续传递以寻找能够处理它的控件对象。

　　对于容器控件ViewGroup来说，它的一个职责就是将交互事件传播到其子控件中。针对不同的事件，ViewGroup可以选择不同的传播方式。如，如果是触摸事件，ViewGroup对象需要判定该事件发生的区域位于哪个子控件上，从而将该事件分配给该子控件进行处理。但通过继承的方式来进行事件处理并不够灵活，会导致系统中出现大量的子控件类型，并且各个控件的复用性都较差。因此采用“组合”来代替“继承”。基于此思想，View类中提供了一系列配套的事件监听函数供开发者处理对应事件，这就有了使用观察者模式来完成Android控件的事件监听模型。开发者可以构造外部观察者对象与控件对象的事件监听接口绑定，获取事件消息。

　　还是以上面的按键事件为例，通过监听者进行处理的实现如下所示：

final View.OnKeyListener listener = new OnKeyListener() {

@Override
public boolean onKey(View v, int keyCode, KeyEvent event) {
// 处理返回键事件
if(keyCode == KeyEvent.KEYCODE_BACK) {
doSomething();
return true;
}
return false;
}
};

。。。

mUISetButton = (Button) findViewById(R.id.setValue);
// 将按钮与监听对象绑定
mUISetButton.setOnKeyListener(listener);

　　通过利用外部对象来处理交互事件，其耦合性低，使每个类控件都具有更好的可复用度，无须为了处理事件而构造新的控件。

四、观察者模式在Android源码中的应用

　　1. 看View类源代码中的OnKeyListener接口：

/**
* Interface definition for a callback to be invoked when a key event is
* dispatched to this view. The callback will be invoked before the key
* event is given to the view.
*/
public interface OnKeyListener {
/**
* Called when a key is dispatched to a view. This allows listeners to
* get a chance to respond before the target view.
*
* @param v The view the key has been dispatched to.
* @param keyCode The code for the physical key that was pressed
* @param event The KeyEvent object containing full information about
*        the event.
* @return True if the listener has consumed the event, false otherwise.
*/
boolean onKey(View v, int keyCode, KeyEvent event);
}

　　2. 再看View类定义了私有成员mOnKeyListener（通过组合的方式）：

private OnKeyListener mOnKeyListener;

　　3. 注册listener

/**
* Register a callback to be invoked when a key is pressed in this view.
* @param l the key listener to attach to this view
*/
public void setOnKeyListener(OnKeyListener l) {
mOnKeyListener = l;
}

　　4. 剩下的就交给开发者自己构造外部观察者对象与该按键的事件接口进行绑定，获取事件消息。

　　最后让我们记住支撑“观察者模式”的设计原则： Strive for loosely coupled designs between objects that interact.

观察者模式应用实例——Broadercast实现进程间异步通信

1 Broadcast实现进程通信

利用Broadcast可以实现Android中的进程间通信。

比如，存在客户端BCClient和服务端BCService这两个不同的进程，它们之间的通信过程具体如下图所示：



通过这样的方式双方能完成通信，不过要达到异步通信的目的，需要进一步改进设计。

2实现异步通信

为了实现异步通信，需要对客户端的类进行重新设计，同时考虑到系统的扩展性、可复用性，以及服务端对外接口的易用性。选择将BCClient的视图ClientActivity剥离出去，并对ClientReceiver做进一步封装，相当于在原客户端和服务端中间构建出一层作为中间层。



为了便于说明，客户端和服务端需要一个应用场景。假设服务端负责管理系统相关设备，并提供操作设备的接口，而客户端则根据需求通过中间件来异步调用相应的服务。

比如，用户点击客户端的按钮来获取设备信息，并且点击按钮后用户不必一直等待服务端返回信息才能继续操作，而是服务端响应完成后自动通知客户端。

由于整个过程客户端不是进行同步等待，而是异步接收，设计时考虑引入设计模式中的“观察者模式”。

2.1 观察者模式

通过以上分析，明确了设计的改进重点在于对ClientReceiver的封装，并且封装采取的合理策略应当是 “观察者模式”。改进设计后ClientReceiver就被中间层所替代，中间层的类图如下：



从类图中不难看出，这是一个典型的“观察者模式”的类设计模型，DevListener对应于观察者模式中的观察者“Observer”，而DevManager就是观察者模式中的主题“Subject”。原ClientReceiver的主要功能被封装在中间层的DevReceiver类中，而服务端接口的直接调用者是DevManager类。

2.2 客户端服务端交互流程

在加入“观察者模式”后，客户端和服务端的交互流程如下：

1、客户端-->创建监听器-->在监听器中重写回调函数，用于处理服务端返回结果-->将该监听器注册到DevManager -->调用DevManager 的readDevInfo方法向服务端发送广播；

2、服务端-->利用BroadcastReceiver接受到广播信息-->处理信息-->向客户端（DevReceiver）发送广播信息；

3、客户端-->利用BroadcastReceiver（DevReceiver）接受到广播信息-->调用DevManager的notifyListener方法-->调用客户端重写好的回调函数，完成异步通信。

2.3 客户端调用

加入中间层后，客户端能够方便的使用DevManager提供的服务，在使用DevManager提供的服务时如同使用Button控件一样（Button控件的内部实现也是利用了观察者模式）方便、简洁。

客户端调用代码如下：

Java代码


public class ClientActivity extends Activity {

private static final String TAG = "ClientActivity>>>>>>>>>";

private DevManager dm;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.main);

Log.i(TAG,"onCreate");

Button button = (Button)findViewById(R.id.button);

button.setOnClickListener(new BroadcastListener());

dm = DevManager.getInstance();

dm.setDevListener(new DevListener(){

@Override

public void dealWith(DevEvent event) {

Toast.makeText(getApplicationContext(),event.getEventContent(), 10000).show();

}

});

}

class BroadcastListener implements OnClickListener{

@Override

public void onClick(View view) {

Log.i(TAG, "Click SendButton");

dm.readDevInfo(view.getContext());

}

}

}

客户端的调用服务过程主要是通过DevManager对监听器DevListener进行注册、监听。运行结果如下，当点击“send”按钮的时候发送设备读取请求，即调用readDevInfo方法，点击完成后不必等待服务端的相应。

服务端处理完客户端请求后，会向中间层的DevReceiver发送广播，DevReceiver接到广播后回调客户端重载的dealWith函数，部分代码如下：

Java代码


public void onReceive(Context context, Intent intent) {

if(intent.getAction().equals("DoServiceResponse")){

Log.i(TAG,"Action Is DoServiceResponse");

Communication info = (Communication)intent.getParcelableExtra("ResponseInfo");

if(info != null){

Log.i(TAG,"Receive ResponseInfo");

DevEvent event = new DevEvent();

event.setEventContent(info.getContent());

DevManager.getInstance().notifyListener(event);

}

}

//notifyListener的实现如下：

public void notifyListener(DevEvent event){

if(listener == null){

return;

}

else{

Log.i(TAG, "Notify Listener");

listener.dealWith(event);

}

}

回调完成后，客户端获取到服务端信息：

3 小结

观察者模式的核心思想是将数据表示层和逻辑层分离，并定义了稳定的消息传递机制、抽象出调用接口。在需要采用异步通信的应用场景中，合理地运用观察者模式往往会有很好的效果。

当然观察者模式也存在有缺陷。目前本例中的Observer（即本例中的DevListener）只有一个，如果一个Subject（即本例中的DevManager）中注册有大量Observer（即DevManager中存在一个存放DevListener的集合）的话，在广播通知Observer时存在效率问题，毕竟需要遍历集合中所有的Observer。