InheritedWidget原理浅析

定义和用法

本文只对InheritedWidget进行分析，需要读者具备一些基础知识，包括但不限于：

1. Flutter的基本知识；
2. Widget、Element的关系

一个可以高效的沿着树高效传递信息的基础Widget。
用户可使用BuildContext.dependOnInheritedWidgetOfExactType获取最近特定类型的InheritedWidget实例，之后每当被引用的InheritedWidget自身状态发生变化时，会导致引用者重新build。

按照官方教程，粗略的提一下用法（此处不再赘述详细的用法，可参考数据共享（InheritedWidget））：

• 首先定义一个InheritedWidget类型的Widget：

//官方Demo
class FrogColor extends InheritedWidget {
   const FrogColor({
     Key key,
     @required this.color,
     @required Widget child,
   }) : assert(color != null),
        assert(child != null),
        super(key: key, child: child);

   final Color color;

   static FrogColor of(BuildContext context) {
     return context.dependOnInheritedWidgetOfExactType<FrogColor>();
   }

   @override
   bool updateShouldNotify(FrogColor old) => color != old.color;
}

• 将该Widget作为普通Widget添加到Widget树中；
• 在其任一子Widget中使用FrogColor.of(context).color即可获得color信息。

要想做到子Widget数据刷新，有两个关键点：

1. 子Widget如何如何跨Widget拿到InheritedWidget
2. InheritedWidget如何在数据改变时通知子Widget刷新（build）

这两点就是InheritedWidget的核心和关键所在，接下来我们对着两个问题进行分析：

InheritedWidget在树中的传递

在上面的示例代码中，子Widget中唯一可见和InheritedWidget发生关联的代码就是FrogColor.of(context).color。其中的关键方法是dependOnInheritedWidgetOfExactType，该方法在BuildContext中定义，并在Element中有具体实现。查看BuildContext.dependOnInheritedWidgetOfExactType在Element中的源码如下：

Map<Type, InheritedElement> _inheritedWidgets;

@override
T dependOnInheritedWidgetOfExactType<T extends InheritedWidget>({Object aspect}) {
  assert(_debugCheckStateIsActiveForAncestorLookup());
  final InheritedElement ancestor = _inheritedWidgets == null ? null : _inheritedWidgets[T];
  if (ancestor != null) {
    assert(ancestor is InheritedElement);
    return dependOnInheritedElement(ancestor, aspect: aspect) as T;
  }
  _hadUnsatisfiedDependencies = true;
  return null;
}

可以看到，每个Element实例都持有一个_inheritedWidgets，每当要为Widget添加特定类型的依赖时，就会从该集合里取出相关类型的InheritedElement实例。那么_inheritedWidgets是在何时保存了InheritedElement的呢？
接下来继续看Element源码，查看_inheritedWidgets在何时赋值。
在element中有一个_updateInheritance方法：

void _updateInheritance() {
    assert(_active);
    _inheritedWidgets = _parent?._inheritedWidgets;
}

它在mount和activate函数执行时被调用。也就是说每次element挂载和重新启用时，element都会从它的上层element中打包拿到其所持有的所有InheritedElement。
InheritedElement继承了Element，并重写了_updateInheritance方法：

@override
void _updateInheritance() {
  assert(_active);
  final Map<Type, InheritedElement> incomingWidgets = _parent?._inheritedWidgets;
  if (incomingWidgets != null)
    _inheritedWidgets = HashMap<Type, InheritedElement>.from(incomingWidgets);
  else
    _inheritedWidgets = HashMap<Type, InheritedElement>();
  _inheritedWidgets[widget.runtimeType] = this;
}

相较于普通的Element，InheritedElement不仅会拿到其上层element所有的InheritedElement，而且会将自己也作为一个元素添加到集合中。
不难看出，每个Element都会持有一个集合，该集合持有其上层Element中出现的所有InheritedElement，每当出现一个InheritedElement，该InheritedElement会将其自身添加到该集合中，并向下传递。InheritedWidget正是通过这种方法确保下层控件可以访问到其上层中所有的InheritedWidget。

InheritedWidget如何进行刷新

当InheritedWidget的状态发生变化时，它是如何通知相关子树进行刷新呢，我们继续分析dependOnInheritedWidgetOfExactType方法的代码，当从_inheritedWidgets中能取出特定类型的实例ancestor时。会执行dependOnInheritedElement方法：

@override
InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object aspect }) {
  assert(ancestor != null);
  _dependencies ??= HashSet<InheritedElement>();
  _dependencies.add(ancestor);
  ancestor.updateDependencies(this, aspect);
  return ancestor.widget;
}

InheritedElement实例会调用自己的updateDependencies方法并将当前Element实例传递过去：

final Map<Element, Object> _dependents = HashMap<Element, Object>();

@protected
void updateDependencies(Element dependent, Object aspect) {
  setDependencies(dependent, null);
}

@protected
void setDependencies(Element dependent, Object value) {
  _dependents[dependent] = value;
}

InheritedElement中，通过_dependents集合保存所有与该实例发生依赖的Widget。每次有Widget与InheritedElement建立依赖关系时，都会讲自己添加到InheritedElement的集合中。而当InheritedElement更新时，会执行实例上的 notifyClients：

@override
void notifyClients(InheritedWidget oldWidget) {
  assert(_debugCheckOwnerBuildTargetExists('notifyClients'));
  for (final Element dependent in _dependents.keys) {
    assert(() {
      // check that it really is our descendant
      Element ancestor = dependent._parent;
      while (ancestor != this && ancestor != null)
        ancestor = ancestor._parent;
      return ancestor == this;
    }());
    // check that it really depends on us
    assert(dependent._dependencies.contains(this));
    //遍历所有的element
    notifyDependent(oldWidget, dependent);
  }
}
@protected
void notifyDependent(covariant InheritedWidget oldWidget, Element dependent) {
  //依次调用所有子element的didChangeDependencies方法
  dependent.didChangeDependencies();
}

在element的didChangeDependencies方法中会调用markNeedsBuild方法，该方法会将标记当前元素，并在下一帧到来时重新创建Widget，具体实现原理已经脱离InheritedWidget的知识范畴，这里不再进行讨论。

总结

InheritedWidget的关键核心是两个集合。通过一个沿树自上而下传递的集合存储所有上层组件中的InheritedWidget，以便Widget可以拿到任意上层树种的InheritedWidget。而在InheritedWidget则通过一个集合持有所有的依赖元素，每当有元素与其发生依赖关系，该元素就被被添加入集合中。当InheritedWidget的状态发生改变时，将遍历该集合并执行每个元素的didChangeDependencies方法。