前言
Activity/Fragment/View 系列文章：
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 效果图
本文基于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 前置基础系列
