YCBlogs 之 Fragment 基础使用完全指南:创建、传值、回退栈与实战避坑
YCBlogs 之 Fragment 基础使用完全指南:创建、传值、回退栈与实战避坑
导读
本文基于 YCBlogs 仓库中的 11.Fragment基础使用.md 整理扩展,系统梳理 Fragment 的本质定位、静态/动态创建方式、Activity 与 Fragment 之间的数据传递、回退栈原理,以及开发中最容易踩中的四大经典坑(getActivity() 空指针、Fragment 重叠、点击穿透、commitAllowingStateLoss)。读完本文,你将掌握一套可复用的 Fragment 使用规范与状态恢复方案,并能结合仓库中 01.Android之基础组件问题.md 的面试考点与 PagerAdapter详细介绍.md 的源码细节,把 Fragment 用得既正确又高效。
01. 什么是 Fragment:组件而非控件
1.1 Fragment 的定位
Fragment 可以简单理解为"显示在 Activity 中的 Activity":它拥有独立的生命周期,可以接受并处理用户事件,并且可以在同一个 Activity 中动态添加、替换、移除多个 Fragment,因此非常适合信息的分屏展示。
- 作为 view 界面的一部分,Fragment 必须依附于 FragmentActivity(或 AppCompatActivity)使用,并拥有独立于宿主的生命周期,同时处理用户的交互动作;
- 同一个宿主 Activity 可以承载一个或多个 Fragment,Fragment 也可以拥有多个子 Fragment(通过 getChildFragmentManager() 管理);
- 支持动态添加、删除 Fragment,让 UI 的重复利用率和易修改性得以提升,也可用于解决部分屏幕适配问题。
1.2 为什么说 Fragment 是组件而不是控件
严格意义上,Fragment 并不是一个显示控件,而只是一个显示组件。原因在于:Activity、Dialog、PopupWindow、Toast 等内部都维护着一个 Window 对象,该 Window 既是 View 控件的集合管理对象,也实现了组件的加载与绘制流程;而 Fragment 从源码看,本质上只是一个 View 组件的集合,通过控制变量实现特定的生命周期。由于 Fragment 并没有维护 Window 类型的成员变量,它不具备组件的加载与绘制能力,不能被单独绘制出来——这正是把它称为组件而非控件的原因。
02. Fragment 的创建与使用
2.1 使用条件
- 宿主 Activity 必须继承自 FragmentActivity(开发中通常直接继承 AppCompatActivity);
- 通过
getSupportFragmentManager()获取 FragmentManager 对象。
2.2 静态使用(XML 声明式)
步骤:创建一个继承 Fragment 的类并重写 onCreateView 确定要显示的布局;然后在 Activity 的布局 XML 中用 <fragment> 标签声明。
Activity 对应布局文件示例:
<LinearLayout >
<fragment
android:id="@+id/search_fragment"
android:name="com.yczbj.fragment.MyFragment"
android:layout_width="match_parent"
android:layout_height="match_parent" />
</LinearLayout>
在 Activity 中查找并显示/隐藏该 Fragment:
phoneNumFragment = (PhoneNumFragment) getSupportFragmentManager()
.findFragmentById(R.id.search_fragment);
private void showSearch() {
getSupportFragmentManager()
.beginTransaction()
.show(phoneNumFragment)
.commit();
}
2.3 动态使用(代码方式,开发中最常用)
OrderStatesFragment fragment = new OrderStatesFragment();
Bundle bundle = new Bundle();
bundle.putSerializable("confirmOrderModel", confirmOrderModel);
fragment.setArguments(bundle);
// 添加 fragment
FragmentManager fragmentManager = activity.getSupportFragmentManager();
FragmentTransaction transaction = fragmentManager.beginTransaction();
transaction.setCustomAnimations(R.anim.push_bottom_in, 0);
transaction.add(android.R.id.content, fragment, "OrderStatesFragment");
transaction.commitAllowingStateLoss();
动态创建的标准五步流程:
- 创建待添加的 Fragment 实例;
- 获取 FragmentManager:
getSupportFragmentManager(); - 开启事务:
beginTransaction(); - 向容器添加或替换 Fragment:常用
replace(容器id, fragment); - 提交事务:
commit()(或commitAllowingStateLoss())。
2.4 replace() 与 hide()/show() 的区别
replace()会先移除容器中同 id 的所有 Fragment 再添加新 Fragment,且不会保留被替换 Fragment 的状态——诸如 EditText 输入内容等用户操作会丢失;hide()/show()不会销毁 Fragment,能完整保留用户的处理信息,切换成本更低。
使用建议:
- 如果当前 Fragment 大概率会再次使用,优先
show()/hide(),性能更好; - 如果 App 中有大量图片,
replace()可能更合适,配合图片框架在 Fragment 视图销毁时回收图片内存; - 关于 add 与 replace 的进一步辨析可参考 01.Android之基础组件问题.md:add 是把 Fragment 添加进容器,replace 是先 remove 掉相同 id 的所有 Fragment 再添加,二者影响的只是界面,控制回退的是事务本身。
03. Fragment 交互与传值
核心原则:Fragment 尽量使用 Bundle 传值,即
fragment.setArguments(args)。
3.1 最常用的传递方式
对 Fragment 传递数据,建议使用 setArguments(Bundle args),在 onCreate 中使用 getArguments() 取出:
- 在"内存重启"前,系统会帮你保存这份数据,不会造成数据丢失,机制与 Activity 的 Intent 恢复类似;
- 使用
newInstance(参数)创建 Fragment 对象,调用者只需关心传递哪些数据,无需关心数据的 Key 是什么。
3.2 Fragment 与 Activity 之间传值
Activity 向 Fragment 传值:
- 把要传的值放入 Bundle 对象;
- 在 Activity 中创建 Fragment 对象,调用
fragment.setArguments(bundle)传入; - 在 Fragment 中通过
getArguments()拿到 Bundle 即可读取值。
Fragment 向 Activity 传值,两种方式:
- 方式一:在 Activity 中通过
getSupportFragmentManager().findFragmentByTag(tag)或findFragmentById(id)获取 Fragment 实例,直接调用其 public 方法; - 方式二:接口回调。在 Fragment 中定义接口,接口方法携带参数,在需要时调用;Activity 实现该接口并重写方法,值即传递到 Activity。
3.3 Fragment 与 Fragment 之间传值
- 第一种:通过
findFragmentByTag获取另一个 Fragment 的对象,直接调用其方法; - 第二种:通过接口回调的方式;
- 第三种:通过
setArguments/getArguments的方式(需要经过宿主 Activity 中转时尤为常用,例如通过ServiceDialogFragment.show(activity.getSupportFragmentManager())弹出对话框,参数先经setArguments传入,见 question/android/01.Android之基础组件问题.md)。
3.4 为何不用构造方法传值
Activity 给 Fragment 传数据一般不通过构造方法,而使用 setArguments:因为横竖屏切换时会调用 Fragment 的空参构造函数重建 Fragment,若数据放在构造方法参数中,重建时数据会丢失。
04. Fragment 回退栈
Fragment 回退栈用于保存每一次 Fragment 事务发生的变化:
- 将 Fragment 事务加入回退栈后,用户点击返回键时,会看到上一次保存的 Fragment;
- 一旦 Fragment 完全从回退栈中弹出,用户再次点击返回键,则退出当前 Activity。
在某个 Activity 上添加 Fragment,若不处理返回键逻辑,点击返回键会同时关闭 Fragment 和 Activity;若调用 transaction.addToBackStack(null),点击返回键时先回退 Fragment 事务,回到宿主 Activity 页面。
addToBackStack() 方法的作用:
- 当移除或替换一个 Fragment 并向返回栈添加事务时,系统会停止(而非销毁)被移除的 Fragment;
- 若用户执行回退操作进行 Fragment 恢复,该 Fragment 将重新启动;
- 若不向返回栈添加事务,系统在移除或替换 Fragment 时会将其销毁。
事务本质上记录了从一个状态到另一个状态的变化过程:例如从 FragmentA 替换到 FragmentB,通过 addToBackStack(null) 将该事务入栈后,点击返回键即可把状态变化过程还原(FragmentB → FragmentA)。
// Create new fragment and transaction
Fragment newFragment = new ExampleFragment();
FragmentTransaction transaction = getFragmentManager().beginTransaction();
// Replace whatever is in the fragment_container view with this fragment,
// and add the transaction to the back stack
transaction.replace(R.id.fragment_container, newFragment);
transaction.addToBackStack(null);
// Commit the transaction
transaction.commit();
05. Fragment 与 Activity 通信
Fragment 依附于 Activity 存在,通信方式归纳如下:
- 若 Activity 持有自己管理的 Fragment 引用,可直接通过引用访问其所有 public 方法;
- 若 Activity 未保存 Fragment 引用,每个 Fragment 都有唯一的 TAG 或 ID,可通过
getFragmentManager().findFragmentByTag()或findFragmentById()获得实例再操作; - Fragment 中可通过
getActivity()得到当前绑定的 Activity 实例再操作(注意:不建议频繁这样获取,容易引发空指针问题,详见第 07 节)。
通信优化:考虑 Fragment 的复用性,应尽量降低 Fragment 与 Activity 的耦合;Fragment 更不应该直接操作其他 Fragment,Fragment 的操作应由其管理者 Activity 来决定。对于频繁 show/hide 的 Fragment,可以这样封装:
/**
* 展示页面
*/
private void showPlayingFragment() {
if (isPlayFragmentShow) {
return;
}
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setCustomAnimations(R.anim.fragment_slide_up, 0);
if (mPlayFragment == null) {
mPlayFragment = PlayMusicFragment.newInstance("Main");
ft.replace(android.R.id.content, mPlayFragment);
} else {
ft.show(mPlayFragment);
}
ft.commitAllowingStateLoss();
isPlayFragmentShow = true;
}
/**
* 隐藏页面
*/
private void hidePlayingFragment() {
if (mPlayFragment != null) {
FragmentTransaction ft = getSupportFragmentManager().beginTransaction();
ft.setCustomAnimations(0, R.anim.fragment_slide_down);
ft.hide(mPlayFragment);
ft.commitAllowingStateLoss();
isPlayFragmentShow = false;
}
}
06. Fragment 旋转场景与状态保持
6.1 问题复现
屏幕旋转时 Activity 会重新启动,默认情况下 Activity 中的 Fragment 也会跟着重新创建。横竖屏显示不同必然涉及视图重绘,而不断旋转就不断绘制,是非常耗费内存的操作。
以一个最简单的 FragmentOne 为例(在 onCreate/onCreateView/onDestroyView/onDestroy 中打 Log),多次翻转屏幕会打印多次 onCreate、onCreateView:
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.651: E/FragmentOne(1633): onCreate
07-20 08:18:46.681: E/FragmentOne(1633): onCreateView
07-20 08:18:46.831: E/FragmentOne(1633): onCreateView
07-20 08:18:46.891: E/FragmentOne(1633): onCreateView
原因:屏幕旋转导致 Activity 重新启动,默认的 Fragment 会跟随重新创建;当 Activity 执行 onCreate 时又会再次实例化一个新的 Fragment,于是出现多个实例叠加。
6.2 解决方案
通过检查 onCreate(Bundle savedInstanceState) 的参数即可判断当前是否发生了 Activity 重新创建。默认的 savedInstanceState 会存储一些数据,包括 Fragment 的实例,因此只在 savedInstanceState == null 时才创建 Fragment 实例:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (savedInstanceState == null) {
mFOne = new FragmentOne();
FragmentManager fm = getFragmentManager();
FragmentTransaction tx = fm.beginTransaction();
tx.add(R.id.id_content, mFOne, "ONE");
tx.commit();
}
}
这样无论旋转多少次,Activity 中都只会有一个 Fragment 实例。但还有一个问题:重绘时 Fragment 重建,原本的数据如何保持?与 Activity 类似,Fragment 也有 onSaveInstanceState 方法,可在其中保存数据,然后在 onCreate / onCreateView / onActivityCreated 中恢复。
07. Fragment 使用建议
7.1 操作与传参建议
- 如果 Fragment 视图被频繁使用、或一会还要再次使用,建议用 show/hide 提升响应速度和性能;
- 如果 Fragment 占用大量资源,使用完成后可用 replace 及时释放资源;
- Fragment 的数据传递通过
setArguments/getArguments进行,Activity 重启时系统会帮你保存数据,这点与 Activity 很相似。
7.2 FragmentPageAdapter 与 FragmentPageStateAdapter 的区别
FragmentPagerAdapter:每次切换页面时只是将 Fragment 分离(detach),适合页面较少的场景,可以节省内存,对系统内存影响不大;FragmentStatePagerAdapter:每次切换页面时将 Fragment 回收,适合页面较多的场景,不会消耗过多内存。
从 PagerAdapter详细介绍.md 的源码细节可以进一步印证:
FragmentPagerAdapter.destroyItem()内部调用的是mCurTransaction.detach((Fragment) object),销毁的是 Fragment 的视图而非 Fragment 本身(走 onPause → onDestroyView),恢复时只需 attach 即可(走 onCreateView → onResume),因此会缓存所有 Fragment 实例;FragmentStatePagerAdapter.instantiateItem()会通过mSavedState.get(position)拿到之前保存的Fragment.SavedState,调用fragment.setInitialSavedState(fss)后重新 add 进事务,即销毁后通过状态恢复新建 Fragment,机制类似于 ListView,页面持有更少的内存。
一般制作主页只有 3、4 个 Tab 时选 FragmentPagerAdapter,ViewPager 展示数量特别多的条目时选 FragmentStatePagerAdapter。另外要注意 ViewPager 默认预加载机制:setOffscreenPageLimit(0) 会被源码强制回退为 1,详见 ViewPager懒加载.md。
7.3 Fragment 高耦合性问题
高耦合的典型场景:当子 Fragment 需要调用宿主 Activity 的方法时(例如发送消息),Fragment 没有该方法,往往需要强转宿主对象去调用,这违背了高内聚低耦合的设计原则。解决办法是接口抽象——通过接口去调用宿主 Activity 的方法:
public interface SendBListener {
void send();
}
public class FirstFragment extends Fragment {
SendBListener listener;
public void setListener(SendBListener listener) {
this.listener = listener;
}
@OnClick(value = R.id.tv)
void onTvClick(View view) {
listener.send();
}
}
public class MainActivity extends AppCompatActivity implements SendBListener {
@Override
public void send() {
}
@Override
protected void onCreate(Bundle savedInstanceState) {
FirstFragment firstFragment = new FirstFragment();
firstFragment.setListener(this);
}
}
08. Fragment 遇到的坑
8.1 getActivity() 空指针
问题:getActivity() 返回 null,或在"内存重启"后原本运行完好的代码突然空指针。
原因:大多数情况是调用 getActivity() 时,当前 Fragment 已经 onDetach() 了宿主 Activity。典型场景:Fragment 出栈后,其异步任务仍在执行,任务完成后调用 getActivity() 即空指针。
解决:在 Fragment 基类中设置一个 Activity 全局变量,在 onAttach(Activity activity) 中赋值,用 mActivity 代替 getActivity()。这样即使 onDetach 后 Fragment 仍持有 Activity 引用(有内存泄漏风险,但异步任务未停止时本身就可能泄漏,相比直接 Crash 更"安全"):
@Override
public void onAttach(Context context) {
super.onAttach(context);
activity = (MainActivity) context;
}
@Override
public void onDetach() {
super.onDetach();
activity = null;
}
8.2 Fragment 发生重叠
重叠原因:
- 页面重启(旋转屏幕、内存不足被强杀重启)。如果采用创建对象的方式初始化 Fragment,宿主 Activity 重新执行 onCreate 时会再次创建 Fragment,而之前已存在的 Fragment 实例也会被再次创建,两个实例同时显示导致 UI 重叠;
- 重复 replace/add Fragment,或 show/hide 使用不当;
- 横竖屏切换导致生命周期重刷。
背景知识:"内存重启"是指 App 运行在后台时,系统资源紧张回收了 App 进程,用户再次返回前台时 App 重启。屏幕旋转等配置变化也会导致当前 Activity 重启,本质类似。系统在回收 App 前会把 Activity 状态保存下来,由 FragmentManager 负责保存其中的 Fragment;"内存重启"后 Activity 从栈顶逐步恢复,Fragment 会在宿主 Activity 的 onCreate 之后紧接着恢复(从 onAttach 开始)。
源码层面的原因分析:Activity 的 onSaveInstanceState() 会在 Activity 将要被 kill 时回调(进入后台、屏幕旋转前、跳转下一个 Activity 等)。产生 Fragment 重叠的根本原因与这个保存机制有关:系统在页面重启前保存了 Fragment 的状态,但重启后恢复时视图的可见状态没有被保存,而 Fragment 默认是 show 状态,于是产生了重叠。
如何模拟调试:
- 先检查 Fragment 是否有背景,如果有先删除;
- 打开手机"设置 → 开发者选项 → 不保留活动"(用于模拟 Activity 被及时回收);
- 把 App 切到后台再重新打开,通过点按不同 tab 切换 Fragment,打开其他页面再回来、再切换 tab;
- 如果有重影,按下面方案解决。
方案一:findFragmentByTag + savedInstanceState 判断
在 add/replace 时绑定 tag(一般用 Fragment 类名),"内存重启"时通过 findFragmentByTag 找到对应 Fragment 并 hide 需要隐藏的:
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity);
TargetFragment targetFragment;
HideFragment hideFragment;
if (savedInstanceState != null) { // “内存重启”时调用
targetFragment = getSupportFragmentManager().findFragmentByTag(TargetFragment.class.getName());
hideFragment = getSupportFragmentManager().findFragmentByTag(HideFragment.class.getName());
// 解决重叠问题
getSupportFragmentManager().beginTransaction()
.show(targetFragment)
.hide(hideFragment)
.commit();
} else { // 正常时
targetFragment = TargetFragment.newInstance();
hideFragment = HideFragment.newInstance();
getSupportFragmentManager().beginTransaction()
.add(R.id.container, targetFragment, targetFragment.getClass().getName())
.add(R.id.container, hideFragment, hideFragment.getClass().getName())
.hide(hideFragment)
.commit();
}
}
该方案的弊端:
- 使用麻烦、代码量大;
- 嵌套 Fragment 场景下恢复会有问题:页面重启后,父 Fragment 未初始化完成前,getChildFragmentManager() 子栈内的子 Fragment 为空,只有父 Fragment 初始化完成后才能正确获取。
方案二:自己保存 Fragment 的 Hidden 状态(推荐)
重叠的根本原因是 FragmentState 没有保存 Fragment 的显示状态 mHidden,导致重启后其值为默认 false(show 状态)。手动维护一个 mSupportHidden 即可:
@Override
public void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (savedInstanceState != null) {
// 异常启动(内存重启)
boolean isSupportHidden = savedInstanceState.getBoolean(STATE_SAVE_IS_HIDDEN);
FragmentTransaction ft = null;
if (getFragmentManager() != null) {
ft = getFragmentManager().beginTransaction();
if (isSupportHidden) {
ft.hide(this);
} else {
ft.show(this);
}
ft.commit();
}
} else {
// 正常启动
}
}
@Override
public void onSaveInstanceState(@NotNull Bundle outState) {
outState.putBoolean(STATE_SAVE_IS_HIDDEN, isHidden());
}
优点:无论多深的嵌套 Fragment、同级 Fragment 等场景,全都可以正常工作,不会发生重叠。
方案三:通过 getFragment/putFragment 方式
在首页 MainActivity 的 onSaveInstanceState(Bundle outState) 中,判断当前所有 Fragment,将已加载的 Fragment 保存(注意:通过 putFragment() 按 Tag 保存前需确认该 Fragment 已 add 到 FragmentManager 中,否则会报 IllegalStateException: Fragment is not currently in the FragmentManager):
@Override
protected void onSaveInstanceState(Bundle outState) {
LogUtil.d("MainActivity-----onSaveInstanceState");
// 传入当前选中的 tab 值,在销毁重启后再定向到该 tab
if (outState != null) {
/* fragment 不为空时保存 */
for (int i = 0; i < TAB_SIZE; i++) {
// 确保 fragment 是否已经加入到 fragment manager 中
if (fragmentList.size() > i && fragmentList.get(i).isAdded() && fragmentList.get(i) != null) {
// 保存已加载的 Fragment
getSupportFragmentManager().putFragment(outState, mFragmentTags.get(i), fragmentList.get(i));
}
}
outState.putInt("position", position);
}
super.onSaveInstanceState(outState);
}
在 onCreate(Bundle savedInstanceState) 中恢复:先判断 savedInstanceState 是否为 null,逐步判断对应 Tag 的 Fragment 是否存在,存在则放入存储 Fragment 的 list 中:
@Override
public void onCreate(Bundle savedInstanceState) {
if (savedInstanceState != null) {
/* 获取保存的 fragment,没有的话返回 null */
for (int i = 0; i < TAB_SIZE; i++) {
Fragment fragment = getSupportFragmentManager().getFragment(
savedInstanceState, mFragmentTags.get(i));
if (fragment != null && fragmentList.size() > i) {
fragmentList.set(i, fragment);
}
}
position = savedInstanceState.getInt("position", 0);
}
initFragment();
}
初始化 Fragment 时记得先判断是否已存在,避免异常重启后重复 add:
private void initFragment() {
// 避免异常重启后重复 add
if (fragmentList.size() >= TAB_SIZE) {
fragmentList.set(0, new IndexFragment());
fragmentList.set(1, new BaoFragment());
fragmentList.set(2, new MyFragment());
} else {
fragmentList.add(0, new IndexFragment());
fragmentList.add(1, new BaoFragment());
fragmentList.add(2, new MyFragment());
}
}
8.3 Fragment 叠加点击穿透
场景:首页 MainActivity 包含多个 Fragment,通过 hide&show 进行 tab 切换。有时当前 Fragment 页点击不该被点击的位置,却触发了其他 Fragment 页面对应位置的点击事件;该问题并非 100% 复现,有些机型不出现、有些很频繁;App 异常重启出现 Fragment 叠加时也容易点击穿透。
原因:本质是点击事件分发问题。多个 Fragment 添加进 Fragment 栈时,栈底 Fragment 的点击事件在上层 Fragment 出现后仍然有效。
解决:在 BaseFragment 中全局设置 view.setClickable(true),截断点击事件的扩散:
@Nullable
@Override
public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
View rootView = inflater.inflate(this.getLayoutId(), container, false);
rootView.setClickable(true); // 把 View 的 click 属性设为 true,截断点击事件扩散
return rootView;
}
8.4 commit 与 commitAllowingStateLoss
一般的 Fragment 添加写法:
getSupportFragmentManager()
.beginTransaction()
.add(R.id.fragment_container, new MyFragment())
.commit();
但有时候会报:Caused by: java.lang.IllegalStateException: Can not perform this action after onSaveInstanceState,意思是不允许在调用 onSaveInstanceState 之后进行 commit。网上常见解法是用 commitAllowingStateLoss 替换 commit,确实不报错了,但为什么?
源码追踪:
- FragmentTransaction 中 commit 与 commitAllowingStateLoss 是抽象方法:
public abstract class FragmentTransaction {
public abstract int commit();
public abstract int commitAllowingStateLoss();
}
- 实现类 BackStackRecord 中二者差异仅在 commitInternal 的布尔参数:
final class BackStackRecord extends FragmentTransaction implements
FragmentManager.BackStackEntry, FragmentManagerImpl.OpGenerator {
@Override
public int commit() {
return commitInternal(false);
}
@Override
public int commitAllowingStateLoss() {
return commitInternal(true);
}
}
- commitInternal 中该布尔值传入 enqueueAction:
int commitInternal(boolean allowStateLoss) {
// ...省略无关代码
mManager.enqueueAction(this, allowStateLoss);
return mIndex;
}
- enqueueAction 中对该值进行判断:
public void enqueueAction(OpGenerator action, boolean allowStateLoss) {
if (!allowStateLoss) {
checkStateLoss();
}
synchronized (this) {
if (mDestroyed || mHost == null) {
if (allowStateLoss) {
// This FragmentManager isn't attached, so drop the entire transaction.
return;
}
throw new IllegalStateException("Activity has been destroyed");
}
// ...省略无关代码
}
}
- checkStateLoss 抛出异常:
private void checkStateLoss() {
if (isStateSaved()) {
throw new IllegalStateException(
"Can not perform this action after onSaveInstanceState");
}
if (mNoTransactionsBecause != null) {
throw new IllegalStateException(
"Can not perform this action inside of " + mNoTransactionsBecause);
}
}
@Override
public boolean isStateSaved() {
// See saveAllState() for the explanation of this. We do this for
// all platform versions, to keep our behavior more consistent between
// them.
return mStateSaved || mStopped;
}
- mStateSaved 在 saveAllState 中被置为 true,而 saveAllState 是在 Activity 与 FragmentActivity 的 onSaveInstanceState 方法中调用的:
Parcelable saveAllState() {
// ...省略无关代码
mStateSaved = true;
// ...省略无关代码
}
结论:commit 会对状态进行检测并抛出异常;commitAllowingStateLoss 不进行状态检测,因此不会抛出异常。 但谷歌在 commitAllowingStateLoss 的注释中也写明,调用此方法有丢失页面状态信息的风险。
使用建议:
- 一般情况下尽量提早调用 commit,比如在 onCreate() 中;
- 异步回调中避免使用 commit;
- 不得已的情况下,可用 commitAllowingStateLoss 替代 commit——毕竟崩溃比页面状态信息丢失更严重。
09. Fragment 一些疑惑
9.1 Fragment 能否不依赖 Activity
Fragment 不能独立存在,必须嵌入到 Activity 中,且 Fragment 的生命周期直接受所在 Activity 的影响。
9.2 事务与回退栈的本质
transaction 只是记录了从一个状态到另一个状态的变化过程。比如从 FragmentA 替换到 FragmentB,当通过 transaction.addToBackStack(null) 将事务添加到回退栈,就记录了这次状态变化;用户点击返回键时,由于状态变化过程被保存,可以将事务还原,即 FragmentB → FragmentA。
9.3 生命周期补充
结合 01.Android之基础组件问题.md,Fragment 从创建到销毁的完整生命周期依次为:
onAttach() → onCreate() → onCreateView() → onActivityCreated() → onStart() → onResume() → onPause() → onStop() → onDestroyView() → onDestroy() → onDetach()
与 Activity 同名方法作用相似,而 Fragment 特有的方法含义如下:
onAttach():Fragment 与 Activity 建立关联时调用;onCreateView():Fragment 创建视图时调用;onActivityCreated():与 Fragment 关联的 Activity 完成 onCreate() 之后调用;onDestroyView():Fragment 的布局被移除时调用;onDetach():Fragment 与 Activity 解除关联时调用。
Fragment 的特点可总结为:可以作为 Activity 界面的一部分出现;一个 Activity 中可同时出现多个 Fragment,一个 Fragment 也可在多个 Activity 中使用;Activity 运行过程中可以添加、移除或替换 Fragment;Fragment 响应自己的输入事件,有自己的生命周期,且生命周期受宿主 Activity 影响。
附:仓库内延伸阅读
- 11.Fragment基础使用.md:本文核心源文档;
- 01.Android之基础组件问题.md:包含 Fragment 传值、生命周期、getActivity 为 null、重叠、add/replace 区别等高频面试题;
- PagerAdapter详细介绍.md:FragmentPagerAdapter 与 FragmentStatePagerAdapter 的源码级对比;
- ViewPager懒加载.md:ViewPager 预加载机制与 Fragment 懒加载实践;
- 03.DialogFragment源码分析.md:DialogFragment 的 show() 方法与 IllegalStateException 分析;
- 02.Navigation学习.md:Navigation 组件如何管理 Fragment 切换与回退栈。