Android Fragment 要你何用？

小鱼人爱编程

已于 2023-01-05 09:33:38 修改

阅读量1.6k

点赞数

分类专栏： Jetpack 细水长流文章标签： android ui java

于 2021-12-31 23:32:18 首次发布

本文链接：https://blog.csdn.net/wekajava/article/details/122263682

版权

Jetpack 细水长流专栏收录该内容

9 篇文章 3 订阅

订阅专栏

前言

系列文章：

Android Activity 与View 的互动思考
 Android Activity 生命周期详解及监听
 Android onSaveInstanceState/onRestoreInstanceState 原来要这么理解
 Android Fragment 要你何用？
Android Activity/View/Window/Dialog/Fragment 深层次关联(白话解析)

关于Fragment 的分析网上已经有许多优秀文章流传，有些人觉得它的生命周期比较复杂，不好控制，实属鸡肋。有些人认为它封装得比较好，属于"轻量级的Activity"，值得在工程里引入。
通过本篇文章，你将了解到：

1、为什么需要Fragment
2、添加Fragment的方式
3、Activity 与Fragment 生命周期的联动
4、常见的控制Fragment 方法

1、为什么需要Fragment

Fragment 定义

Fragment 翻译为中文：碎片、片段。
最早在Android 3.0时引入的，为了应用能够适配大屏幕的设备而提供的一种灵活的UI 组件。

Fragment 与View、Activity 关系

和View 对比

如上图，App 需要适配手机与平板。
因为有公用的界面，因此尽可能地想复用公用部分，这个时候我们想到了View。将View 抽取出来作为一个公共UI组件，分别放在手机和平板对应的布局文件里。若是View里包含了比较多的逻辑，以后就不好复用这个组件了。并且View 本身并没有生命周期，想要跟随Activity的生命周期，只能靠Activity 传递过来或是主动监听Activity 生命周期变化，比较麻烦。
刚好，Fragment 能够满足此种需求。
和View 相比，Fragment 有如下特点：

1、拥有生命周期。
2、将View(UI)与逻辑封装在Fragment里。
3、其它Activity 可以复用Fragment(UI + 逻辑)。

和Activity 对比

我们常说Activity “重”，View “轻”，这很容易理解，试想一下：启动一个Activity 远比展示一个View 慢很多。
为什么呢？
因为Activity 是受到AMS 管控的，Activity 的生命周期都是由AMS 跨进程通知到App进程，这显然耗费了不少时间。再加上Activity 启动时初始化了许多东西，比如Window、DecorView等，因此从启动Activity 到完全展示它需要一定的时间。
而View 则不同，仅仅只需要new 一个对象，并设置一些属性，最后添加到上层的ViewGroup里进行展示即可，都是在本进程内操作，速度很快。
和View 类似，当向Activity 里添加Fragment 时，实际上主要做了两件事：

1、加入到Fragment栈里，方便管理。
2、将Fragment 所持有的View 添加到ViewTree 某个节点里。

可以看出，以上两步没有涉及进程间通信，也没有初始化许多的组件，因此启动一个Fragment 比启动一个Activity 快得多。

三者关系

用图说明三者的联系：

上图仅仅表示类比关系，Fragment并不是Activity 子类也不是View/ViewGroup 父类或子类。

2、添加Fragment的方式

静态添加方式

了解了Fragment特点，看看如何使用它。与View 类似，View 可以放在xml里作为静态加载，也可以通过代码动态加载。
先说静态加载。
编写静态布局文件：activity_static_fragment.xml

<?xml version="1.0" encoding="utf-8"?>
<com.example.androiddemo.fragment.MyFrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <fragment
        android:id="@+id/static_fragment"
        android:name="com.example.androiddemo.fragment.MyFragment"
        android:layout_width="match_parent"
        android:layout_height="100dp"
        tools:ignore="Instantiatable">
    </fragment>

</com.example.androiddemo.fragment.MyFrameLayout>

其中android:name 指定Fragment的全限定类名称。
MyFragment 是自定义的Fragment。
然后在Activity onCreate里加载此布局文件：

setContentView(R.layout.activity_static_fragment);

可以看出，静态添加fragment 与静态添加View 很相似，接着分析其添加的原理。

静态添加原理

1、整体流程
上节有提到过，Fragment 会将布局文件管理起来并添加到ViewTree里。在声明自定义Fragment时需要重写onCreateView(xx)方法：

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,Bundle savedInstanceState) {
        TextView textView = new TextView(getContext());
        if (TextUtils.isEmpty(desc))
            desc = "静态fragment";
        textView.setText(desc);
        textView.setLayoutParams(new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
        return textView;
    }

该方法可以理解为Fragment指定其承载的布局，此处构造一个TextView 对象，并返回。

串起来静态加载的流程为：

1、Activity 通过LayoutInflater 加载布局文件。
2、LayoutInflater 寻找"fragment"标签。
3、找到"fragment"标签，根据"android:name"指定的Fragment类的全限定名称反射实例化Fragment。
4、拿到Fragment实例后，调用onCreateView(xx)，将返回的View对象与Fragment进行关联。
5、View 对象被添加到"fragment"标签的父布局里。在该例里是MyFrameLayout。
6、至此，Fragment关联的View 已经被添加到ViewTree里。

注：Fragment并不是Activity/View 的子类，

2、View 添加到ViewTree
核心代码：

#FragmentManagerImpl.java
    void ensureInflatedFragmentView(Fragment f) {
        if (f.mFromLayout && !f.mPerformedCreateView) {
            //最终执行到Fragment.onCreateView()
            //返回的View 对象赋值给f.mView
            f.performCreateView(f.performGetLayoutInflater(
                    f.mSavedFragmentState), null, f.mSavedFragmentState);
            if (f.mView != null) {
                ...
                //调用onViewCreated(xx)
                f.onViewCreated(f.mView, f.mSavedFragmentState);
            } else {
                f.mInnerView = null;
            }
        }
    }

Fragment 将关联的View 存储在f.mView里，LayoutInflater 加载时将f.mView add 到上层的ViewGroup里，最终f.mView 挂接到ViewTree里。

动态添加方式

    private void addFragment(Fragment fragment) {
//        list.add(fragment);
        //获取Fragment管理对象
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();   // 开启一个事务
        //添加fragment
        transaction.add(R.id.container, fragment);
        //提交动作
        transaction.commit();
    }

封装一个addFragment(xx)方法，传入构造好的Fragment。
然后在Activity的onCreate(xx)里调用此方法

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_fragment);
        //直接new 出来
        addFragment(new MyFragment("fragment1"));
    }

动态添加原理

1、获取Fragment 控制器
先看getSupportFragmentManager()：

#FragmentActivity.java
    public FragmentManager getSupportFragmentManager() {
        return mFragments.getSupportFragmentManager();
    }

而mFragments 是FragmentActivity.java 的成员变量：

#FragmentActivity.java
final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

最终返回的是FragmentManagerImpl 实例。
从这里可以看出，每个直接或间接地继承自FragmentActivity.java 的类都会拥有FragmentController 成员变量，从该变量里获取FragmentManagerImpl 实例就可以控制Fragment的一切活动。

2、Fragment 关联 View
接着看：

transaction.add(R.id.container, fragment);

第一个参数表示要将Fragment挂接到的ViewGroup，第二个参数表示待挂接的Fragment 对象。
而当Fragment.onCreateView(xx)被调用时，返回的View 将会被add到ViewGroup里，也就是R.id.container代表的ViewGroup。
而R.id.container 是Activity 布局文件里某个布局的id。
至此：

Fragment 所关联的View 被添加到ViewTree里。

3、View 添加到ViewTree
核心代码：

#FragmentManagerImpl.java
    void moveToState(Fragment f, int newState, int transit, int transitionStyle,
                     boolean keepActive) {
        ...
        //最终执行Fragment.onCreateView(xx)
        //返回的View 赋值给f.mView，f表示Fragment 对象
        f.performCreateView(f.performGetLayoutInflater(
                f.mSavedFragmentState), container, f.mSavedFragmentState);
        if (f.mView != null) {
            f.mInnerView = f.mView;
            f.mView.setSaveFromParentEnabled(false);
            //container 是ViewGroup
            //transaction.replace(R.id.container, fragment) 方法里的 R.id.container 实例化得来的
            if (container != null) {
                //将Fragment.onCreateView(xx)得到的View 添加到container里，也就是添加到了ViewTree里。
                container.addView(f.mView);
            }
            ...
        } else {
            f.mInnerView = null;
        }
        ...
    }

需要注意的是，在onCreateView(xx)里咱们是动态生成了View，若是通过LayoutInflater加载布局文件：

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
                             Bundle savedInstanceState) {
        //最后参数为false
        View view = inflater.inflate(R.layout.fragment_layout, container,false);
        return view;
    }

那么最后一个参数必须为false，意思是不将生成的View add到container里，因为在FragmentManagerImpl.moveToState(xx)里也会执行container.addView(view)，若是最后参数为true，那么就会报重复添加的错误。

3、Activity 与Fragment 生命周期的联动

通过对静态添加与动态添加的分析，我们已经弄清楚了Fragment 关联的View 如何添加到ViewTree里。接着再来分析静态添加与动态添加时Fragment 生命周期的流转。

Fragment 的生命周期的由来

Fragment 依赖于Activity，因此我们想当然地认为它的生命周期依赖于Activity，事实究竟如何呢？为寻求真相，从源码入手。
以Activity.onResume()为例，探究与Fragment.onResume()关系。
当调用Activity.performResume(xx)时，有如下源码：

    #Activity.java
    final void performResume(boolean followedByPause, String reason) {
        ...
        onPostResume();
        ...
    }

    #FragmentActivity.java
    protected void onPostResume() {
        super.onPostResume();
        onResumeFragments();
    }

    #FragmentActivity.java
    protected void onResumeFragments() {
        mFragmentLifecycleRegistry.handleLifecycleEvent(Lifecycle.Event.ON_RESUME);
        //mFragments 最终控制着Fragment 生命周期
        mFragments.dispatchResume();
    }

可以看出，因为自定义的Activity 直接/间接地继承自FragmentActivity，而FragmentActivity 重写了很多Activity 方法，因此每当调用Activity.xx()方法时都会调用到FragmentActivity重写的对应方法，而重写的方法里会通过mFragments(FragmentController 控制器）最终控制Fragment各个生命周期回调方法。
总而言之：

1、Fragment 生命周期依赖于Activity 生命周期。
2、Activity 生命周期变更回调的方法onCreate/onStart/onResume/onPause/onStop/onDestroy，Fragment都有，Fragment 比Activity 还多一些回调方法，比如onAttach/onCreateView 等。

静态添加Fragment 生命周期

以图示之：

由图可知：

Activity 生命周期变动就会调用Fragment对应方法，因此Fragment 也间接拥有了生命周期。

明显地可以看出，Fragment 生命周期涉及到的方法比Activity 更多。
简单解释涉及的各个方法的用处：

1、onAttach

Fragment 第一次绑定Context。
当使用Fragment.getContext()/Fragment.getActivity()返回的是绑定的FragmentActivity。

2、onCreate

类似Activity onCreate。

3、onCreateView

关联Fragment 与UI，Fragment的展示效果即是通过该UI表现的。

4、onViewCreated

执行到这一步，说明第三步创建的View 已经被添加到ViewTree里。

5、onActivityCreated

表示Activity 与Fragment 完全绑定了。

onDestroyView、onDetach 等是反向操作，不再细说。

动态添加Fragment 生命周期

理论上来说不管静态添加还是动态添加，生命周期都是一样的，为什么要区分呢？
我们之前说的动态添加方式，有个方法重点关注：

transaction.commit();

该方法有个孪生兄弟方法：

transaction.commitNow()

顾名思义，transaction.commitNow() 表示立即添加，生命周期与静态添加一致。
而transaction.commit() 是加入到队列里，延迟执行，此时生命周期如下：

因为延迟执行，并没有在Activity.onCreate(xx)时进行Fragment.onAttach()等一些列操作，而是在Activity.onStart()之后。
除了这点区别，其它都一样。

4、常见的控制Fragment 方法

主要是依赖FragmentTransaction 来控制Fragment。
1、FragmentTransaction.hide(xx)

隐藏Fragment，本质上是将Fragment关联的View进行隐藏：View.setVisibility(GONE)
不会回调Fragment 生命周期中的方法。

2、FragmentTransaction.show(xx)

显示Fragment，本质上是将Fragment关联的View进行展示：View.setVisibility(VISIBLE)
不会回调Fragment 生命周期中的方法。

3、FragmentTransaction.detach(xx)

将Fragment 从Activity 中移除，实际上是将Fragment 关联的View 从ViewTree中移除。Fragment还在栈里。

生命周期变化如下：

4、FragmentTransaction.remove(xx)

除了将Fragment 从Activity 中移除，还将Fragment从回退栈里移除。

生命周期变化如下：

5、FragmentTransaction.replace(xx)

效果同 remove + add。

当前展示fragment1，通过FragmentTransaction.replace(fragment2)，
生命周期变动如下：

6、数据传递
Activity 向Fragment传递数据，实际上就是传递Bundle。
Fragment.setArguments(Bundle)。
在Fragment里通过：
Fragment.getArguments()获取。
当然，引入Jetpack可通过ViewModel共享数据。

最后附上Demo 效果图

Fragment 添加/删除/替换/隐藏测试代码

本文基于Android 10.0

您若喜欢，请点赞、关注，您的鼓励是我前进的动力

持续更新中，和我一起步步为营系统、深入学习Android

1、Android各种Context的前世今生
2、Android DecorView 必知必会
3、Window/WindowManager 不可不知之事
4、View Measure/Layout/Draw 真明白了
5、Android事件分发全套服务
6、Android invalidate/postInvalidate/requestLayout 彻底厘清
7、Android Window 如何确定大小/onMeasure()多次执行原因
8、Android事件驱动Handler-Message-Looper解析
9、Android 键盘一招搞定
10、Android 各种坐标彻底明了
11、Android Activity/Window/View 的background
12、Android Activity创建到View的显示过
13、Android IPC 系列
14、Android 存储系列
15、Java 并发系列不再疑惑
16、Java 线程池系列
17、Android Jetpack 前置基础系列
18、Android Jetpack 易学易懂系列