设备横竖屏切换的时候，Fragment的自定义变量，数据会丢失。具体代码验证效果，这篇文章说的很清楚：屏幕旋转Fragment数据丢失。
用构造方法传参，为什么会数据丢失？设备横竖屏切换的话，当前展示给用户的Activity默认情况下会重新创建并展现给用户，依附于Activity的Fragment也会重新创建。具体过程一步一步分析：
setArguments()是如何保存数据的？ public void setArguments(Bundle args) {
if (mIndex >= 0) {
throw new IllegalStateException("Fragment already active");
}
mArguments = args;
}
首先将当前的bundle对象赋值给mArguments，mArguments是Fragment的成员变量：
Fragment.java
public class Fragment implements ComponentCallbacks2, OnCreateContextMenuListener {
// Construction arguments;
Bundle mArguments;
}
Activity保存状态的时候会调用onSaveInstanceState方法:
Activity.java
//从这里看出mFragments是FragmentController实例
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
protected void onSaveInstanceState(Bundle outState) {
outState.putBundle(WINDOW_HIERARCHY_TAG, mWindow.saveHierarchyState());
outState.putInt(LAST_AUTOFILL_ID, mLastAutofillId);
// 调用saveAllState方法保存Fragment状态
Parcelable p = mFragments.saveAllState();
if (p != null) {
// 将结果保存到Bundle中
outState.putParcelable(FRAGMENTS_TAG, p);
}
if (mAutoFillResetNeeded) {
outState.putBoolean(AUTOFILL_RESET_NEEDED, true);
getAutofillManager().onSaveInstanceState(outState);
}
getApplication().dispatchActivitySaveInstanceState(this, outState);
}
FragmentController.saveAllState()方法最终调用到FragmentManager的saveAllState方法中：
FragmentController.java
public Parcelable saveAllState() {
return mHost.mFragmentManager.saveAllState();
}
在FragmentManager.java中，把Fragment对象作为参数传递给了FragmentState：
FragmentManager.java
Parcelable saveAllState() {
// 找到所有的存活的Fragment
int N = mActive.size();
// 代表Fragment状态的数组
FragmentState[] active = new FragmentState[N];
boolean haveFragments = false;
for (int i=0; i Fragment.INITIALIZING && fs.mSavedFragmentState == null) {
// 保存Fragment的状态
fs.mSavedFragmentState = saveFragmentBasicState(f);
FragmentManagerState fms = new FragmentManagerState();
// active是上面代表Fragment状态的数组，至此，fragment的状态就被保存到了FragmentManagerState中
fms.mActive = active;
fms.mAdded = added;
fms.mBackStack = backStack;
fms.mNextFragmentIndex = mNextFragmentIndex;
if (mPrimaryNav != null) {
fms.mPrimaryNavActiveIndex = mPrimaryNav.mIndex;
}
saveNonConfig();
return fms;
}
FragmentState是Fragment的同级类，内部有一个final变量mArguments：
FragmentState.java
final class FragmentState implements Parcelable {
...
final Bundle mArguments;
final boolean mHidden;
Bundle mSavedFragmentState;
Fragment mInstance;
public FragmentState(Fragment frag) {
...
mArguments = frag.mArguments;
mHidden = frag.mHidden;
}
}
public class Fragment implements ComponentCallbacks2, OnCreateContextMenuListener {
// Construction arguments;
Bundle mArguments;
}
总结一下：Fragment的状态信息保存到了FragmentState中，然后FragmentState又保存在FragmentManagerState中，FragmentManagerState对象被return回去，保存到了Bundle对象outState里面：
//Activity.onSaveInstance()方法
Parcelable p = mFragments.saveAllState();
if (p != null) {
outState.putParcelable(FRAGMENTS_TAG, p);
}
数据保存后，又是如何取出并放入新的Fragment的？
默认情况下，屏幕旋转，Android系统会销毁并重建Activity，上面分析了销毁时调用的onSaveInstanceState方法，把数据存在Bundle中，新建Activity时，Bundle会在onCreate方法中，作为入参被读取，现在分析重建时onCreate方法。
Activity.java
//从这里看出mFragments是FragmentController实例
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());
protected void onCreate(@Nullable Bundle savedInstanceState) {
if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);
if (mLastNonConfigurationInstances != null) {
mFragments.restoreLoaderNonConfig(mLastNonConfigurationInstances.loaders);
}
if (mActivityInfo.parentActivityName != null) {
if (mActionBar == null) {
mEnableDefaultActionBarUp = true;
} else {
mActionBar.setDefaultDisplayHomeAsUpEnabled(true);
}
}
if (savedInstanceState != null) {
Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);
//Fragment数据恢复从这里开始
mFragments.restoreAllState(p, mLastNonConfigurationInstances != null
? mLastNonConfigurationInstances.fragments : null);
}
mFragments.dispatchCreate();
getApplication().dispatchActivityCreated(this, savedInstanceState);
if (mVoiceInteractor != null) {
mVoiceInteractor.attachActivity(this);
}
mCalled = true;
}
FragmentController.java
public void restoreAllState(Parcelable state, FragmentManagerNonConfig nonConfig) {
mHost.mFragmentManager.restoreAllState(state, nonConfig);
}
在FragmentManager中，直接把Parcelable对象state ，强制转化为FragmentManagerState，然后取出其中的FragmentState:
FragmentManager.java
void restoreAllState(Parcelable state, FragmentManagerNonConfig nonConfig) {
// If there is no saved state at all, then there can not be
// any nonConfig fragments either, so that is that.
if (state == null) return;
FragmentManagerState fms = (FragmentManagerState)state;
if (fms.mActive == null) return;
List childNonConfigs = null;
// First re-attach any non-config instances we are retaining back
// to their saved state, so we don't try to instantiate them again.
...
// Build the full list of active fragments, instantiating them from
// their saved state.
mActive = new ArrayList<>(fms.mActive.length);
if (mAvailIndices != null) {
mAvailIndices.clear();
}
for (int i=0; i();
}
if (DEBUG) Log.v(TAG, "restoreAllState: avail #" + i);
mAvailIndices.add(i);
}
}
// Update the target of all retained fragments.
...
// Build the list of currently added fragments.
...
// Build the back stack.
...
}
关键代码是：
Fragment f = fs.instantiate(mHost, mParent, childNonConfig);
在FragmentState中，再把已经在保存数据过程中赋值的mArguments作为参数，传递给Fragment.instantiate()方法：
FragmentState.java
final Bundle mArguments;
//mInstance是Fragment类型的成员变量
Fragment mInstance;
public Fragment instantiate(FragmentHostCallback host, Fragment parent,
FragmentManagerNonConfig childNonConfig) {
if (mInstance == null) {
final Context context = host.getContext();
if (mArguments != null) { mArguments是Bundle类型的成员变量
mArguments.setClassLoader(context.getClassLoader());
}
//这里是重新初始化
mInstance = Fragment.instantiate(context, mClassName, mArguments);
if (mSavedFragmentState != null) {
mSavedFragmentState.setClassLoader(context.getClassLoader());
mInstance.mSavedFragmentState = mSavedFragmentState;
}
mInstance.setIndex(mIndex, parent);
mInstance.mFromLayout = mFromLayout;
mInstance.mRestored = true;
mInstance.mFragmentId = mFragmentId;
mInstance.mContainerId = mContainerId;
mInstance.mTag = mTag;
mInstance.mRetainInstance = mRetainInstance;
mInstance.mDetached = mDetached;
mInstance.mHidden = mHidden;
mInstance.mFragmentManager = host.mFragmentManager;
if (FragmentManagerImpl.DEBUG) Log.v(FragmentManagerImpl.TAG,
"Instantiated fragment " + mInstance);
}
mInstance.mChildNonConfig = childNonConfig;
return mInstance;
}
Fragment中，mArguments最终赋值给新建的Fragment对象f:
Fragment.java
public static Fragment instantiate(Context context, String fname, @Nullable Bundle args) {
try {
Class clazz = sClassMap.get(fname);
if (clazz == null) {
// Class not found in the cache, see if it's real, and try to add it
clazz = context.getClassLoader().loadClass(fname);
if (!Fragment.class.isAssignableFrom(clazz)) {
throw new InstantiationException("Trying to instantiate a class " + fname
+ " that is not a Fragment", new ClassCastException());
}
sClassMap.put(fname, clazz);
}
Fragment f = (Fragment)clazz.newInstance();
if (args != null) {
args.setClassLoader(f.getClass().getClassLoader());
f.mArguments = args;
}
return f;
} catch (ClassNotFoundException e) {
throw new InstantiationException("Unable to instantiate fragment " + fname
+ ": make sure class name exists, is public, and has an"
+ " empty constructor that is public", e);
} catch (java.lang.InstantiationException e) {
throw new InstantiationException("Unable to instantiate fragment " + fname
+ ": make sure class name exists, is public, and has an"
+ " empty constructor that is public", e);
} catch (IllegalAccessException e) {
throw new InstantiationException("Unable to instantiate fragment " + fname
+ ": make sure class name exists, is public, and has an"
+ " empty constructor that is public", e);
}
}
根据：Fragment f = (Fragment)clazz.newInstance();可知，通过反射创建一个新的Fragment，调用的是无参构造函数，也就是默认构造函数，所以我们自定义的变量数据会丢失。
setArguments()为什么数据不会丢失？ ，仔细看下面有一行关键代码：
f.mArguments = args;
setArguments()的参数，重新赋值给了mArguments。
数据获取过程参考
数据保存过程参考
