源码分析commitAllowingStateLoss() 和commit()的区别（挑重点去知道）

ゝ一世哀愁。 2022-06-03 04:38 116阅读 0赞

之前在使用Fragment的时候偶尔会有这么一个报错，Can not perform this action after onSaveInstanceState，意思为无法再onSaveInstanceState之后执行该操作，这个操作就是指commit()，之前也没怎么在意，后来通过查看源码去了解了一下这个问题，以下是对这个问题的解析及对应解决办法的对比。

Fragment是我们经常用到的东西，常用的操作有添加(add)、移除(remove)、替换(replace)等，这些操作组成一个集合transaction，我们在通过调用getSupportFragmentManager().beginTransaction()来获取这个FragmentTransaction类的实例来管理这些操作，将他们存进由activity管理的back stack中，这样我们就可以进行fragment变化的回退操作，也可以这样去获取FragmentTransaction类的实例：

\[java\]  [view plain][]  [copy][view plain]

1.  FragmentManager  mFragmentManager = getSupportFragmentManager();    
2.  FragmentTransaction  mFragmentTransaction = mFragmentManager.beginTransaction();

为什么我们会有这种报错呢，因为我们在使用add(),remove(),replace()等方法将Fragment的变化添加进去，然后在通过commit去提交这些变化（另外，在commit之前可以去调用addToBackState()方法，将这些变化加入到activity管理的back stack中去，这样用户调用返回键就可以回退这些变化了），提交完成之后这些变化就会应用到我们的Fragment中去。但是，这个commit()方法，你只能在avtivity存储他的状态之前调用，也就是onSaveInstanceState()，我们都知道activity有一个保存状态的方法和恢复状态的方法，这个就不详细解释了，在onSaveInstanceState()方法之后去调用commit()，就会抛出我们遇到的这个异常，这是因为在onSaveInstanceState()之后调用commit()方法，这些变化就不会被activity存储，即这些状态会被丢失，但我们可以去用commitAllowingStateLoss()这个方法去代替commit()来解决这个为题，下面我们通过源码去看这两个方法的区别。

首先从我们获取FragmentTransaction类的实例开始，即getSupportFragmentManager()，源码是这样的：

\[java\]  [view plain][]  [copy][view plain]

1.  /\*\* 
2.   \* Return the FragmentManager for interacting with fragments associated 
3.   \* with this activity. 
4.   \*/  
5.  public FragmentManager getSupportFragmentManager() \{  
6.      return mFragments;  
7.  \}

而这个返回的mFragments是一个FragmentManagerImpl类 的实例，他继承自FragmentManager这个类：

\[java\]  [view plain][]  [copy][view plain]

1.  final FragmentManagerImpl mFragments = new FragmentManagerImpl();

我们在FragmentManager这个类中还看到beginTransaction()这个抽象方法，打开他的实现类

\[java\]  [view plain][]  [copy][view plain]

1.  final class FragmentManagerImpl extends FragmentManager \{  
2.    
3.      ... ...  
4.    
5.      @Override  
6.      public FragmentTransaction beginTransaction() \{  
7.          return new BackStackRecord(this);  
8.      \}  
9.    
10.     .... ...  
11.   
12. \}

我们看到这个实现类中的该方法是返回一个BackStateRecord类的实体，我们继续去追踪这个类，就会发现，这个类其实是继承自FragmentTransaction的，并且，我们在这里看到我们熟悉的方法：

\[java\]  [view plain][]  [copy][view plain]

1.  final class BackStackRecord extends FragmentTransaction implements  
2.          FragmentManager.BackStackEntry, Runnable \{  
3.    
4.      public BackStackRecord(FragmentManagerImpl manager) \{  
5.          mManager = manager;  
6.      \}  
7.    
8.      public int commit() \{  
9.          return commitInternal(false);  
10.     \}  
11.   
12.     public int commitAllowingStateLoss() \{  
13.         return commitInternal(true);  
14.     \}  
15.       
16.     int commitInternal(boolean allowStateLoss) \{  
17.         if (mCommitted) throw new IllegalStateException("commit already called");  
18.         if (FragmentManagerImpl.DEBUG) \{  
19.             Log.v(TAG, "Commit: " + this);  
20.             LogWriter logw = new LogWriter(TAG);  
21.             PrintWriter pw = new PrintWriter(logw);  
22.             dump("  ", null, pw, null);  
23.         \}  
24.         mCommitted = true;  
25.         if (mAddToBackStack) \{  
26.             mIndex = mManager.allocBackStackIndex(this);  
27.         \} else \{  
28.             mIndex = -1;  
29.         \}  
30.         mManager.enqueueAction(this, allowStateLoss);  
31.         return mIndex;  
32.     \}  
33.   
34. \}

终于找到了我们有用的东西了，这里省略了其他不必要的代码，只留下我们需要用的核心代码，有兴趣可以自己去查看源码，这里还有省略掉我们常用的add、remove、replace等方法，回归正题，看我们要找的两个方法commit()和commitAllowingStateLoss()，他们都调用了commitInternal(boolean allowStateLoss)这个方法，只是传入的参数不同，我们去看commitInternal方法，该方法首先去判断是否已经commit，这个简单，直接跳过，最后他执行的是FragmentTransactionImpl类的enqueueAction方法，好，不要嫌麻烦，我们继续去追踪这个方法：

\[java\]  [view plain][]  [copy][view plain]

1.  public void enqueueAction(Runnable action, boolean allowStateLoss) \{  
2.      if (!allowStateLoss) \{  
3.          checkStateLoss();  
4.      \}  
5.      synchronized (this) \{  
6.          if (mActivity == null) \{  
7.              throw new IllegalStateException("Activity has been destroyed");  
8.          \}  
9.          if (mPendingActions == null) \{  
10.             mPendingActions = new ArrayList<Runnable>();  
11.         \}  
12.         mPendingActions.add(action);  
13.         if (mPendingActions.size() == 1) \{  
14.             mActivity.mHandler.removeCallbacks(mExecCommit);  
15.             mActivity.mHandler.post(mExecCommit);  
16.         \}  
17.     \}  
18. \}

通过这个方法我们可以看到，他首先去根据commit和commitAllowingStateLoss这两个方法传入的参数不同去判断，然后将任务扔进activity的线程队列中，这里我们重点去看的是checkStateLoss()这个方法：

\[java\]  [view plain][]  [copy][view plain]

1.  private void checkStateLoss() \{  
2.      if (mStateSaved) \{  
3.          throw new IllegalStateException(  
4.                  "Can not perform this action after onSaveInstanceState");  
5.      \}  
6.      if (mNoTransactionsBecause != null) \{  
7.          throw new IllegalStateException(  
8.                  "Can not perform this action inside of " + mNoTransactionsBecause);  
9.      \}  
10. \}

这个方法很简单，就只是一个简单的判断而已，并且只有调用commit方法才会执行这里，commitAllowingStateLoss则直接跳过这步，这里我们调用commit方法时，系统系判断状态（mStateSaved）是否已经保存，如果已经保存，则抛出"Can not perform this action after onSaveInstanceState"异常，这就是我们遇到的问题了，而用commitAllowingStateLoss方法则不会这样，这就与我们之前分析的activity去保存状态对应上了，在activity保存状态完成之后调用commit时，这个mStateSaved就是已经保存状态，所以会抛出异常。

长篇大论终于讲完了，其实回头一看并没有多么复杂，就跟着源码一步一步去找，就会找到我们发生错误的地方，看了源码之后发现，原来并没有多么难，so easy！哈哈

[view plain]: http://blog.csdn.net/freelander_j/article/details/52925745#