Android Context完全解析

Context相信所有的Android开发人员基本上每天都在接触，因为它太常见了。我们知道，Android应用都是使用Java语言来编写的，那么大家可以思考一下，一个Android程序和一个Java程序，他们最大的区别在哪里？划分界限又是什么呢？其实简单点分析，Android程序不像Java程序一样，随便创建一个类，写个main()方法就能跑了，而是要有一个完整的Android工程环境，在这个环境下，我们有像Activity、Service、BroadcastReceiver等系统组件，而这些组件并不是像一个普通的Java对象new一下就能创建实例的了，而是要有它们各自的上下文环境，也就是我们这里讨论的Context。可以这样讲，Context是维持Android程序中各组件能够正常工作的一个核心功能类。

Context的继承结构

先上图，如下：

可以看到，直系子类有两个，一个是ContextWrapper，一个是ContextImpl。那么从名字上就可以看出，ContextWrapper是上下文功能的封装类，而ContextImpl则是上下文功能的实现类。而ContextWrapper又有三个直接的子类，ContextThemeWrapper、Service和Application。其中，ContextThemeWrapper是一个带主题的封装类，而它有一个直接子类就是Activity。

在这里我们至少看到了几个所比较熟悉的面孔，Activity、Service、还有Application。由此，其实我们就已经可以得出结论了，Context一共有三种类型，分别是Application、Activity和Service。这三个类虽然分别各种承担着不同的作用，但它们都属于Context的一种，而它们具体Context的功能则是由ContextImpl类去实现的。

Context数量

其实根据上面的Context类型我们就已经可以得出答案了。Context一共有Application、Activity和Service三种类型，因此一个应用程序中Context数量的计算公式就可以这样写：

    Context数量 = Activity数量 + Service数量 + 1

上面的1代表着Application的数量，因为一个应用程序中可以有多个Activity和多个Service，但是只能有一个Application。

Application Context的设计

基本上每一个应用程序都会有一个自己的Application，并让它继承自系统的Application类，然后在自己的Application类中去封装一些通用的操作。其实这并不是Google所推荐的一种做法，因为这样我们只是把Application当成了一个通用工具类来使用的，而实际上使用一个简单的单例类也可以实现同样的功能。但是根据我的观察，有太多的项目都是这样使用Application的。当然这种做法也并没有什么副作用，只是说明还是有不少人对于Application理解的还有些欠缺。那么这里我们先来对Application的设计进行分析，讲一些大家所不知道的细节，然后再看一下平时使用Application的问题。

首先新建一个MyApplication并让它继承自Application，然后在AndroidManifest.xml文件中对MyApplication进行指定，如下所示：

<application
     android:name=".MyApplication"
     android:allowBackup="true"
     android:icon="@drawable/ic_launcher"
     android:label="@string/app_name"
     android:theme="@style/AppTheme" >
     ......
</application>

指定完成后，当我们的程序启动时Android系统就会创建一个MyApplication的实例，如果这里不指定的话就会默认创建一个Application的实例。

前面提到过，现在很多的Application都是被当作通用工具类来使用的，那么既然作为一个通用工具类，我们要怎样才能获取到它的实例呢？如下所示：

public class MainActivity extends Activity {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          MyApplication myApp = (MyApplication) getApplication();
          Log.d("TAG", "getApplication is " + myApp);
    }

}

代码很简单，只需要调用getApplication()方法就能拿到我们自定义的Application的实例了。
那么除了getApplication()方法，其实还有一个getApplicationContext()方法，这两个方法看上去好像有点关联，那么它们的区别是什么呢？我们将代码修改一下：

public class MainActivity extends Activity {

     @Override
     protected void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.activity_main);
          MyApplication myApp = (MyApplication) getApplication();
          Log.d("TAG", "getApplication is " + myApp);
          Context appContext = getApplicationContext();
          Log.d("TAG", "getApplicationContext is " + appContext);
    }

}

其实上述的这两个方法作用是相同的，都是拿到MyApplication本身的实例。

那么有的朋友可能就会问了，既然这两个方法得到的结果都是相同的，那么Android为什么要提供两个功能重复的方法呢？

那么，重点来了：

• getApplication()方法的语义性非常强，一看就知道是用来获取Application实例的，但是这个方法只有在Activity和Service中才能调用的到。
• 但是如果在一些其它的场景，比如BroadcastReceiver中也想获得Application的实例，这时就可以借助getApplicationContext()方法了 。

也就是说，getApplicationContext()方法的作用域会更广一些，任何一个Context的实例，只要调用getApplicationContext()方法都可以拿到我们的Application对象。

其实呢，除了上面两个方法之外，其实还有一个getBaseContext()方法。不过这个方法不是获得Application本身的实例，而是拿到的是ContextImpl的实例。这个ContextImpl是不是感觉有点似曾相识？回去看一下Context的继承结构图吧，ContextImpl正是上下文功能的实现类。也就是说像Application、Activity这样的类其实并不会去具体实现Context的功能，而仅仅是做了一层接口封装而已，Context的具体功能都是由ContextImpl类去完成的。那么这样的设计到底是怎么实现的呢？我们还是来看一下源码吧。因为Application、Activity、Service都是直接或间接继承自ContextWrapper的，我们就直接看ContextWrapper的源码，如下所示：

/**
* Proxying implementation of Context that simply delegates all of its calls to
* another Context.  Can be subclassed to modify behavior without changing
* the original Context.
*/
public class ContextWrapper extends Context {
     Context mBase;

     /**
       * Set the base context for this ContextWrapper.  All calls will then be
       * delegated to the base context.  Throws
       * IllegalStateException if a base context has already been set.
       *
       * @param base The new base context for this wrapper.
       */
     protected void attachBaseContext(Context base) {
           if (mBase != null) {
                 throw new IllegalStateException("Base context already set");
           }
           mBase = base;
     }

     /**
       * @return the base context as set by the constructor or setBaseContext
       */
     public Context getBaseContext() {
           return mBase;
     }

     @Override
     public AssetManager getAssets() {
           return mBase.getAssets();
     }

     @Override
     public Resources getResources() {
          return mBase.getResources();
     }

     @Override
     public ContentResolver getContentResolver() {
          return mBase.getContentResolver();
     }

     @Override
     public Looper getMainLooper() {
          return mBase.getMainLooper();
     }

     @Override
     public Context getApplicationContext() {
          return mBase.getApplicationContext();
     }

     @Override
     public String getPackageName() {
          return mBase.getPackageName();
     }

     @Override
     public void startActivity(Intent intent) {
          mBase.startActivity(intent);
     }

     @Override
     public void sendBroadcast(Intent intent) {
          mBase.sendBroadcast(intent);
     }

     @Override
     public Intent registerReceiver(
          BroadcastReceiver receiver, IntentFilter filter) {
          return mBase.registerReceiver(receiver, filter);
     }

     @Override
     public void unregisterReceiver(BroadcastReceiver receiver) {
          mBase.unregisterReceiver(receiver);
     }

     @Override
     public ComponentName startService(Intent service) {
          return mBase.startService(service);
     }

     @Override
     public boolean stopService(Intent name) {
          return mBase.stopService(name);
     }

     @Override
     public boolean bindService(Intent service, ServiceConnection conn, int flags) {
          return mBase.bindService(service, conn, flags);
     }

     @Override
     public void unbindService(ServiceConnection conn) {
          mBase.unbindService(conn);
     }

     @Override
     public Object getSystemService(String name) {
          return mBase.getSystemService(name);
     }

     ......
}

其实所有ContextWrapper中方法的实现都非常统一，就是调用了mBase对象中对应当前方法名的方法。

那么这个mBase对象又是什么呢？我们来看attachBaseContext()方法，这个方法中传入了一个base参数，并把这个参数赋值给了mBase对象。而attachBaseContext()方法其实是由系统来调用的，它会把ContextImpl对象作为参数传递到attachBaseContext()方法当中，从而赋值给mBase对象，之后ContextWrapper中的所有方法其实都是通过这种委托的机制交由ContextImpl去具体实现的，所以说ContextImpl是上下文功能的实现类是非常准确的。

在上面我们提到的getBaseContext方法中，只有一行代码，就是返回了mBase对象而已，而mBase对象其实就是ContextImpl对象。

使用Application的问题

Application是Context的其中一种类型，那么是否就意味着，只要是Application的实例，就能随时使用Context的各种方法呢？

看下面这段代码：

public class MyApplication extends Application {

     public MyApplication() {
          String packageName = getPackageName();
          Log.d("TAG", "package name is " + packageName);
     }

}

这是一个非常简单的自定义Application，我们在MyApplication的构造方法当中获取了当前应用程序的包名，并打印出来。获取包名使用了getPackageName()方法，这个方法就是由Context提供的。那么上面的代码能正常运行吗？

答案是不能的，程序在一开始的时候就会报空指针异常的。我们先卖个关子，对代码做个修改先：

public class MyApplication extends Application {

     @Override
     public void onCreate() {
          super.onCreate();
          String packageName = getPackageName();
          Log.d("TAG", "package name is " + packageName);
     }

}

可以告诉大家的是，修改之后的代码是运行成功的。

在构造方法中调用Context的方法就会崩溃，在onCreate()方法中调用Context的方法就一切正常，那么这两个方法之间到底发生了什么事情呢？我们重新回顾一下ContextWrapper类的源码，ContextWrapper中有一个attachBaseContext()方法，这个方法会将传入的一个Context参数赋值给mBase对象，之后mBase对象就有值了。而我们又知道，所有Context的方法都是调用这个mBase对象的同名方法，那么也就是说如果在mBase对象还没赋值的情况下就去调用Context中的任何一个方法时，就会出现空指针异常。

Application中在onCreate()方法里去初始化各种全局的变量数据是一种比较推荐的做法，但是如果你想把初始化的时间点提前到极致，也可以去重写attachBaseContext()方法，如下所示：

public class MyApplication extends Application {

     @Override
     protected void attachBaseContext(Context base) {
           // 在这里调用Context的方法会崩溃
           super.attachBaseContext(base);
           // 在这里可以正常调用Context的方法
     }

}

Application全局只有一个，它本身就已经是单例了，无需再用单例模式去为它做多重实例保护了

一个非常典型错误的例子如下所示：

public class MyApplication extends Application {

     private static MyApplication app;

     public static MyApplication getInstance() {
          if (app == null) {
                app = new MyApplication();
          }
          return app;
     }

}

这里的错误有两点：
- 就是刚才说到的，Application全局只有一个，它本身就已经是单例了，无需再用单例模式去为它做多重实例保护了。
- Application是属于系统组件，系统组件的实例是要由系统来去创建的，如果这里我们自己去new一个MyApplication的实例，它就只是一个普通的Java对象而已，而不具备任何Context的能力。一个普通的Java对象，它无法通过这个对象来进行Context操作。

下面才是一个获取MyApplication实例的正确方法：

public class MyApplication extends Application {

     private static MyApplication app;

     public static MyApplication getInstance() {
          return app;
     }

     @Override
     public void onCreate() {
          super.onCreate();
          app = this;
     }

}

getInstance()方法可以照常提供，但是里面不要做任何逻辑判断，直接返回app对象就可以了，而app对象又是什么呢？在onCreate()方法中我们将app对象赋值成this，this就是当前Application的实例，那么app也就是当前Application的实例了。

好了，关于Context的介绍就到这里吧，内容还是比较简单易懂的，希望大家通过这篇文章可以理解Context更多的细节，并且不要去犯使用Context时的一些低级错误。