Handler机制的工作原理

Handler 工作流程基本包括 Handler、Looper、Message、MessageQueue 四个部分，Message 负责消息的搭载，里面有个 target 用于标记消息，obj 用于存放内容，Handler 负责消息的分发和处理。Handler机制是由Looper和MessageQueue来构建消息机制的。

动手撸简易的handler

Message：

public class Message {
    String obj;
    Handler targrt;

    public Message(String obj){
        this.obj = obj;
    }
}

Message很简单，就是持有一个Handler的引用，①至于为什么要拿，后面再看。还有一个obj用来存放消息的内容。

MessageQueue：

public class MessageQueue {
    BlockingQueue<Message> mBlockingQueue = new ArrayBlockingQueue<Message>(10);

    
    public void enqueueMessage(Message msg){
        try {
            mBlockingQueue.put(msg);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public Message next(){
        Message msg = null;
        try {
            msg = mBlockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return msg;
    }
}

MessageQueue维护了一个阻塞队列，主要负责将Message对象入队出队。②谁来负责入队出队呢？

Looper:

public class Looper {
    MessageQueue mQueue;
    static final ThreadLocal<Looper> sThredLocal = new ThreadLocal<Looper>();

    private Looper(){
        mQueue = new MessageQueue();
    }

    public static void prepare(){
        if (sThredLocal.get() != null){
            throw new RuntimeException("one thread only one looper");
        }
        sThredLocal.set(new Looper());
    }

    public static Looper myLooper(){
        return sThredLocal.get();
    }

    public static void loop(){
        final Looper me = myLooper();
        final MessageQueue queue = me.mQueue;
        for (;;){
            Message msg = queue.next();
            if (msg !=null){
                msg.targrt.dispatchMessage(msg);
            }
        }
    }

}

先看构造器Looper()，初始了一个消息队列MessageQueue，而构造器的权限修饰符是私有的，不禁猜想，一个Looper对象对应一个唯一的MessageQueue。继续往下看，Looper还维护了一个ThredLocal，在看看prepare()，是把looper对象和ThredLocal相关联了，这就可以指定Looper线程单例了。最后一个方法，loop()，则负责不断的取消息，消息对象持有handler的引用，再调用handler的disspatchMessage()方法。问题2也得解。

handler：

public class Handler {
    final MessageQueue mQueue;
    final Looper mLooper;

    public Handler(){
        mLooper = Looper.myLooper();
        mQueue = mLooper.mQueue;
    }

    public void sendMessage(Message msg){
        enqueueMessage(msg);
    }

    private void enqueueMessage(Message msg) {
        msg.targrt = this;
        mQueue.enqueueMessage(msg);
    }

    public void dispatchMessage(Message msg){
        handleMessage(msg);
    }

    //最少知识原则
    public void handleMessage(Message msg) {
    }
}

Handler类有两个主要方法,sendMessage()和disspatchMessage()方法，前者主要是发送消息，后者用来处理消息。在handler的构造器中，关联好Looper对象和MessageQueue。对于问题一就很好理解了，持有handler的引用，在发送消息时就关联上了，然后在dispatchMessage来对这个消息对象来处理.