移动开发最新Android组件内核之Fragment管理与内核（二），2024年最新一篇文章教你搞定计算机网络面试

本文链接：https://blog.csdn.net/2401_84563080/article/details/138734683

《设计思想解读开源框架》

第一章、热修复设计

第一节、 AOT/JIT & dexopt 与 dex2oat
第二节、热修复设计之 CLASS_ISPREVERIFIED 问题
第三节、热修复设计之热修复原理
第四节、Tinker 的集成与使用（自动补丁包生成）

第二章、插件化框架设计
第一节、 Class 文件与 Dex 文件的结构解读
第二节、 Android 资源加载机制详解
第三节、四大组件调用原理
第四节、 so 文件加载机制
第五节、 Android 系统服务实现原理

第三章、组件化框架设计
第一节、阿里巴巴开源路由框——ARouter 原理分析
第二节、APT 编译时期自动生成代码&动态类加载
第三节、 Java SPI 机制
第四节、 AOP&IOC
第五节、手写组件化架构

第四章、图片加载框架
第一节、图片加载框架选型
第二节、Glide 原理分析
第三节、手写图片加载框架实战

第五章、网络访问框架设计
第一节、网络通信必备基础
第二节、OkHttp 源码解读
第三节、Retrofit 源码解析

第六章、 RXJava 响应式编程框架设计
第一节、链式调用
第二节、扩展的观察者模式
第三节、事件变换设计
第四节、Scheduler 线程控制

第七章、 IOC 架构设计
第一节、依赖注入与控制反转
第二节、ButterKnife 原理上篇、中篇、下篇
第三节、Dagger 架构设计核心解密

第八章、 Android 架构组件 Jetpack
第一节、 LiveData 原理
第二节、 Navigation 如何解决 tabLayout 问题
第三节、 ViewModel 如何感知 View 生命周期及内核原理
第四节、 Room 架构方式方法
第五节、 dataBinding 为什么能够支持 MVVM
第六节、 WorkManager 内核揭秘
第七节、 Lifecycles 生命周期

本文包含不同方向的自学编程路线、面试题集合/面经、及系列技术文章等，资源持续更新中…

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

final FragmentController mFragments = FragmentController.createController(new HostCallbacks());

/**

Return the FragmentManager for interacting with fragments associated
with this activity.
*/
public FragmentManager getFragmentManager() {
return mFragments.getFragmentManager();
}

FragmentManager是一个抽象类，它是通过mFragments.getFragmentManager()来获取的，mFragments是FragmentController对象，它通过FragmentController.createController(new HostCallbacks())生成，这是一个静态工厂方法：

public static final FragmentController createController(FragmentHostCallback<?> callbacks) {
return new FragmentController(callbacks);
}

在这里面直接new了一个FragmentController对象，注意FragmentController的构造方法需要传入一个FragmentHostCallback

1.3.2FragmentController构造方法

private final FragmentHostCallback<?> mHost; private FragmentController(FragmentHostCallback<?> callbacks) {
mHost = callbacks;
}

构造方法很简单，传入了一个FragmentHostCallback实例

1.3.3FragmentController#getFragmentManager

public FragmentManager getFragmentManager() {
return mHost.getFragmentManagerImpl();
}

这里又调用了mHost的getFragmentManagerImpl方法，希望童鞋们没有被绕晕，mHost是一个FragmentHostCallback实例，那我们回过头来看看它传进来的地方

1.3.4FragmentHostCallback
这个FragmentHostCallback是一个抽象类，我们可以看到，在Activity中是传入了 Activity#HostCallbacks内部类，这个就是FragmentHostCallback的实现类

1.3.5FragmentHostCallback#getFragmentManagerImpl

final FragmentManagerImpl mFragmentManager = new FragmentManagerImpl();
FragmentManagerImpl getFragmentManagerImpl() {
return mFragmentManager;
}

终于找到FragmentManager的真身FragmentManagerImpl了

1.3.6FragmentManagerImpl#beginTransaction

@Override
public FragmentTransaction beginTransaction() {
return new BackStackRecord(this);
}

可以看到，所谓的FragmentTransaction其实就是一个BackStackRecord。到现在，FragmentManager和FragmentTransaction我们都找到了。下图就是各个类之间的关系：

下面开始真正的事务管理分析，我们先选择一个事务add来进行分析

1.3.7FragmentTransaction#add

public FragmentTransaction add(int containerViewId, Fragment fragment, String tag) {
doAddOp(containerViewId, fragment, tag, OP_ADD);
return this;
}

private void doAddOp(int containerViewId, Fragment fragment, String tag, int opcmd) {

//设置fragment的FragmentManagerImpl，mManager其实就是Activity#HostCallbacks中的成员变量
fragment.mFragmentManager = mManager;

//设置fragment的tag
if (tag != null) {
if (fragment.mTag != null && !tag.equals(fragment.mTag)) {
throw new IllegalStateException(“…”);
}
fragment.mTag = tag;
}

if (containerViewId != 0) {
if (containerViewId == View.NO_ID) {
throw new IllegalArgumentException(“…”);
}
if (fragment.mFragmentId != 0 && fragment.mFragmentId != containerViewId) {
throw new IllegalStateException(“”);
}
//设置fragment的mContainerId以及mFragmentId
fragment.mContainerId = fragment.mFragmentId = containerViewId;
}

//新增一个操作
Op op = new Op();
op.cmd = opcmd;
op.fragment = fragment;
//添加操作
addOp(op);
}

//插入到链表的最后
void addOp(Op op) {
if (mHead == null) {
mHead = mTail = op;
} else {
op.prev = mTail;
mTail.next = op;
mTail = op;
}
op.enterAnim = mEnterAnim;
op.exitAnim = mExitAnim;
op.popEnterAnim = mPopEnterAnim;
op.popExitAnim = mPopExitAnim;
mNumOp++;
}

add的操作步骤为：

设置fragment的FragmentManagerImpl
设置fragment的tag
设置fragment的mContainerId以及mFragmentId
插入一个类型为OP_ADD的操作到链表最后
这里用到了一个类：

static final class Op {
Op next;//下一操作节点
Op prev;//上一操作节点
int cmd;//操作类型，可选有：OP_NULL|OP_ADD|OP_REPLACE|OP_REMOVE|OP_HIDE|OP_SHOW|OP_DETACH|OP_ATTACH
Fragment fragment;//操作的Fragment对象
int enterAnim;//入场动画
int exitAnim;//出场动画
int popEnterAnim;//弹入动画
int popExitAnim;//弹出动画
ArrayList removed;
}

这是一个操作链表节点。所有add、remove、hide等事物最终会形成一个操作链

1.3.8FragmentTransaction#commit
等所有操作都插入后，最后我们需要调用FragmentTransaction的commit方法，操作才会真正地执行。

public int commit() {
return commitInternal(false);
}

int commitInternal(boolean allowStateLoss) {
//防止重复commit
if (mCommitted) {
throw new IllegalStateException(“commit already called”);
}

//DEBUG代码统统不管
if (FragmentManagerImpl.DEBUG) {
Log.v(TAG, “Commit: " + this);
LogWriter logw = new LogWriter(Log.VERBOSE, TAG);
PrintWriter pw = new FastPrintWriter(logw, false, 1024);
dump(” ", null, pw, null);
pw.flush();
}

mCommitted = true;

//只有调用了addToBackStack方法之后，这个标记才会为true
if (mAddToBackStack) {
mIndex = mManager.allocBackStackIndex(this);
} else {
mIndex = -1;
}
//插入事物队列
mManager.enqueueAction(this, allowStateLoss);
return mIndex;
}

1.3.9FragmentManagerImpl#enqueueAction

/**

Adds an action to the queue of pending actions.
@param action the action to add
@param allowStateLoss whether to allow loss of state information
@throws IllegalStateException if the activity has been destroyed
*/
public void enqueueAction(Runnable action, boolean allowStateLoss) {
if (!allowStateLoss) {
checkStateLoss();
}
synchronized (this) {
if (mDestroyed || mHost == null) {
throw new IllegalStateException(“Activity has been destroyed”);
}
if (mPendingActions == null) {
mPendingActions = new ArrayList();
}
mPendingActions.add(action);
if (mPendingActions.size() == 1) {
mHost.getHandler().removeCallbacks(mExecCommit);
mHost.getHandler().post(mExecCommit);
}
}
}

这里把操作添加到mPendingActions列表里去。并通过mHost.getHandler()获取Handler发送执行请求。从上面的分析知道，mHost就是Activity的HostCallbacks，构造方法中把Activity的mHandler传进去了，这里执行的mHost.getHandler()获取到的也就是Activity中的mHandler，这样做是因为需要在主线程中执行

final Handler mHandler = new Handler();

再看看mExecCommit中做了什么操作：

Runnable mExecCommit = new Runnable() {
@Override
public void run() {
execPendingActions();
}
};

/**

Only call from main thread!
*/
public boolean execPendingActions() {
if (mExecutingActions) {
throw new IllegalStateException(“Recursive entry to executePendingTransactions”);
}

//再次检测是否主线程
if (Looper.myLooper() != mHost.getHandler().getLooper()) {
throw new IllegalStateException(“Must be called from main thread of process”);
}

boolean didSomething = false;

while (true) {
int numActions;

synchronized (this) {

//参数检测
if (mPendingActions == null || mPendingActions.size() == 0) {
break;
}

numActions = mPendingActions.size();
if (mTmpActions == null || mTmpActions.length < numActions) {
mTmpActions = new Runnable[numActions];
}

mPendingActions.toArray(mTmpActions);
mPendingActions.clear();
mHost.getHandler().removeCallbacks(mExecCommit);
}

mExecutingActions = true;
//遍历执行待处理的事务操作
for (int i=0; i<numActions; i++) {
mTmpActions[i].run();
mTmpActions[i] = null;
}
mExecutingActions = false;
didSomething = true;
}

doPendingDeferredStart();

return didSomething;
}

插入了事物之后，就是在主线程中把需要处理的事务统一处理，处理事务是通过执行mTmpActions[i].run()进行的，这个mTmpActions[i]就是前面我们通过enqueueAction方法插入的BackStackRecord，童鞋们可能没注意到，它可是一个Runnable，我们来看看它的定义

final class BackStackRecord extends FragmentTransaction implements
FragmentManager.BackStackEntry, Runnable {
static final String TAG = FragmentManagerImpl.TAG;
… …
}

兜兜转转，我们又回到了BackStackRecord

1.3.10BackStackRecord#run

public void run() {

…

if (mManager.mCurState >= Fragment.CREATED) {
SparseArray firstOutFragments = new SparseArray();
SparseArray lastInFragments = new SparseArray();
calculateFragments(firstOutFragments, lastInFragments);
beginTransition(firstOutFragments, lastInFragments, false);
}
//遍历链表，根据cmd事务类型依次处理事务
Op op = mHead;
while (op != null) {
switch (op.cmd) {
case OP_ADD: {
Fragment f = op.fragment;
f.mNextAnim = op.enterAnim;
mManager.addFragment(f, false);
}
break;
case OP_REPLACE: {
Fragment f = op.fragment;
int containerId = f.mContainerId;
if (mManager.mAdded != null) {
for (int i = mManager.mAdded.size() - 1; i >= 0; i–) {
Fragment old = mManager.mAdded.get(i);
if (old.mContainerId == containerId) {
if (old == f) {
op.fragment = f = null;
} else {
if (op.removed == null) {
op.removed = new ArrayList();
}
op.removed.add(old);
old.mNextAnim = op.exitAnim;
if (mAddToBackStack) {
old.mBackStackNesting += 1;
}
mManager.removeFragment(old, mTransition, mTransitionStyle);
}
}
}
}
if (f != null) {
f.mNextAnim = op.enterAnim;
mManager.addFragment(f, false);
}
}
break;
case OP_REMOVE: {
Fragment f = op.fragment;
f.mNextAnim = op.exitAnim;
mManager.removeFragment(f, mTransition, mTransitionStyle);
}
break;
case OP_HIDE: {
Fragment f = op.fragment;
f.mNextAnim = op.exitAnim;
mManager.hideFragment(f, mTransition, mTransitionStyle);
}
break;
case OP_SHOW: {
Fragment f = op.fragment;
f.mNextAnim = op.enterAnim;
mManager.showFragment(f, mTransition, mTransitionStyle);
}
break;
case OP_DETACH: {
Fragment f = op.fragment;
f.mNextAnim = op.exitAnim;
mManager.detachFragment(f, mTransition, mTransitionStyle);
}
break;
case OP_ATTACH: {
Fragment f = op.fragment;
f.mNextAnim = op.enterAnim;
mManager.attachFragment(f, mTransition, mTransitionStyle);
}
break;
default: {
throw new IllegalArgumentException("Unknown cmd: " + op.cmd);
}
}