JAVA中Context的详细介绍和实例分析

最熟悉的陌生人——Context

刚刚学android或者js等，都会看见这个频繁的字眼——Context。
意为”上下文“。

本文主要记述，Context到底是什么、如何理解Context、一个APP可以有几个Context、Context能干啥、Context的作用域、获取Context、全局获取Context技巧。

思考：

Java:万物皆对象。Flutter:万物皆组件。
俗语：”没对象吗？自己new一个啊~“
既然大多数情况可以new一个实例，那么，我们在android中的Activity实例怎么获取呢？Activity.instance可以获取activity。既然Activity也大致归属于一个类，那么可不可以用 Activity activity=new Activity(); 呢？安卓不像Java程序一样，随便创建一个类，写个main(）方法就能运行，**Android应用模型是基于组件的应用设计模式，组件的运行要有一个完整的Android工程环境。在这个环境下，Activity、Service等系统组件才能正常工作，而这些组件不能采用普通的java对象创建方式，new一下是不能创建实例的，而是要有它们各自的上下文环境，也就是Context.
所以说，Context是维持android各组件能够正常工作的一个核心功能类。

what 's Context:

(本图为沙拉查词给出的中文翻译)

有点晦涩难懂。但在程序中，我们可理解为当前对象在程序中所处的一个环境，一个与系统交互的过程。 比如QQ和你们自己的女朋友聊天时（没有grilfriend的可自己跳过举例），此时的context是指的聊天界面以及相关的数据请求与传输，Context在加载资源、启动Activity、获取系统服务、创建View等操作都要参与。

所以，一个Activity就是一个Context（getActivity()==getContext），一个Service也是一个Context。Android把场景抽象为Context类，用户和操作系统的每一次交互都是一个场景，比如：打电话、发短信等，都有activity，还有一些我们肉眼看不见的后台服务。一个应用程序可以认为是一个工作环境，用户在这个环境中切换到不同的场景，这就像服务员，客户可能是外卖小哥、也可能是农民工等，这些就是不同的场景，而服务员就是一个应用程序。

How to understand the ‘Context':

Context理解为”上下文“/”场景“，可能还是很抽象。那么我们可以做一个比喻：
一个APP是仙剑奇侠传3电视剧，Activity、Service、BroadcastReceiver、ContentProvider这四大组件就是电视剧的主角。它们是导演(系统)一开始就确定好试镜成功的人。换言之， 不是我们每个人都能被导演认可的。有了演员，就要有镜头啊，这个镜头便是(Context)。通过镜头，我们才能看见帅气 的胡歌。演员们都是在镜头(Context环境)下表演的。那么Button这些组件子类型就是配角，它们没有那么重要，随便一个组件都能参与演出（即随便new 一个实例），但是它们也需要参与镜头，不然一部戏只有主角多没意思，魔尊重楼还是要的，魔尊也要露面(工作在Context环境下)，所以可以用代码new Button()；或者xml布局定义一个button。

打开AndroidStudio，输入Context，然后ctrl+鼠标左键追朔其源码(看源码一般都先看注释便于理解)：import android.content.Context;

看注释，TMD，是English，那么笔者这里就用小学生英语水平来翻译一哈哈：
Context提供了关于应用环境全局信息的接口。它是一个abstract类，它的执行被Android系统提供，允许获取以应用为特征的资源和类型，是一个统领一些资源APP环境变量等的上下文。通过它可以获取应用程序的资源和类（包括应用级别操作，如启动Activity，发广播，接收intent等）。abstract会有它的实现类。在源码中，我们可以通过AndroidStudio去查看它的子类，得到以下关系：
它有2个具体实现子类：ContextImpl、ContextWrapper。

• 其中，ContextWrapper类，只是一个包装类，其构造函数中必须包含一个Context引用，同时它提供了attachBaseContext(）用于给ContextWrapper对象中指定真正的Context对象，调用它的方法都会被转向其所包含的真正的Context对象。
• ContextThemeWrapper类其内部包含了与主题相关的接口。主题就是清单文件中android:theme为Application或Activity元素指定的主题。（Activity才需要主题，Serviceu不需要，因为服务是没有界面的后台场景，所以服务直接继承ContextWrapper。Application同理。）而Contextlmpl类则是真正实现了Context中的所有函数，应用程序中所调用的各种Context类的方法，其实现均来自这个类。
• 换言之：Context的2个实现子类分工的，其中ContextImpl是Context的具体是实现类，而ContextWrapper则是Context的包装类。Activity、Application、Service都继承自ContextWrapper(Activity继承自ContextWrapper的子类ContextThemeWrapper)，但它们的初始化过程中都会创建ContextImpl对象，由ContextImpl实现Context中的方法。

How much has Context in a App:

关键在于对COntext的理解。从上面提到的实现子类可以看出，在APP中，Context的具体实现子类是Acitivity、Service、Applicaiton。所以Context's number=Activity's number + Service's number+1(1个APP只有一个Application)。为啥不是4大组件，上面不是说四大组件也是主角吗？看看BroadcastReceiver和ContentProvider的源码可以知道它们并不是Context的子类，它们持有的Context都是其他地方传递过去的(比如我们发送广播intent中的context就是外部传递过来的)，所以不计数它们。

Context's method:

Context哪里会用到它。刚开始了解Android的时候不知道它是个啥玩意儿，但是久了发现有些地方就不得不传这个参数。
比如Toast、启动Activity、启动Service、发送广播、操作数据库等等都需要传Context参数，具体例子就不说了。详细可以看后文将提到的如何获取它。

Context's 作用域

不是随便获取一个Context实例就可以的，它的使用有一些规则和限制。因为Context的具体实例是由ContextImpl类去实现的，因此，Activity、Service、Application3种类型的Context都是等价的。但是，需要注意的是，，有些场景，比如启动Activity、弹出Dialog等。为了安全，Android不允许Activity或者Dialog凭空出现，一个Activity的启动肯定是由另一个Activity负责的，也就是以此形成的返回栈（具体可以看看任主席的《Android开发艺术探索》）而Dialog则必须是在一个Activity上弹出（系统Alert类型的Dialog除外），这种情况下， 我们只能用Activity类型的Context，否则报错。

Activity继承自ContextThemeWrapper，而Application和Service继承ContextWrapper，所以ContextThemeWrapper在ContextWrapper的基础上作了一些操作，使得Activity更加厉害。

关于表格中提到的Application和Service不推荐的2种情况：

1.如果用ApplicationContext去启动一个LaunchMode为standard的Activity的时候会报错：androud,util.AndroidRuntimeException:Calling startActivity from outside of an Activity context require the FLAG_ACTIVITY_NEW_TASK flag。Is this really what you want?
翻译一下，并了解这个FLAG的都知道，此时的非Activity类型的Context并没有所谓的返回栈，因此带启动的Activity就找不到栈。它还给我们明确之处了FLAG的解决办法，这样启动的时候就为它创建一个新的任务栈，而此时Activity是以Single Task模式启动的。所以这种用Application Context启动Activity的方式不推荐，Service同理。

2.在Application和Service中去layout inflate也是合法的，但是会使用系统默认的主题样式，如果自定义了某些样式可能不会被使用，所以也不推荐。

注：和UI相关的，都应该使用Activity Context来处理。其他的一些操作，Service、Activity、Application等实例都是可以的。同时要注意Context的引用持有，防止内存泄漏。可在被销毁的时候，置Context为null。

How to get the ‘Context':

常用4种方法获取Context对象：

1.View.getContext()：返回当前View对象的Context对象。通常是当前正在展示的Activity对象。
1.Activity,getApplicationContext()[后文会详细介绍这个方法]：获取当前Activity所在应用进程的Context对象，通常我们使用3.Context对象时，要优先考虑这个全局的进程Context。
ContextWrapper.getBaseContext()：用来获取一个ContextWrapper进行装饰之前的Context。实际开发很少用，也不建议使用。
4.Activity.this：返回当前Activity的实例，如果的UI控件需要使用Activity作为Context对象，但默认的Toast实际上使用的ApplicationContext也可以。
实现View.OnClick监听方法中，写Toast，不要用this,因为this,在onClick(View view)指的是view对象而不是Activity实例，所以在这个方法中，应该使用”当前的Activity名.this“，这是入门者比较容易混淆的地方。

getApplication()和getApplicationContext()：
获取当前Application对象用getApplicationContext.但是getApplication又是什么。
我们可以自己写代码打印一下：

Application app=(Application)getApplication();
Log.e(TAG,"getApplication is "+app);
Context context=getApplicationContext();
Log.e(TAG,"getApplicationContext is "+ context);

运行后看logcat，效果图就不贴了（电脑卡）。从打印结果可以看出它们2个的内存地址是相同的，即它们是同一个对象。 因为Application本来就是一个Context，那么这里获取的getApplicationContext()自然也是Application本身的实例了。那这2个相同方法存在的意义是啥？（双胞胎？）实际上这2个方法在作用域上有比较大的区别。 getApplication（）一看就知道是用来获取Application实例的(道理可以联想getActivity())。但getApplication()只有在Activity和Service中才能调用的到。 对于比如BroadcastReceiver等中也想要获取Application实例，这时就需要getApplicationContext()方法。

//继承BroadcastReceiver并重写onReceive()方法
@Override
public void onReceive(Context context.Intent intent){
 Application app=(Application)context.getApplicationContext();
}

内存泄漏之Context：

我们经常会遇到内存泄漏，比如Activity销毁了，但是Context还持有该Activity的引用，造成了内存泄漏。(经常遇到)

2种典型的错误引用方式：

1.错误的单例模式：

public class Singleton{
 private static Singleton instancel
 private Context context;
 private Singleton(Context context){
 this.context=context;
 }
 public static Singleton getInstance(Context context){
 if(instance == null ){
 instance=new Singleton(context);
 }
 return instance;
 }
}

熟悉单例模式的都知道，这是一个非线程安全的单例模式，instance作为静态对象，其生命周期要长于普通的对象（单例直到APP退出后台才销毁），其中也包含了Activity。比如Activity A去getInstance()得到instance对象，传入this,常驻内存的Singleton保存了我们传入的A对象，并一直持有，即使Activity被销毁掉，但因为它的引用还存在于一个Singleton中，就不可能被GC掉，这样就导致了内存泄漏。比如典型的数据库操作，存储数据，需要重复的去索取数据，用单例保持数据和拿到Activity持有context引用，因为单例可以看作是上帝，它帮我们保存数据。所以即使Activity被finish掉，还有它的引用在Singleton中。

View持有Activity引用：

public class MainActivity extend Activity{
 private static Drawable mDrawable; 
 @Override
 protected void onCreate(Bundle saveInstanceState){
 super.onCreate();
 setContentView(R.layout.activity_main);
 ImageView imageview=new ImageView(this);//通过代码动态的创建组件，而不是传统的xml配置组件，这里的ImageView持有当前Activity的引用。
 mDrawable=getResources().getDrawable(R.drawable.ic_launcher);
 imageview.setImageDrawable(mDrawable);
 }
}

上述代码中，有一个static的Drawable对象。当ImageView设置这个Drawable的时候，ImageView保存了这个mDrawable的引用，而ImageView初始化的时候又传入了this,此处的this是指MainActivity的context。因为被static修饰的mDrawable是常驻内存的(比类还要早加载)。MainActivity是它的间接引用了，当MainActivity被销毁的时候，也不能被GC掉，就造成了内存泄漏。

How to get the context in the whole :

大量的地方都需要使用Context，我们常常会因为不知道怎么得到这个Context而苦恼。那么，全局获取Context无疑是最好的解决方案。
很多时候，我们也不是经常为得不到Context而发愁，毕竟我们很多的操作都是在活动中进行的，而活动本身就是一个Context对象。但APP架构复杂后，很多逻辑代码都脱离了Activity类，此时又需要使用Context，所以我们需要采取全局获取Context的方法。
举例， 我们平常经常会写网络工具类，比如下面的这些代码：

public calss HttpUtil{
 public static void sendHttpRequest(final String address,final HttpCallbackListener listener){
 new Thread(new Runnable()){
 @Override 
 public void run(){
 HttpURLConnection connection=null;
 try{
 URL url =new URL(address);
 connection=(HttpURLConnection)url.openConnection();
 connection.setRequestMethod("GET");
 connection.setConnectTimeout(8000);
 connection.setReadTimeout(8000);
 connection.setDoInput(true);
 connection.setDoOutput(true);
 InputStream in =connection.getInputStream();
 BufferedReader reader=new BufferedReader(new InputStreamReader(in));
 StringBuilder response=new StringBuilder();
 String line;
 while((line=reader.readLine())!=nulll){
 response.append(line);
 }
 if(listener!=null){
 //回调onFinish()
 listener.onFinish(response.toString);
 }
 }catch(Execption e){
 if(listener!=null){
 //回调onError()
 listener.onError(e);
 }
 }finally{
 if(connection!=null){
 connection.disconnect();
 }
 }
 }}.start();
 }
}

上述代码中使用sendHttpRequest()方法来发送HTTP请求显然没问题。并且还可以在回调方法中处理服务器返回的数据。但是这个方法还可以被优化。当检测不到网络存在的时候就给用户一个Toast，并不再执行后面的代码。问题来了，Toast需要一个Context参数，但是在本来没有可以传递的Context对象。。。
一般思路：在方法中添加一个COntext参数：

 public static void sendHttpRequest(final String address,final HttpCallbackListener listener，final Context context){
 if(!isNetWorkAvailable()){
 Toast.makeText(context,……);
 ……
 }
 ……

看似可以，但是有点甩锅。我们将获取Context的任务转移到了sendHttpRequest()方法的调用方。至于调用方能不能得到COntext对象就不是我们要考虑的问题了。

甩锅不一定是通用的解决方案。于是这里介绍哈如何获取全局Context的步骤：,通过它在项目的任何地方都能轻松的获取到Context。：

Android提供了一个Application类，每当APP启动的时候，系统就会自动将这个类进行初始化。我们可以定制一个自己的Application类，以便管理程序内一些全局的状态信息，比如说全局Context。
定制一个自己的Application并不复杂，首先， 需要创建一个MyApplication类继承自系统的Application:

public calss MyApplication extends Application{
 private static Context context;
 @Overrride
 public void onCreate(){
 context=getApplicationContext();
 }
 public static Context getContext(){
 return context;
 }
}

代码很简单，容易理解。重写了父类的onCreate()方法，并通过调用getApplicationContext()方法得到一个应用程序级别的Context，然后又提供了一个静态的getContext()方法，在这里将刚才获取到的COntext进行返回。

接下来，我们需要告诉系统，当程序启动的时候应该初始化MyApplication类，而不是系统默认的Application类。这一步需要在清单文件里面实现，找到清单文件的<application>标签下进行指定就可以了：

<manifest ……
……>
<application 
 android :name="com.example.myContext.MyApplication" //这里输入.MyApplication也可以，或者输入MyApplication根据AS提示自动补全包名
 ..>
</application>

注意：这里一定要加上完整的包名，不然系统将无法找到这个类。

以上就是实现了一种全局获取Context的机制，在这个项目的任何地方使用Context，只需要调用MyApplication.getContext()就可以了。

关于自定义Application和LitePal配置冲突的问题：

自定义需要在清单文件写出android.name="……"。而为了让LitePal可以正常工作，也需要在清单文件下，配置：

android:name="org.litepal.LitePalApplication"

道理也是一样的，这样配置后，LitePal就能在内部自动获取到Context了。
问题：当都已经配置过自定义的Application怎么办？岂不是和LitePalApplication冲突了？
解答：任何一个项目都只能配置一个Application. 对于这种情况，LitePalApplication给出了很简单的解决方案，在自定义的Application中去调用LitePal的初始化方法就可以了：

public calss MyApplication extends Application{
 private static Context context;
 @Overrride
 public void onCreate(){
 context=getApplicationContext();
 LitePalApplication.initialize(context);
 }
 public static Context getContext(){
 return context;
 }
}

这种写法就相当于我们把全局Context对象通过参数传递给了LitePal，效果和在清单文件配置LitePalApplication是一样的。

总结，如何在程序中正确的使用Context:

一般Context造成的内存泄漏，几乎都是当Context销毁的时候，因为被引用导致销毁失败。而Application的Context对象可以简单的理解为伴随着进程存在的（它的生命周期也很长，毕竟APP加载的时候先加载Application,我们可以自定义Application然后继承系统的Application）。
正确使用：

当Applicatin的Context能搞定的情况下，并且生命周期长的对象，优先使用Application的Context;
不要让生命周期长于Activity的对象持有Activity的引用。
尽量不要在Activity中使用非静态内部类。非静态内部类会隐式持有外部类实例的引用。如果使用静态内部类，将外部实例引用作为弱引用持有。

获取全局context的另一种思路：

ActivityThread是主进程的入口，它的currentApplication返回值是application.

import android.app.Application;

import java.lang.reflect.InvocationTargetException;

/**
 * 这种方式获取全局的Application 是一种拓展思路。
 * <p>
 * 对于组件化项目,不可能把项目实际的Application下沉到Base,而且各个module也不需要知道Application真实名字
 * <p>
 * 这种一次反射就能获取全局Application对象的方式相比于在Application#OnCreate保存一份的方式显示更加通用了
 */
public class AppGlobals {
 private static Application sApplication;

 public static Application getApplication() {
 if (sApplication == null) {
 try {
 sApplication = (Application) Class.forName("android.app.ActivityThread")
 .getMethod("currentApplication")
 .invoke(null, (Object[]) null);
 } catch (IllegalAccessException e) {
 e.printStackTrace();
 } catch (InvocationTargetException e) {
 e.printStackTrace();
 } catch (NoSuchMethodException e) {
 e.printStackTrace();
 } catch (ClassNotFoundException e) {
 e.printStackTrace();
 }
 }
 return sApplication;
 }
}

到此这篇关于Context的详细介绍和实例分析的文章就介绍到这了,更多相关Context的详细介绍内容请搜索自学编程网以前的文章或继续浏览下面的相关文章希望大家以后多多支持自学编程网！