YCBlogs 之 Fragment 基础使用完全指南:创建、传值、回退栈与实战避坑

原创2026-10-07 22:48:021,993 阅读
文章标签:文档技术博客教程知识库

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();

动态创建的标准五步流程:

  1. 创建待添加的 Fragment 实例;
  2. 获取 FragmentManager:getSupportFragmentManager();
  3. 开启事务:beginTransaction();
  4. 向容器添加或替换 Fragment:常用 replace(容器id, fragment);
  5. 提交事务: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 传值:

  1. 把要传的值放入 Bundle 对象;
  2. 在 Activity 中创建 Fragment 对象,调用 fragment.setArguments(bundle) 传入;
  3. 在 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 发生重叠

重叠原因:

  1. 页面重启(旋转屏幕、内存不足被强杀重启)。如果采用创建对象的方式初始化 Fragment,宿主 Activity 重新执行 onCreate 时会再次创建 Fragment,而之前已存在的 Fragment 实例也会被再次创建,两个实例同时显示导致 UI 重叠;
  2. 重复 replace/add Fragment,或 show/hide 使用不当;
  3. 横竖屏切换导致生命周期重刷。

背景知识:"内存重启"是指 App 运行在后台时,系统资源紧张回收了 App 进程,用户再次返回前台时 App 重启。屏幕旋转等配置变化也会导致当前 Activity 重启,本质类似。系统在回收 App 前会把 Activity 状态保存下来,由 FragmentManager 负责保存其中的 Fragment;"内存重启"后 Activity 从栈顶逐步恢复,Fragment 会在宿主 Activity 的 onCreate 之后紧接着恢复(从 onAttach 开始)。

源码层面的原因分析:Activity 的 onSaveInstanceState() 会在 Activity 将要被 kill 时回调(进入后台、屏幕旋转前、跳转下一个 Activity 等)。产生 Fragment 重叠的根本原因与这个保存机制有关:系统在页面重启前保存了 Fragment 的状态,但重启后恢复时视图的可见状态没有被保存,而 Fragment 默认是 show 状态,于是产生了重叠。

如何模拟调试:

  1. 先检查 Fragment 是否有背景,如果有先删除;
  2. 打开手机"设置 → 开发者选项 → 不保留活动"(用于模拟 Activity 被及时回收);
  3. 把 App 切到后台再重新打开,通过点按不同 tab 切换 Fragment,打开其他页面再回来、再切换 tab;
  4. 如果有重影,按下面方案解决。

方案一: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,确实不报错了,但为什么?

源码追踪:

  1. FragmentTransaction 中 commit 与 commitAllowingStateLoss 是抽象方法:
public abstract class FragmentTransaction {
    public abstract int commit();
    public abstract int commitAllowingStateLoss();
}
  1. 实现类 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);
    }
}
  1. commitInternal 中该布尔值传入 enqueueAction:
int commitInternal(boolean allowStateLoss) {
    // ...省略无关代码
    mManager.enqueueAction(this, allowStateLoss);
    return mIndex;
}
  1. 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");
        }
        // ...省略无关代码
    }
}
  1. 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;
}
  1. 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 影响。

附:仓库内延伸阅读

登录后查看全文
YCBlogs