反射： 反射在中Android运用

JAVA反射机制是在“运行状态”中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。Java反射机制主要提供了几个功能：在运行时判断任意一个对象所属的类、在运行时构造任意一个类的对象、在运行时判断任意一个类所具有的成员变量和方法、在运行时调用任意一个对象的方法。

通过前面对反射基础的介绍，知道了反射怎么使用，接下来看看反射在Android项目中的运用。

写一个demo，设想我们想通过插件的方式，来启动一个未注册的 Activity，这就会涉及到很多问题，其中之一就是如何赋予这些插件 Activity 生命周期。这个例子就是通过反射的方式，来手动地进行 Activity 生命周期的通知。

准备工作
要实现上述的功能，首先要知道 Activity 的生命周期是如何运作的。因为反射所操作的对象是具体的 Class 对象，如果不清楚源码细节，反射将无从说起。

对Activity生命周期管理要熟悉，大体上Activity 生命周期与 ActivityThread 相关，先看看 Activity 是怎么启动的。当需要启动 Activity 时，ActivityManagerService 会通过 Binder 机制向 ActivityThread 发送消息，经过链式地调用后，会执行到scheduleLaunchActivity 这个方法，

public final void scheduleLaunchActivity(...) {

     ......
     //scheduleLaunchActivity最终是通过handler处理的
    sendMessage(H.LAUNCH_ACTIVITY, r);
}

说明内部是采用的 handler 机制来进行通信的。会调用 ActivityThread 的 main 方法，并在这个方法中进行相应的消息循环初始化，其后在主线程上的消息传递都是通过 ActivityThread 中的 H 这个内部来进行初始化，这个H就是我们要关心的。

private class H extends Handler {
    public static final int LAUNCH_ACTIVITY         = 100;
    public static final int PAUSE_ACTIVITY          = 101;
    public static final int PAUSE_ACTIVITY_FINISHING= 102;
    public static final int STOP_ACTIVITY_SHOW      = 103;
    public static final int STOP_ACTIVITY_HIDE      = 104;
    public static final int SHOW_WINDOW             = 105;
    public static final int HIDE_WINDOW             = 106;
    public static final int RESUME_ACTIVITY         = 107;
    public static final int SEND_RESULT             = 108;
    public static final int DESTROY_ACTIVITY        = 109;
    public static final int BIND_APPLICATION        = 110;
    public static final int EXIT_APPLICATION        = 111;
    public static final int NEW_INTENT              = 112;
    public static final int RECEIVER                = 113;
    public static final int CREATE_SERVICE          = 114;
    public static final int SERVICE_ARGS            = 115;
    public static final int STOP_SERVICE            = 116;

    //......

    public void handleMessage(Message msg){
        // ...
    }
}

可以看出这个H处理了Activity的生命周期相关的逻辑，Handler 在内部维护着一个 callback 对象，当有消息发生时，会通过这个 callback 往外发送消息，如果能够替换 callback 变量，这样消息就可以传递到替换后的 callback 里了，就可以实现我们想要的效果了。

public void dispatchMessage(Message msg) {
    if (msg.callback != null) {
        handleCallback(msg);
    } else {
        if (mCallback != null) {
            if (mCallback.handleMessage(msg)) {
                return;
            }
        }
        handleMessage(msg);
    }
}

开始上手
首先，我们自定义出自定义的 callback 对象，这个 callback 作为 H 中 callback 的代理，这里需要注意的是 msg 的定义要和底层保持一致，代码如下：

public class myHandlerCallBack implements Handler.Callback {
  //常量值和系统的值保持一致
    public static final int LAUNCH_ACTIVITY = 100;
    public static final int NEW_INTENT = 112;
    Handler handler;
    private String TAG = myHandlerCallBack.class.getName();

    public myHandlerCallBack(Handler handler) {
        this.handler = handler;
    }

    @Override
    public boolean handleMessage(Message msg) {
        if(handler == null){
            return false;
        }
        if (msg.what == LAUNCH_ACTIVITY) {
            Log.i(TAG, "activity is going to launch! ");
        }else if (msg.what == NEW_INTENT){
            Log.i(TAG, "activity is going to new intent! ");
        }
        handler.handleMessage(msg);
        return true;
    }
}

myHandlerCallBack 对Activity的两个生命周期做了处理（打印log），其他方法自己去尝试。

其次，通过前文提及的反射方法，将运行的 callback 替换为自定义的 callback

public class ReflectUtil {

    private static String TAG = ReflectUtil.class.getName();

    public static void replaceCallBack() {
        try {
            // 通过反射调用 ActivityThread 的静态方法, 获取 currentActivityThread
            Class classAThread = Class.forName("android.app.ActivityThread");
            Method method = classAThread.getDeclaredMethod("currentActivityThread");
            method.setAccessible(true);
            Object currentActivityThread = method.invoke(null);
            // 获取 currentActivityThread 这个示例中的 mH
            Field fieldH = classAThread.getDeclaredField("mH");
            fieldH.setAccessible(true);
            Handler handler = (Handler) fieldH.get(currentActivityThread);

            // 修改 mH 中的 callback 字段
           Field callBackField = Handler.class.getDeclaredField("mCallback");
            callBackField.setAccessible(true);
            //这里没有直接反射出handler的mCallBack属性，而是直接使用了handler，主要是因为mCallBack可能为空
            //Handler.Callback callback = (Handler.Callback) callbackField.get(handler);

            callBackField.set(handler, new myHandlerCallBack(handler));

        } catch (ClassNotFoundException e) {
            Log.i(TAG, "ClassNotFoundException------- "+e.toString());
        } catch (Exception e) {
            Log.i(TAG, "Exception------- "+e.toString());
        }

    }

最后，在 Application 中进行注入，完成修改。

@Override
protected void attachBaseContext(Context base) {
    super.attachBaseContext(base);
    ReflectUtil.replaceCallBack();
}

测试流程：
先启动Activity A （singleTask），然后在A中启动Activity B，再点击启动 Activity A

打印日志：

07-31 22:34:45.850 12511-12511/com.example.administrator.myapplication I/com.example.administrator.myapplication.myHandlerCallBack: activity is going to launch! 
07-31 22:34:52.840 12511-12511/com.example.administrator.myapplication I/com.example.administrator.myapplication.myHandlerCallBack: activity is going to launch! 
07-31 22:35:03.960 12511-12511/com.example.administrator.myapplication I/com.example.administrator.myapplication.myHandlerCallBack: activity is going to new intent!