關(guān)于Context我們首先應(yīng)該知道：
（1）它描述的是一個應(yīng)用程序環(huán)境的信息，即上下文。
（2）該類是一個抽象(abstract class)類，Android提供了該抽象類的具體實現(xiàn)類(后面我們會講到是ContextIml類)。
（3）通過它我們可以獲取應(yīng)用程序的資源和類，也包括一些應(yīng)用級別操作，例如：啟動一個Activity，發(fā)送廣播，接受Intent信息等。。
于是，我們可以利用該Context對象去構(gòu)建應(yīng)用級別操作(application-level operations) 。
一、Context相關(guān)類的繼承關(guān)系
相關(guān)類介紹：
Context類路徑： /frameworks/base/core/java/android/content/Context.java
說明：抽象類，提供了一組通用的API。源代碼(部分)如下：
public abstract class Context { ... public abstract Object getSystemService(String name); //獲得系統(tǒng)級服務(wù) public abstract void startActivity(Intent intent); //通過一個Intent啟動Activity public abstract ComponentName startService(Intent service); //啟動Service //根據(jù)文件名得到SharedPreferences對象 public abstract SharedPreferences getSharedPreferences(String name,int mode); ... }
ContextIml.java類 路徑 ：/frameworks/base/core/java/android/app/ContextImpl.java
說明：該Context類的實現(xiàn)類為ContextIml，該類實現(xiàn)了Context類的功能。請注意，該函數(shù)的大部分功能都是直接調(diào)用其屬性mPackageInfo去完成，這點(diǎn)我們后面會講到。 源代碼(部分)如下：
/** * Common implementation of Context API, which provides the base * context object for Activity and other application components. */ class ContextImpl extends Context{ //所有Application程序公用一個mPackageInfo對象 /*package*/ ActivityThread.PackageInfo mPackageInfo; @Override public Object getSystemService(String name){ ... else if (ACTIVITY_SERVICE.equals(name)) { return getActivityManager(); } else if (INPUT_METHOD_SERVICE.equals(name)) { return InputMethodManager.getInstance(this); } } @Override public void startActivity(Intent intent) { ... //開始啟動一個Activity mMainThread.getInstrumentation().execStartActivity( getOuterContext(), mMainThread.getApplicationThread(), null, null, intent, -1); } } ContextWrapper類 路徑 ：/frameworks/base/core/java/android/content/ContextWrapper.java
說明： 正如其名稱一樣，該類只是對Context類的一種包裝，該類的構(gòu)造函數(shù)包含了一個真正的Context引用，即ContextIml對象。源代碼(部分)如下：
public class ContextWrapper extends Context { Context mBase; //該屬性指向一個ContextIml實例，一般在創(chuàng)建Application、Service、Activity時賦值 //創(chuàng)建Application、Service、Activity，會調(diào)用該方法給mBase屬性賦值 protected void attachBaseContext(Context base) { if (mBase != null) { throw new IllegalStateException("Base context already set"); } mBase = base; } @Override public void startActivity(Intent intent) { mBase.startActivity(intent); //調(diào)用mBase實例方法 } } ContextThemeWrapper類 路徑：/frameworks/base/core/java/android/view/ContextThemeWrapper.java
說明：該類內(nèi)部包含了主題(Theme)相關(guān)的接口，即android:theme屬性指定的。只有Activity需要主題，Service不需要主題，所以Service直接繼承于ContextWrapper類。
源代碼(部分)如下：
public class ContextThemeWrapper extends ContextWrapper { //該屬性指向一個ContextIml實例，一般在創(chuàng)建Application、Service、Activity時賦值 private Context mBase; //mBase賦值方式同樣有一下兩種 public ContextThemeWrapper(Context base, int themeres) { super(base); mBase = base; mThemeResource = themeres; } @Override protected void attachBaseContext(Context newBase) { super.attachBaseContext(newBase); mBase = newBase; } } Activity類 、Service類 、Application類本質(zhì)上都是Context子類， 更多信息大家可以自行參考源代碼進(jìn)行理解。
二、 什么時候創(chuàng)建Context實例
熟悉了Context的繼承關(guān)系后，我們接下來分析應(yīng)用程序在什么情況需要創(chuàng)建Context對象的？應(yīng)用程序創(chuàng)建Context實例的情況有如下幾種情況：
（1）創(chuàng)建Application 對象時， 而且整個App共一個Application對象
（2）創(chuàng)建Service對象時
（3）創(chuàng)建Activity對象時
因此應(yīng)用程序App共有的Context數(shù)目公式為：
總Context實例個數(shù) = Service個數(shù) + Activity個數(shù) + 1（Application對應(yīng)的Context實例）
具體創(chuàng)建Context的時機(jī)：
1、創(chuàng)建Application對象的時機(jī)
每個應(yīng)用程序在第一次啟動時，都會首先創(chuàng)建Application對象。如果對應(yīng)用程序啟動一個Activity(startActivity)流程比較清楚的話，創(chuàng)建Application的時機(jī)在創(chuàng)建handleBindApplication()方法中，該函數(shù)位于 ActivityThread.java類中 ，如下：
//創(chuàng)建Application時同時創(chuàng)建的ContextIml實例 private final void handleBindApplication(AppBindData data){ ... ///創(chuàng)建Application對象 Application app = data.info.makeApplication(data.restrictedBackupMode, null); ... } public Application makeApplication(boolean forceDefaultAppClass, Instrumentation instrumentation) { ... try { java.lang.ClassLoader cl = getClassLoader(); ContextImpl appContext = new ContextImpl(); //創(chuàng)建一個ContextImpl對象實例 appContext.init(this, null, mActivityThread); //初始化該ContextIml實例的相關(guān)屬性 ///新建一個Application對象 app = mActivityThread.mInstrumentation.newApplication( cl, appClass, appContext); appContext.setOuterContext(app); //將該Application實例傳遞給該ContextImpl實例 } ... } 2、創(chuàng)建Activity對象的時機(jī)
通過startActivity()或startActivityForResult()請求啟動一個Activity時，如果系統(tǒng)檢測需要新建一個Activity對象時，就會回調(diào)handleLaunchActivity()方法，該方法繼而調(diào)用performLaunchActivity()方法，去創(chuàng)建一個Activity實例，并且回調(diào)onCreate()，onStart()方法等， 函數(shù)都位于 ActivityThread.java類 ，如下：
//創(chuàng)建一個Activity實例時同時創(chuàng)建ContextIml實例 private final void handleLaunchActivity(ActivityRecord r, Intent customIntent) { ... Activity a = performLaunchActivity(r, customIntent); //啟動一個Activity } private final Activity performLaunchActivity(ActivityRecord r, Intent customIntent) { ... Activity activity = null; try { //創(chuàng)建一個Activity對象實例 java.lang.ClassLoader cl = r.packageInfo.getClassLoader(); activity = mInstrumentation.newActivity(cl, component.getClassName(), r.intent); } if (activity != null) { ContextImpl appContext = new ContextImpl(); //創(chuàng)建一個Activity實例 appContext.init(r.packageInfo, r.token, this); //初始化該ContextIml實例的相關(guān)屬性 appContext.setOuterContext(activity); //將該Activity信息傳遞給該ContextImpl實例 ... } ... }
3、創(chuàng)建Service對象的時機(jī)
通過startService或者bindService時，如果系統(tǒng)檢測到需要新創(chuàng)建一個Service實例，就會回調(diào)handleCreateService()方法，完成相關(guān)數(shù)據(jù)操作。handleCreateService()函數(shù)位于 ActivityThread.java類，如下：
//創(chuàng)建一個Service實例時同時創(chuàng)建ContextIml實例 private final void handleCreateService(CreateServiceData data){ ... //創(chuàng)建一個Service實例 Service service = null; try { java.lang.ClassLoader cl = packageInfo.getClassLoader(); service = (Service) cl.loadClass(data.info.name).newInstance(); } catch (Exception e) { } ... ContextImpl context = new ContextImpl(); //創(chuàng)建一個ContextImpl對象實例 context.init(packageInfo, null, this); //初始化該ContextIml實例的相關(guān)屬性 //獲得我們之前創(chuàng)建的Application對象信息 Application app = packageInfo.makeApplication(false, mInstrumentation); //將該Service信息傳遞給該ContextImpl實例 context.setOuterContext(service); ... }
另外，需要強(qiáng)調(diào)一點(diǎn)的是，通過對ContextImp的分析可知，其方法的大多數(shù)操作都是直接調(diào)用其屬性mPackageInfo(該屬性類
型為PackageInfo)的相關(guān)方法而來。這說明ContextImp是一種輕量級類，而PackageInfo才是真正重量級的類。而一個App里的
所有ContextIml實例，都對應(yīng)同一個packageInfo對象。
三、利用Context獲取SharedPreferences類
給大家分析利用Context獲取SharedPreferences類的使用方法，SharedPreferences類想必大家都使用過，其一般獲取方
法就是通過調(diào)用getSharedPreferences()方法去根據(jù)相關(guān)信息獲取SharedPreferences對象。具體流程如下：
1 、調(diào)用 getSharedPreferences()獲取對應(yīng)的的文件，該函數(shù)實現(xiàn)功能如下：
//Context類靜態(tài)數(shù)據(jù)集合，以鍵值對保存了所有讀取該xml文件后所形成的數(shù)據(jù)集合 private static final HashMap<File, SharedPreferencesImpl> sSharedPrefs = new HashMap<File, SharedPreferencesImpl>(); @Override public SharedPreferences getSharedPreferences(String name, int mode){ //其所對應(yīng)的SharedPreferencesImpl對象 ，該對象已一個HashMap集合保存了我們對該文件序列化結(jié)果 SharedPreferencesImpl sp; File f = getSharedPrefsFile(name); //該包下是否存在對應(yīng)的文件，不存在就新建一個 synchronized (sSharedPrefs) { //是否已經(jīng)讀取過該文件，是就直接返回該SharedPreferences對象 sp = sSharedPrefs.get(f); if (sp != null && !sp.hasFileChanged()) { //Log.i(TAG, "Returning existing prefs " + name + ": " + sp); return sp; } } //以下為序列化該xml文件，同時將數(shù)據(jù)寫到map集合中 Map map = null; if (f.exists() && f.canRead()) { try { str = new FileInputStream(f); map = XmlUtils.readMapXml(str); str.close(); } ... } synchronized (sSharedPrefs) { if (sp != null) { //Log.i(TAG, "Updating existing prefs " + name + " " + sp + ": " + map); sp.replace(map); //更新數(shù)據(jù)集合 } else { sp = sSharedPrefs.get(f); if (sp == null) { //新建一個SharedPreferencesImpl對象，并且設(shè)置其相關(guān)屬性 sp = new SharedPreferencesImpl(f, mode, map); sSharedPrefs.put(f, sp); } } return sp; } }
2、 SharedPreferences 不過是個接口，它定義了一些操作xml文件的方法，其真正實現(xiàn)類為SharedPreferencesImpl ，該類是ContextIml的內(nèi)部類，該類如下：
//soga，這種形式我們在分析Context ContextIml時接觸過 //SharedPreferences只是一種接口，其真正實現(xiàn)類是SharedPreferencesImpl類 private static final class SharedPreferencesImpl implements SharedPreferences{ private Map mMap; //保存了該文件序列化結(jié)果后的操作， 鍵值對形式 //通過key值獲取對應(yīng)的value值 public String getString(String key, String defValue) { synchronized (this) { String v = (String)mMap.get(key); return v != null ? v : defValue; } } ... //獲得該SharedPreferencesImpl對象對應(yīng)的Edito類，對數(shù)據(jù)進(jìn)行操作 public final class EditorImpl implements Editor { private final Map<String, Object> mModified = Maps.newHashMap(); //保存了對鍵值變化的集合 } }
基本上獲取SharedPreferences 對象就是這么來的。
四、在任意位置獲取應(yīng)用程序Context
1、在任意位置獲取應(yīng)用程序Context
Android程序中訪問資源時需要提供Context，一般來說只有在各種component中（Activity, Provider等等)才能方便的使用api來獲取Context;喜歡編程的人都知道，編寫工具類可以有效的實現(xiàn)代碼復(fù)用，而在Android下某些工具類的編寫很讓人困惑，例如：我們要在工具類中獲取SharedPreferences，那就需要Context的支持。
為了解決這寫由Context帶來的麻煩，我們可以自定義一個Application類來實現(xiàn)這種功能。
import android.app.Application;public class ContextUtil extends Application { private static ContextUtil instance; public static ContextUtil getInstance() { return instance; } @Override public void onCreate() { // TODO Auto-generated method stub super.onCreate(); instance = this; }}然后在manifest中<application>中加入Android：name="mypackage.ContextUtil",這樣我們就可以在任何一個類下面獲取Context，例如：Context c=ContextUtil.getInstance();
2、context注意事項：
在android中context可以作很多操作，但是最主要的功能是加載和訪問資源。在android中有兩種context，一種是 application context，一種是activity context，通常我們在各種類和方法間傳遞的是activity context。
比如一個activity的onCreate：
protected void onCreate(Bundle state) { super.onCreate(state); TextView label = new TextView(this); //傳遞context給view control label.setText("Leaks are bad"); setContentView(label);}把a(bǔ)ctivity context傳遞給view，意味著view擁有一個指向activity的引用，進(jìn)而引用activity占有的資源：view hierachy, resource等。
這樣如果context發(fā)生內(nèi)存泄露的話，就會泄露很多內(nèi)存。
這里泄露的意思是gc沒有辦法回收activity的內(nèi)存。
Leaking an entire activity是很容易的一件事。
當(dāng)屏幕旋轉(zhuǎn)的時候，系統(tǒng)會銷毀當(dāng)前的activity，保存狀態(tài)信息，再創(chuàng)建一個新的。
比如我們寫了一個應(yīng)用程序，它需要加載一個很大的圖片，我們不希望每次旋轉(zhuǎn)屏 幕的時候都銷毀這個圖片，重新加載。實現(xiàn)這個要求的簡單想法就是定義一個靜態(tài)的Drawable，這樣Activity 類創(chuàng)建銷毀它始終保存在內(nèi)存中。
實現(xiàn)類似：
public class myactivity extends Activity { private static Drawable sBackground; protected void onCreate(Bundle state) { super.onCreate(state); TextView label = new TextView(this); label.setText("Leaks are bad"); if (sBackground == null) { sBackground = getDrawable(R.drawable.large_bitmap); } label.setBackgroundDrawable(sBackground);//drawable attached to a view setContentView(label); }}這段程序看起來很簡單，但是卻問題很大。當(dāng)屏幕旋轉(zhuǎn)的時候會有l(wèi)eak（即gc沒法銷毀activity）。
我們剛才說過，屏幕旋轉(zhuǎn)的時候系統(tǒng)會銷毀當(dāng)前的activity。但是當(dāng)drawable和view關(guān)聯(lián)后，drawable保存了view的 reference，即sBackground保存了label的引用，而label保存了activity的引用。既然drawable不能銷毀，它所 引用和間接引用的都不能銷毀，這樣系統(tǒng)就沒有辦法銷毀當(dāng)前的activity，于是造成了內(nèi)存泄露。gc對這種類型的內(nèi)存泄露是無能為力的。
避免這種內(nèi)存泄露的方法是避免activity中的任何對象的生命周期長過activity，避免由于對象對 activity的引用導(dǎo)致activity不能正常被銷毀。我們可以使用application context。application context伴隨application的一生，與activity的生命周期無關(guān)。application context可以通過Context.getApplicationContext或者Activity.getApplication方法獲取。
避免context相關(guān)的內(nèi)存泄露，記住以下幾點(diǎn)：
（1）不要讓生命周期長的對象引用activity context，即保證引用activity的對象要與activity本身生命周期是一樣的
（2）對于生命周期長的對象，可以使用application context
（3）避免非靜態(tài)的內(nèi)部類，盡量使用靜態(tài)類，避免生命周期問題，注意內(nèi)部類對外部對象引用導(dǎo)致的生命周期變化
3、獲取別的包的Context
Android中有Context的概念，想必大家都知道。Context可以做很多事情，打開activity、發(fā)送廣播、打開本包下文件夾和數(shù)據(jù)庫、獲取classLoader、獲取資源等等。如果我們得到了一個包的Context對象，那我們基本上可以做這個包自己能做的大部分事情。
Context有個createPackageContext方法，可以創(chuàng)建另外一個包的上下文，這個實例不同于它本身的Context實例，但是功能是一樣的。
這個方法有兩個參數(shù)：
（1）packageName包名，要得到Context的包名
（2）flags標(biāo)志位，有CONTEXT_INCLUDE_CODE和CONTEXT_IGNORE_SECURITY兩個選項。 CONTEXT_INCLUDE_CODE的意思是包括代碼，也就是說可以執(zhí)行這個包里面的代碼。CONTEXT_IGNORE_SECURITY的意思是忽略安全警告，如果不加這個標(biāo)志的話，有些功能是用不了的，會出現(xiàn)安全警告。
下面給個小例子，執(zhí)行另外一個包里面的某個類的方法。另外一個包的包名是chroya.demo,類名Main，方法名print，代碼如下：
package chroya.demo; import android.app.Activity; import android.os.Bundle; import android.util.Log; class Main extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); } public void print(String msg) { Log.d("Main", "msg:"+ msg); } } package chroya.demo; import android.app.Activity; import android.os.Bundle; import android.util.Log; class Main extends Activity { @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); } public void print(String msg) { Log.d("Main", "msg:"+ msg); } } 本包的調(diào)用Main的print方法的代碼塊如下：
Context c = createPackageContext("chroya.demo", Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY); //載入這個類 Class clazz = c.getClassLoader().loadClass("chroya.demo.Main"); //新建一個實例 Object owner = clazz.newInstance(); //獲取print方法，傳入?yún)?shù)并執(zhí)行 Object obj = clazz.getMethod("print", String.class).invoke(owner,"Hello"); Context c = createPackageContext("chroya.demo", Context.CONTEXT_INCLUDE_CODE | Context.CONTEXT_IGNORE_SECURITY); //載入這個類 Class clazz = c.getClassLoader().loadClass("chroya.demo.Main"); //新建一個實例 Object owner = clazz.newInstance(); //獲取print方法，傳入?yún)?shù)并執(zhí)行 Object obj = clazz.getMethod("print", String.class).invoke(owner, "Hello"); ok，這樣，我們就調(diào)用了chroya.demo包的Main類的print方法，執(zhí)行結(jié)果，打印出了Hello。
新聞熱點(diǎn)
疑難解答
圖片精選
