本文共 14536 字，大约阅读时间需要 48 分钟。
对于setRetainInstance（）这个方法大多数人还是比较陌生的，之前我也不太理解，只是了解个大概，就是在配置改变时，Fragment不会被重新创建，这里的配置我们就以横竖屏切换为例，这边文章将会带你从源码的角度来分析，基于support-v4-23.1.0，其他版本的原理也是一致的，相信看完之后你会对Fragment销毁时的状态的保存和重建时状态的恢复有一个更加清晰的认识。
先我们来看个简单的例子，Activity代码：public class SecondActivity extends AppCompatActivity { private static final String TAG = "SecondActivity"; private SimpleFragment fragment; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_second); findViewById(R.id.start).setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { Log.d(TAG, "onClick: "+getRequestedOrientation()); if (getRequestedOrientation() != ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE) { setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE); } else { setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT); } } }); FragmentManager manager = getSupportFragmentManager(); Fragment simple_fragment = manager.findFragmentByTag("simple_fragment"); if (simple_fragment == null) { fragment = new SimpleFragment(); FragmentTransaction transaction = manager.beginTransaction(); transaction.add(fragment,"simple_fragment").commit(); } Log.d(TAG, "simple_fragment = "+simple_fragment); } } Fragment代码：
public class SimpleFragment extends Fragment { private static final String TAG = "SimpleFragment"; @Override public void onAttach(Context context) { super.onAttach(context); Log.d(TAG, "onAttach: "); } @Override public void onCreate(@Nullable Bundle savedInstanceState) { super.onCreate(savedInstanceState); Log.d(TAG, "onCreate: "); setRetainInstance(true); } @Nullable @Override public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) { Log.d(TAG, "onCreateView: "); return super.onCreateView(inflater, container, savedInstanceState); } @Override public void onViewCreated(View view, @Nullable Bundle savedInstanceState) { super.onViewCreated(view, savedInstanceState); Log.d(TAG, "onViewCreated: "); } @Override public void onActivityCreated(@Nullable Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); Log.d(TAG, "onActivityCreated: "); } @Override public void onStart() { super.onStart(); Log.d(TAG, "onStart: "); } @Override public void onResume() { super.onResume(); Log.d(TAG, "onResume: "); } @Override public void onPause() { super.onPause(); Log.d(TAG, "onPause: "); } @Override public void onStop() { super.onStop(); Log.d(TAG, "onStop: "); } @Override public void onDestroyView() { super.onDestroyView(); Log.d(TAG, "onDestroyView: "); } @Override public void onDestroy() { super.onDestroy(); Log.d(TAG, "onDestroy: "); } @Override public void onDetach() { super.onDetach(); Log.d(TAG, "onDetach: "); }} Fragment的onCreate（）方法中需要，有一个setRetainInstance(true)方法，这里有个需要注意的点，那就是如果调用setRetainInstance(true)，那么onCreate（）就只会被调用一次。测试的时候分两种情况，一是注释掉这个方法，二是不注释掉，在这两种情况下运行并进行横竖屏切换，在Activity中查看打印SimpleFragment实例的日志，可以发现，在注释掉setRetainInstance(true)运行时，每次打印的SimpleFragment实例都是不一样的，如果不注释掉setRetainInstance(true)运行时，这就是setRetainInstance(true)的作用。下面我们就去源码中一探究竟。
先来看下setRetainInstance(true)这个方法中具体做了些什么：public void setRetainInstance(boolean retain) { if (retain && mParentFragment != null) { throw new IllegalStateException( "Can't retain fragements that are nested in other fragments"); } mRetainInstance = retain; } 很简单，就是对mRetainInstance 属性进行了赋值，接下来我们就该想到，在Activity销毁时，状态的保存会调用onSaveInstanceState（）方法，Fragment的使用，继承的是FragmentActivity，那么我们就去FragmentActivity看看onSaveInstanceState（）这个方法做了些什么东西：
@Override protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState); Parcelable p = mFragments.saveAllState(); if (p != null) { outState.putParcelable(FRAGMENTS_TAG, p); } } 可以看到这里就是简单的调用了mFragments.saveAllState()并返回一个Parcelable对象，然后保存到了Bundle中，Activity销毁后，这个Bundle实际是ActivityManagerService给我们保存了，当下次在重新创建时再重新传回给我们，这里我们我们就不去细究了，接下来我们就去看下saveAllState（）这个方法里做了些什么，这里先提一点，对于mFragments变量调用的方法最终都会调用FragmentManager中，记住了，后面就不在重复了，所以这里最终调用到的是FragmentManager中的saveAllState（）：
Parcelable saveAllState() { // Make sure all pending operations have now been executed to get // our state update-to-date. execPendingActions(); if (HONEYCOMB) { // As of Honeycomb, we save state after pausing. Prior to that // it is before pausing. With fragments this is an issue, since // there are many things you may do after pausing but before // stopping that change the fragment state. For those older // devices, we will not at this point say that we have saved // the state, so we will allow them to continue doing fragment // transactions. This retains the same semantics as Honeycomb, // though you do have the risk of losing the very most recent state // if the process is killed... we'll live with that. mStateSaved = true; } if (mActive == null || mActive.size() <= 0) { return null; } // First collect all active fragments. int N = mActive.size(); FragmentState[] active = new FragmentState[N]; boolean haveFragments = false; for (int i=0; i Fragment.INITIALIZING && fs.mSavedFragmentState == null) { fs.mSavedFragmentState = saveFragmentBasicState(f); if (f.mTarget != null) { if (f.mTarget.mIndex < 0) { throwException(new IllegalStateException( "Failure saving state: " + f + " has target not in fragment manager: " + f.mTarget)); } if (fs.mSavedFragmentState == null) { fs.mSavedFragmentState = new Bundle(); } putFragment(fs.mSavedFragmentState, FragmentManagerImpl.TARGET_STATE_TAG, f.mTarget); if (f.mTargetRequestCode != 0) { fs.mSavedFragmentState.putInt( FragmentManagerImpl.TARGET_REQUEST_CODE_STATE_TAG, f.mTargetRequestCode); } } } else { fs.mSavedFragmentState = f.mSavedFragmentState; } if (DEBUG) Log.v(TAG, "Saved state of " + f + ": " + fs.mSavedFragmentState); } } if (!haveFragments) { if (DEBUG) Log.v(TAG, "saveAllState: no fragments!"); return null; } int[] added = null; BackStackState[] backStack = null; // Build list of currently added fragments. if (mAdded != null) { N = mAdded.size(); if (N > 0) { added = new int[N]; for (int i=0; i 0) { backStack = new BackStackState[N]; for (int i=0; i 这个方法中做的主要就是保存Fragment的状态，最后全部封装到FragmentManagerState 中去并返回，这样做的目的就是当下次重新创建Activity的时候可以恢复之前创建的Fragment。
到目前为止，我们还没说到setRetainInstance（）设置的mRetainInstance的作用，接下来看看，我们先从源头去跟，这个源头就是ActivityThread的performDestroyActivity（）方法，在这个方法中有这样一句代码：r.lastNonConfigurationInstances = r.activity.retainNonConfigurationInstances();
这个r最终是保存在ActivityManagerService中，下次重新创建时会返回给我们，接下来要做的就是去Activity中看看retainNonConfigurationInstances()这个方法是如何实现的：
NonConfigurationInstances retainNonConfigurationInstances() { Object activity = onRetainNonConfigurationInstance(); HashMap children = onRetainNonConfigurationChildInstances(); List fragments = mFragments.retainNonConfig(); ArrayMap loaders = mFragments.retainLoaderNonConfig(); if (activity == null && children == null && fragments == null && loaders == null && mVoiceInteractor == null) { return null; } NonConfigurationInstances nci = new NonConfigurationInstances(); nci.activity = activity; nci.children = children; nci.fragments = fragments; nci.loaders = loaders; if (mVoiceInteractor != null) { mVoiceInteractor.retainInstance(); nci.voiceInteractor = mVoiceInteractor; } return nci; } 这里有一个onRetainNonConfigurationInstance（）方法，这个方法在Activity是空实现，那就去它的子类，也就是FragmentActivity去看看做了些什么逻辑处理：
@Override public final Object onRetainNonConfigurationInstance() { if (mStopped) { doReallyStop(true); } Object custom = onRetainCustomNonConfigurationInstance(); List fragments = mFragments.retainNonConfig(); SimpleArrayMap loaders = mFragments.retainLoaderNonConfig(); if (fragments == null && loaders == null && custom == null) { return null; } NonConfigurationInstances nci = new NonConfigurationInstances(); nci.custom = custom; nci.fragments = fragments; nci.loaders = loaders; return nci; } 这里有个mFragments.retainNonConfig()，这里最终调用到是FragmentManager的retainNonConfig（）方法，跟进去看看做了什么：