一、自己的理解

本质就是Fragment经由同一个FragmentManager以观察者模式的方式通信。

首先多个Fragment通过同一个实例做到观察者模式的通信。

其次Fragment都是由FragmentManager来管理的，Fragemnt的重建数据的保存等，各种机制都由FragmentManager控制，所以选择FragmentManager来当这个同一个实例是最合适不过。

所以一个经由同一个FragmentManager以观察者模式的方式通信就出现了。

二、使用

1.接收数据

FragmentManager.setFragmentResultListener(requestKey,lifecycleOwner,FragmentResultListener { requestKey: String, result: Bundle ->在这里可以通过requestKey的判断，来区别处理})

如果想在 Fragment 中接受数据，可以在 FragmentManager 中注册一个 FragmentResultListener，通过对 requestKey 的判断，区别处理 FragmentManager 发送的数据

setFragmentResultListener方法的参数中，携带着lifecycleOwner，它对生命周期进行了监听，只有在Started状态之后才能接收信息，并且对Started状态之前最后一次发送的数据有黏性，即Started之前发的最后一条消息，在Started状态之后会收到，当lifecycleOwner生命周期到销毁的时候会移除这个FragmentResultListener。

2.发送数据

FragmentManager.setFragmentResult(requestKey, bundleOf(key to value) 
)

注意事项：

通信的Fragment要使用同一个FragmentManager来接收和发送信息。

举例：

(1).如果在 FragmentA 中接收 FragmentB 发送的数据，FragmentA 和 FragmentB 处于相同的层级，它们的共同点是被上一层级的FragmentManager所控制，parentFragmentManager就是他俩的同一个实例的FragmentManager，所以他们都通过parentFragmentManager来通信。

(2).如果在 FragmentA 中接受 FragmentB 发送的数据，FragmentA 是 FragmentB 的父容器，那对于FragemntA来说它和FragemntB的共同的FragmentManager是A的childFragmentManager，对于FragmentB来说它和A的共同的FragmentManager是B的parentFragmentManager，所以A接收B的消息用childFragmentManager，B发送A的消息用parentFragmentManager

三、源码分析

1.发送数据

private final ConcurrentHashMap mResults = new ConcurrentHashMap<>();
private final ConcurrentHashMap mResultListeners =new ConcurrentHashMap<>();@Override
public final void setFragmentResult(@NonNull String requestKey, @Nullable Bundle result) {if (result == null) {// mResults 是 ConcurrentHashMap 的实例，用来存储数据传输的 Bundle// 如果传递的参数 result 为空，移除 requestKey 对应的 BundlemResults.remove(requestKey);return;}// Check if there is a listener waiting for a result with this key// mResultListeners 是 ConcurrentHashMap 的实例，用来储存注册的 listener// 获取 requestKey 对应的 listenerLifecycleAwareResultListener resultListener = mResultListeners.get(requestKey);if (resultListener != null && resultListener.isAtLeast(Lifecycle.State.STARTED)) {// 如果 resultListener 不为空，并且生命周期处于 STARTED 状态时，调用回调resultListener.onFragmentResult(requestKey, result);} else {// 否则保存当前传输的数据mResults.put(requestKey, result);}
}

我们看到这两个集合：

private final Map mResults =Collections.synchronizedMap(new HashMap());
private final Map mResultListeners =Collections.synchronizedMap(new HashMap());

就明白，这就是观察者模式保存观察者的地方，再看发送数据的方法， 果然就是通过requestKey来找到对应的观察者，然后调用onFragmentResult方法通知观察者。

注意当resultListener生命周期状态不到Started的时候，会先把数据保存mResults.put(requestKey, result);，在监听到生命周期状态到Started时，会取一次数据，然后这个mResults是一个map，所以只会保存最后一次put的数据，所以在Started生命周期前发送的最后一次数据，有黏性。

2.接收数据

private final ConcurrentHashMap mResultListeners =new ConcurrentHashMap<>();@Override
public final void setFragmentResultListener(@NonNull final String requestKey,@NonNull final LifecycleOwner lifecycleOwner,@Nullable final FragmentResultListener listener) {// mResultListeners 是 ConcurrentHashMap 的实例，用来储存注册的 listener// 如果传递的参数 listener 为空时，移除 requestKey 对应的 listenerif (listener == null) {mResultListeners.remove(requestKey);return;}// Lifecycle是一个生命周期感知组件，一般用来响应Activity、Fragment等组件的生命周期变化final Lifecycle lifecycle = lifecycleOwner.getLifecycle();// 当生命周期处于 DESTROYED 时，直接返回// 避免当 Fragment 处于不可预知状态的时，可能发生未知的问题if (lifecycle.getCurrentState() == Lifecycle.State.DESTROYED) {return;}// 开始监听生命周期LifecycleEventObserver observer = new LifecycleEventObserver() {@Overridepublic void onStateChanged(@NonNull LifecycleOwner source,@NonNull Lifecycle.Event event) {// 当生命周期处于 ON_START 时开始处理数据if (event == Lifecycle.Event.ON_START) {// 开始检查受到的数据Bundle storedResult = mResults.get(requestKey);if (storedResult != null) {// 如果结果不为空，调用回调方法listener.onFragmentResult(requestKey, storedResult);// 清除数据setFragmentResult(requestKey, null);}}// 当生命周期处于 ON_DESTROY 时，移除监听if (event == Lifecycle.Event.ON_DESTROY) {lifecycle.removeObserver(this);mResultListeners.remove(requestKey);}}};lifecycle.addObserver(observer);mResultListeners.put(requestKey, new FragmentManager.LifecycleAwareResultListener(lifecycle, listener));
}

Lifecycle是一个生命周期感知组件，一般用来响应Activity、Fragment等组件的生命周期变化
获取 Lifecycle 去监听 Fragment 的生命周期的变化
当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
当生命周期处于 ON_DESTROY 时，移除监听

如果大家看过我的Lifecycle源码分析的文章，就会很简单的看出来这就是一个简单的观察者模式。

四、小结

这种方式只能传递简单数据类型、Serializable 和 Parcelable 数据，Fragment result APIs 允许程序从崩溃中恢复数据，而且不会持有对方的引用，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题。

优点：

在 Fragment 之间传递数据，不会持有对方的引用
当生命周期处于 ON_START 时开始处理数据，避免当 Fragment 处于不可预知状态的时，可能发生未知的问题
当生命周期处于 ON_DESTROY 时，移除监听