Android开发中经常用到ViewPager+Fragment+Adapter的场景，一般每个Fragment控制自己的刷新，但是如果想要刷新整个ViewPager怎么做呢？或者想要将缓存的Fragent给重建怎么做呢？之前做业务的时候遇到一个问题，ViewPage在第二次setAdapter的如果用的是FragmentPager并不会导致页面刷新，但是采用FragementStatePagerAdapter却会刷新？不由得有些好奇，随跟踪了部分源码，简单整理如下：
ViewPager+FragmentPagerAdapter为何不能通过setAdapter做到整体刷新
第二次设置PagerAdapter的时候，首先会将原来的Fragment进行清理，之后在调用populate()重建，只是重建的时候并不一定真的重新创建Fragment，如下：
public void setAdapter(PagerAdapter adapter) {
if (mAdapter != null) {
...
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
<!--全部destroy-->
mAdapter.destroyItem(this, ii.position, ii.object);
}
mAdapter.finishUpdate(this);
<!--清理-->
mItems.clear();
removeNonDecorViews();
<!--重置位置-->
mCurItem = 0;
scrollTo(0, 0);
}
...
if (!wasFirstLayout) {
<!--重新设置Fragment-->
populate();
}
...
}
之前说过，第二次通过setAdapter的方式来设置ViewPager的FragmentAdapter时不会立即刷新的效果，但是如果往后滑动几屏会发现其实是有效果了？为什么呢，因为第二次setAdapter的时候，已经被FragmentManager缓存的Fragent不会被新建，也不会被刷新，因为FragmentAdapter在调用destroy的时候，采用的是detach的方式，并未真正的销毁Fragment，仅仅是打算销毁了View，这就导致FragmentManager中仍旧保留正Fragment的缓存：
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
// 仅仅detach
mCurTransaction.detach((Fragment)object);
}
Transaction.detach函数最终会调用FragmentManager的detachFragment函数，将Fragment从当前Activity detach
public void detachFragment(Fragment fragment, int transition, int transitionStyle) {
if (!fragment.mDetached) {
<!--只是detach -->
fragment.mDetached = true;
if (fragment.mAdded) {
<!--如果是被added 从added列表中移除-->
if (mAdded != null) {
mAdded.remove(fragment);
}
...
fragment.mAdded = false;
<!--将状态设置为Fragment.CREATED-->
moveToState(fragment, Fragment.CREATED, transition, transitionStyle, false);
}
}
}
可以看到，这里仅仅会将Fragment设置为Fragment.CREATED，对于Fragment.CREATED状态的Fragment，FragmentManager是不会调用makeInactive进行清理的，
void moveToState(Fragment f, int newState, int transit, int transitionStyle,
boolean keepActive) {
...
case Fragment.CREATED:
if (newState < Fragment.CREATED) {
...
if (!keepActive) {
if (!f.mRetaining) {
makeInactive(f);
} else {
f.mActivity = null;
f.mParentFragment = null;
f.mFragmentManager = null;
}
...
因为只有makeInactive才会清理Fragment的引用如下：
void makeInactive(Fragment f) {
if (f.mIndex < 0) {
return;
}
<!--置空mActive列表对于Fragment的强引用-->
mActive.set(f.mIndex, null);
if (mAvailIndices == null) {
mAvailIndices = new ArrayList<Integer>();
}
mAvailIndices.add(f.mIndex);
mActivity.invalidateFragment(f.mWho);
f.initState();
}
可见，Fragment的缓存仍旧留在FragmentManager中。新的FragmentPagerAdapter被设置后，会通过instantiateItem函数来获取Fragment，这个时候它首先会从FragmentManager的缓存中去取Fragment，取到的Fragment其实就是之前未销毁的Fragment，这也是为什么不会刷新的原因：
@Override
public Object instantiateItem(ViewGroup container, int position) {
<!--新建一个事务-->
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
final long itemId = getItemId(position);
<!--利用id与container的id创建name-->
String name = makeFragmentName(container.getId(), itemId);
<!--根据name在Activity的FragmentManager中查找缓存Fragment-->
Fragment fragment = mFragmentManager.findFragmentByTag(name);
<!--如果找到的话，直接使用当前Fragment-->
if (fragment != null) {
mCurTransaction.attach(fragment);
} else {
<!--如果找不到则新建，并新建name，添加到container中去-->
fragment = getItem(position);
mCurTransaction.add(container.getId(), fragment,
makeFragmentName(container.getId(), itemId));
}
if (fragment != mCurrentPrimaryItem) {
fragment.setMenuVisibility(false);
fragment.setUserVisibleHint(false);
}
return fragment;
}
从上面代码可以看到，在新建Fragment对象的时候，首先是通过mFragmentManager.findFragmentByTag(name);查找是否已经有Fragment缓存，第二次设置Adapter的时候，由于部分Fragment已经被添加到FragmentManager的缓存中去了，新的Adapter仍然能通过mFragmentManager.findFragmentByTag(name)找到缓存Fragment，阻止了Fragment的新建，因此不会有整体刷新的效果。那如果想要整体刷新怎么办呢？可以使用FragementStatePagerAdapter，两者对于Fragment的缓存管理不同。
ViewPager+FragementStatePagerAdapter可以通过setAdapter做到整体刷新
同样先看一下FragementStatePagerAdapter的destroyItem函数，FragementStatePagerAdapter在destroyItem的时候使用的是remove的方式，这种方式对于没有添加到回退栈的Fragment操作来说，不仅会销毁view，还会销毁Fragment。
@Override
public void destroyItem(ViewGroup container, int position, Object object) {
Fragment fragment = (Fragment)object;
if (mCurTransaction == null) {
mCurTransaction = mFragmentManager.beginTransaction();
}
while (mSavedState.size() <= position) {
mSavedState.add(null);
}
mSavedState.set(position, mFragmentManager.saveFragmentInstanceState(fragment));
<!--FragementStatePagerAdapter先清理自己的缓存-->
mFragments.set(position, null);
<!--直接删除-->
mCurTransaction.remove(fragment);
}
可见FragementStatePagerAdapter会首先通过mFragments.set(position, null)清理自己的缓存，然后，通过Transaction.remove清理在FragmentManager中的缓存，Transaction.remove最终会调用FragmentManager的removeFragment函数：
public void removeFragment(Fragment fragment, int transition, int transitionStyle) {
<!-- 其实两者的主要区别就是看是否在回退栈，如果在，表现就一致，如果不在，表现不一致-->
final boolean inactive = !fragment.isInBackStack();
if (!fragment.mDetached || inactive) {
if (mAdded != null) {
mAdded.remove(fragment);
}
...
fragment.mAdded = false;
fragment.mRemoving = true;
<!--将状态设置为Fragment.CREATED或者Fragment.INITIALIZING-->
moveToState(fragment, inactive ? Fragment.INITIALIZING : Fragment.CREATED,
transition, transitionStyle, false);
}
}
FragementStatePagerAdapter中的Fragment在添加的时候，都没有addToBackStack，所以moveToState会将状态设置为Fragment.INITIALIZING ，
void moveToState(Fragment f, int newState, int transit, int transitionStyle,
boolean keepActive) {
...
case Fragment.CREATED:
if (newState < Fragment.CREATED) {
...
if (!keepActive) {
if (!f.mRetaining) {
makeInactive(f);
} else {
f.mActivity = null;
f.mParentFragment = null;
f.mFragmentManager = null;
}
...
Fragment.INITIALIZING < Fragment.CREATED，这里一般会调用makeInactive函数清理Fragment的引用，这里其实就算销毁了Fragment在FragmentManager中的缓存。
ViewPager通过populate因此再次新建的时候，FragementStatePagerAdapter的instantiateItem 一定会新建Fragment，因为之前的Fragment已经被清理掉了，在自己的Fragment缓存列表中取不到，就新建。看如下代码：
@Override
public Object instantiateItem(ViewGroup container, int position) {
<!--查看FragementStatePagerAdapter中是否有缓存的Fragment，如果有直接返回-->
if (mFragments.size() > position) {
Fragment f = mFragments.get(position);
if (f != null) {
return f;
}
}
...
<!--关键点 如果在FragementStatePagerAdapter找不到，直接新建，不关心FragmentManager中是否有-->
Fragment fragment = getItem(position);
<!--查看是否需恢复，如果需要，则恢复-->
if (mSavedState.size() > position) {
Fragment.SavedState fss = mSavedState.get(position);
if (fss != null) {
fragment.setInitialSavedState(fss);
}
}
...
mFragments.set(position, fragment);
mCurTransaction.add(container.getId(), fragment);
return fragment;
}
从上面代码也可以看出，FragementStatePagerAdapter在新建Fragment的时候，不会去FragmentMangerImpl中去取，而是直接在FragementStatePagerAdapter的缓存中取，如果取不到，则直接新建Fragment，如果通过setAdapter设置了新的FragementStatePagerAdapter，一定会新建所有的Fragment，就能够达到整体刷新的效果。
FragmentPagerAdapter如何通过notifyDataSetChanged刷新ViewPager
FragmentPagerAdapter中的数据发生改变时，往往要重新将数据设置到Fragment，或者干脆新建Fragment，而对于用FragmentPagerAdapter的ViewPager来说，只是利用其notifyDataSetChanged是不够的，跟踪源码会发现，notifyDataSetChanged最终会调用ViewPager中的dataSetChanged：
void dataSetChanged() {
...
for (int i = 0; i < mItems.size(); i++) {
final ItemInfo ii = mItems.get(i);
final int newPos = mAdapter.getItemPosition(ii.object);
if (newPos == PagerAdapter.POSITION_UNCHANGED) {
continue;
}
if (newPos == PagerAdapter.POSITION_NONE) {
mItems.remove(i);
i--;
...
mAdapter.destroyItem(this, ii.position, ii.object);
needPopulate = true;
...
continue;
}
...
if (needPopulate) {
final int childCount = getChildCount();
for (int i = 0; i < childCount; i++) {
final View child = getChildAt(i);
final LayoutParams lp = (LayoutParams) child.getLayoutParams();
if (!lp.isDecor) {
lp.widthFactor = 0.f;
}
}
setCurrentItemInternal(newCurrItem, false, true);
requestLayout();
}
}
默认情况下FragmentPagerAdapter中的getItemPosition返回的是PagerAdapter.POSITION_UNCHANGED，所以这里不会 destroyItem，即时设置了PagerAdapter.POSITION_NONE，调用了其destroyItem，也仅仅是detach，销毁了View，Fragment仍旧不会重建，必须手动更改参数才可以，这个时机在哪里呢？FragmentAdapter的getItem函数会在第一次需要创建Fragment的时候调用，如果需要将参数传递给Fragment，可以通过Fragment.setArguments()来设置，但是仅仅在getItem新建的时候有效，一旦被Fragment被创建，就会被FragmentManager缓存，如果不主动释放，对于当前位置的Fragment来说，getItem函数是不会再次被调用的，原因已经在上文的instantiateItem函数处说明了，它会首先去缓存中取。那这个时候，如何更新呢？Fragment.setArguments是不能再调用的，因为被attach过的Fragment来说不能再次通过setArguments被设置参数，否则抛出异常
public void setArguments(Bundle args) {
if (mIndex >= 0) {
throw new IllegalStateException("Fragment already active");
}
mArguments = args;
}
那如果真要更改就需要在其instantiateItem的时候，通过额外的接口手动设置，同时也必须将getItemPosition返回值设置为POSITION_NONE，这样才会每次都走View的新建流程，才有可能刷新：
public int getItemPosition(Object object) {
return POSITION_NONE;
}
至于参数如何设置呢？这里就需要用户手动提供接口变更参数了，在自定义的FragmentAdapter覆盖instantiateItem，自己手动获取缓存Fragment，在attach之前，将参数给重新设置进去，之后，Fragment在走onCreateView流程的时候，就会获取到新的参数。
@Override
public Object instantiateItem(ViewGroup container, int position) {
String name = makeFragmentName(container.getId(), position);
Fragment fragment =((FragmentActivity) container.getContext()).getSupportFragmentManager().findFragmentByTag(name);
if(fragment instanceof MyFragment){
Bundle bundle=new Bundle();
bundle.putString("msg",""+System.currentTimeMillis());
( (MyFragment) fragment).resetArgument(bundle);
}
return super.instantiateItem(container, position);
}
private static String makeFragmentName(int viewId, long id) {
return "android:switcher:" + viewId + ":" + id;
}
如此，便可以完成FragmentPagerAdapter中Fragment的刷新。并且到这里我们也知道了，对于FragmentPagerAdapter来说，用户完全不需要自己缓存Fragment，只需要缓存View，因为FragmentPagerAdapter不会销毁Fragment，也不会销毁FragmentManager中缓存的Fragment，至于缓存的View要不要刷新，可能就要你具体的业务需求了。
FragmentStatePagerAdapter如何通过notifyDataSetChanged刷新ViewPager页面
对于FragmentStatePagerAdapter相对容易些，如果不需要考虑效率，重建所有的Fragment即可，只需要复写其getItemPosition函数
public int getItemPosition(Object object) {
return POSITION_NONE;
}
因为FragmentStatePagerAdapter中会真正的remove Fragment，达到完全重建的效果。
Fragmentmanager Transaction栈的意义
最后看一下Fragmentmanager中Transaction栈，FragmentManager的Transaction栈到底是做什么的呢？FragmentManager对于Fragment的操作是分批量进行的，在一个Transaction中有多个add、remove、attach操作，Android是有返回键的，为了支持点击返回键恢复上一个场景的操作，Android的Fragment管理引入Transaction栈，更方便回退，其实将一个Transaction的操作全部翻转：添加变删除、attach变detach，反之亦然。对于每个入栈的Transaction，都是需要出栈的，而且每个操作都有前后文，比如进入与退出的动画，当需要翻转这个操作，也就是点击返回键的时候，需要知道如何翻转，也就是需要记录当前场景，对于remove，如果没有入栈操作，说明不用记录上下文，可以直接清理掉。对于ViewPager在使用FragmentPagerAdapter/FragmentStatePagerAdapter的时候都不会addToBackStack，这也是为什么detach跟remove有时候表现一致或者不一致的原因。简单看一下出栈操作，其实就是将原来从操作翻转一遍，当然，并不是完全照搬，还跟当前的Fragment状体有关。
public void popFromBackStack(boolean doStateMove) {
Op op = mTail;
while (op != null) {
switch (op.cmd) {
case OP_ADD: {
Fragment f = op.fragment;
f.mNextAnim = op.popExitAnim;
mManager.removeFragment(f,
FragmentManagerImpl.reverseTransit(mTransition),
mTransitionStyle);
} break;
case OP_REPLACE: {
Fragment f = op.fragment;
if (f != null) {
f.mNextAnim = op.popExitAnim;
mManager.removeFragment(f,
FragmentManagerImpl.reverseTransit(mTransition),
mTransitionStyle);
}
if (op.removed != null) {
for (int i=0; i<op.removed.size(); i++) {
Fragment old = op.removed.get(i);
old.mNextAnim = op.popEnterAnim;
mManager.addFragment(old, false);
}
}
} break;
...
FragmentManager对于Fragment的缓存管理
FragmentManager主要维护三个重要List，一个是mActive Fragment列表，一个是mAdded FragmentList，还有个BackStackRecord回退栈
ArrayList<Fragment> mActive;
ArrayList<Fragment> mAdded;
ArrayList<BackStackRecord> mBackStack;
mAdded列表是被当前添加到Container中去的，而mActive是全部参与的Fragment集合，只要没有被remove，就会一致存在，可以认为mAdded的Fragment都是活着的，而mActive的Fragment却可能被处决，并被置null，只有makeInactive函数会这么做。
void makeInactive(Fragment f) {
if (f.mIndex < 0) {
return;
}
mActive.set(f.mIndex, null);
if (mAvailIndices == null) {
mAvailIndices = new ArrayList<Integer>();
}
mAvailIndices.add(f.mIndex);
mActivity.invalidateFragment(f.mWho);
f.initState();
}
FragmentPagerAdapter获取试图获取的Fragment就是从这两个列表中读取的 。
public Fragment findFragmentByTag(String tag) {
if (mAdded != null && tag != null) {
for (int i=mAdded.size()-1; i>=0; i--) {
Fragment f = mAdded.get(i);
if (f != null && tag.equals(f.mTag)) {
return f;
}
}
}
if (mActive != null && tag != null) {
for (int i=mActive.size()-1; i>=0; i--) {
Fragment f = mActive.get(i);
if (f != null && tag.equals(f.mTag)) {
return f;
}
}
}
return null;
}
总结
本文简单分析了下ViewPager在使用FrgmentPagerAdapter跟FragmentStatePagerAdapter遇到问题，原理、及问题的解决方案。
作者：看书的小蜗牛 原文链接:ViewPager刷新问题原理分析及解决方案（FragmentPagerAdapter+FragementStatePagerAdapter）
仅供参考，欢迎指正
