5.4.2 Handler分析
最后更新于：2022-04-02 05:50:05
1. 初识Handler
Handler中所包括的成员：
**Handler.java**
~~~
final MessageQueue mQueue;//Handler中也有一个消息队列
final Looper mLooper;//也有一个Looper
final Callback mCallback;//有一个回调用的类
~~~
这几个成员变量是怎么使用的呢？这首先得分析Handler的构造函数。Handler一共有四个构造函数，它们主要的区别，是在对上面三个重要成员变量的初始化上。我们试对其进行逐一分析。
**Handler.java**
~~~
//构造函数1
public Handler() {
//获得调用线程的Looper
mLooper = Looper.myLooper();
if(mLooper == null) {
throw new RuntimeException(......);
}
//得到Looper的消息队列
mQueue = mLooper.mQueue;
//无callback设置
mCallback = null;
}
//构造函数2
publicHandler(Callback callback) {
mLooper = Looper.myLooper();
if(mLooper == null) {
throw new RuntimeException(......);
}
//和构造函数1类似，只不过多了一个设置callback
mQueue = mLooper.mQueue;
mCallback = callback;
}
//构造函数3
publicHandler(Looper looper) {
mLooper = looper; //looper由外部传入，是哪个线程的Looper不确定
mQueue = looper.mQueue;
mCallback = null;
}
//构造函数4，和构造函数3类似，只不过多了callback设置
publicHandler(Looper looper, Callback callback) {
mLooper= looper;
mQueue = looper.mQueue;
mCallback = callback;
}
~~~
在上述构造函数中，Handler中的消息队列变量最终都会指向了Looper的消息队列，Handler为何要如此做？
2. Handler的真面目
根据前面的分析可知，Handler中的消息队列实际就是某个Looper的消息队列，那么，Handler做如此安排的目的何在？
在回答这个问题之前，我先来问一个问题：
- 怎么往Looper的消息队列插入消息？
如果不知道Handler，这里有一个很原始的方法：
- 调用Looper的myQueue，它将返回消息队列对象MessageQueue。
- 构造一个Message，填充它的成员，尤其是target变量。
- 调用MessageQueue的enqueueMessage，将消息插入消息队列。
这种原始方法的确很麻烦，且极容易出错。但有了Handler后，我们的工作就变得异常简单了。Handler更像一个辅助类，帮助我们简化编程的工作。
2.1 Handler和Message
Handle提供了一系列函数，帮助我们完成创建消息和插入消息队列的工作。这里只列举其中一二。要掌握详细的API，则需要查看相关文档。
~~~
//查看消息队列中是否有消息码是what的消息
final boolean hasMessages(int what)
//从Handler中创建一个消息码是what的消息
final Message obtainMessage(int what)
//从消息队列中移除消息码是what的消息
final void removeMessages(int what)
//发送一个只填充了消息码的消息
final boolean sendEmptyMessage(int what)
//发送一个消息,该消息添加到队列尾
final boolean sendMessage(Message msg)
//发送一个消息，该消息添加到队列头，所以优先级很高
final boolean sendMessageAtFrontOfQueue(Message msg)
~~~
只需对上面这些函数稍作分析，就能明白其他的函数。现以sendMessage为例，其代码如下所示：
**Handler.java**
~~~
public final boolean sendMessage(Message msg)
{
return sendMessageDelayed(msg, 0); //调用sendMessageDelayed
}
~~~
**Handler.java**
~~~
// delayMillis是以当前调用时间为基础的相对时间
public final boolean sendMessageDelayed(Message msg, long delayMillis)
{
if (delayMillis < 0) {
delayMillis = 0;
}
//调用sendMessageAtTime，把当前时间算上
return sendMessageAtTime(msg,SystemClock.uptimeMillis() + delayMillis);
}
~~~
**Handler.java**
~~~
//uptimeMillis 是绝对时间，即sendMessageAtTime函数处理的是绝对时间
public boolean sendMessageAtTime(Message msg, long uptimeMillis){
boolean sent = false;
MessageQueue queue = mQueue;
if (queue != null) {
//把Message的target设置为自己，然后加入到消息队列中
msg.target = this;
sent = queue.enqueueMessage(msg, uptimeMillis);
}
return sent;
}
~~~
看到上面这些函数可以想见，如果没有Handler的辅助，当我们自己操作MessageQueue的enqueueMessage时，得花费多大功夫！
Handler把Message的target设为自己，是因为Handler除了封装消息添加等功能外还封装了消息处理的接口。
2.2 Handler的消息处理
刚才，我们往Looper的消息队列中加入了一个消息，按照Looper的处理规则，它在获取消息后，会调用target的dispatchMessage函数，再把这个消息派发给Handler处理。Handler在这块是如何处理消息的呢？
**Handler.java**
~~~
public void dispatchMessage(Message msg) {
//如果Message本身有callback，则直接交给Message的callback处理
if(msg.callback != null) {
handleCallback(msg);
}else {
//如果本Handler设置了mCallback，则交给mCallback处理
if (mCallback != null) {
if (mCallback.handleMessage(msg)) {
return;
}
}
//最后才是交给子类处理
handleMessage(msg);
}
}
~~~
dispatchMessage定义了一套消息处理的优先级，它们分别是：
- Message如果自带了callback处理，则交给callback处理。
- Handler如果设置了全局的mCallback，则交给mCallback处理。
- 如果上述都没有，该消息则会被交给Handler子类实现的handleMessage来处理。当然，这需要从Handler派生并重载handleMessage函数。
在通常情况下，我们一般都是采用第三种方法，即在子类中通过重载handleMessage来完成处理工作的。
至此，Handler知识基本上讲解完了，可是在实际编码过程中还有一个重要问题需要警惕。下一节内容就将谈及此问题。
';