Flutter查漏补缺1

Flutter 基础知识查漏补缺 Hot reload原理

热重载分为这几个步骤

• 扫描项目改动：检查是否有新增，删除或者改动，直到找到上次编译后发生改变的dart代码
• 增量编译：找到改变的dart代码，将其转化为增量支持动态编译的dart kernel
• 推送更新：热重载模块将增量更新的代码通过HTTP端口发送到在虚拟机上的Dart VM
• 代码合并：Dart Vm收到增量的dart kernel代码，将其与原有的dart vm代码合并，并加载新的dart kernel代码
• widget重建：在确认dart vm资源加载成功后，flutter会将Ui线程重置，通知flutter framework重建widget

Hot reload是debug下的JIT(Just In Time)动态编译模式，dart代码会被编译成可以在dart VM上的Dart kernel中间代码，而Dart kernel代码是支持动态更新的。
JIT由于包括了很多debug工具和中间层代码，所以性能没有AOT(Ahead Of Time)编译模式好，但是AOT编译需要花费大量时间，适合release版本，JIT虽然性能没有那么好，但是支持动态编译，所以适合debug模式

var、dynamic、final、const的区别

• var在创建时会推断变量的类型，并且确定之后无法再更改，dynamic是动态类型，可以随时更改类型，如下

//A value of type 'int' can't be assigned 
to a variable of type 'String'.
var a = 'String';
a = 1;
//成功运行
dynamic b = 'String';
b = 12;

• final是运行时常量，类型会在运行时确定，且只能赋值一次，const是编译时常量，类型在编译时确定，无法被赋值

//The final variable 'b' can only 
be set once.
final b = '';
b = '';
//Constant variables can't be 
assigned a value.
const a = '';
a = '';

??和??=的区别

?? 是给A赋值给B，如果A为null，就将??后面的值赋给B
??= 是如果A为空就将??=后面的值赋值给A

String? A;
String B = A ?? 'B';
A ??= 'A';

Dart中是值传递还是引用传递

基本类型值传递，类是引用传递

Widget 、 Element 、Render Object三者之间的联系 简单说一说，后面再继续总结

• Widget是“描述一个UI元素的配置信息”，并不是最终绘制在屏幕上的显示元素，所谓的配置信息就是Widget接收的参数，比如一个Text的配置信息就是文本内容，对齐方式，文本样式等。Widget有一些方法，比较重要的是@immutable，代表不可变的(final)，因为Flutter中如果发生属性改变机会重新构建Widget，会创建新的Widget实例替代老的Widget实例，所以Widget中的变量如果可变的话就没有任何意义。还有canUpdate方法，其作用是是否用新的Widget对象去更新旧UI树上Element对象的配置，如果新老Widget的runtimeType和key相同会返回true。Widget还有一个createElement方法来创建Element对象。
• 当新建一个Widget时，会创建一个Element对象，Element树的节点都继承自Element。
• 然后根据Element树生成Render树，也就是渲染树，渲染树的节点都继承自RenderObject。
• 根据渲染树生成Layer树，Layer树的节点都继承自Layer类。
• 而真正的绘制，渲染逻辑都是由渲染树完成。Element可以说是Widget和RenderObject的粘合剂。是Widget在整个UI树中的实例，UI树是由一个个独立的Element节点构成。Widget ==> Element ==> RenderObject。Element树根据Widget树生成，Render树又依赖于Element树。我们一般不会直接操纵Element，Flutter框架已经将Widget树映射到Element树上，极大的降低复杂度，提高开发效率。
• Widget和Element是一一对应的，但Element并不会和RenderObject一一对应。只有需要渲染的Widget才有对应的RenderObject节点。Layer树以后再总结。

总结

• 总结一下就是，Widget是我们通过代码创建的UI配置信息，Flutter框架通过遍历Widget树来创建Element树，Element树又根据需要渲染的Widget来创建renderObject树进行绘制和渲染等逻辑的操作。Widget负责管理配置信息，render负责渲染，Element是一个中间层，相当于一个大管家。当Widget配置信息改变时，通过比较Widget和老Widget的key和runtimeType来确定Element和renderObject是否需要重建，不需要重建的直接更新Element的属性就可以了，这样可以以最小的开销来更新renderObject，从而达到在Widget不断变化时达到高性能的渲染。这里面的知识点太多了，以后再来慢慢深究。

有关extends 、 implements 、 mixins

参考

• 书写顺序是extends(继承) ==> with(混入) ==> implements(实现)

abstract class

abstract class C {
  ///这是一个抽象方法因为没有实现
  c();

  ///这是一个抽象getter
  int get type;

  ///这个方法不会被强制重写因为他有实现
  cc() {}
}

///继承自抽象类的子类必须重写父类的抽象方法
class D extends C {
  @override
  c() {}

  @override
  int get type => 1;
}

implements

• implements是对接口的实现，当一个类implements另一个类时，会被强制重写其父类的方法。

class A {
  void a() {}
}

class B implements A {
  @override
  void a() {
    print('b a');
  }
}

mixins

• mixins可以被关联到另外一个class，为了重用代码但是又不用继承，需要用with关键字
• 一个类可以拥有无数个mixins，一旦将mixins混入了一个类，这个类就持有所有mixins的方法

mixin Run {
  void running() {}
  void same() {
    print('Run');
  }
}

mixin Walk {
  void walking() {}
  void same() {
    print('Walk');
  }
}

mixin Talk {
  void talking() {}
  void same() {
    print('Talk');
  }
}

///现在Man拥有talk，walk，run，并且如果多个mixin有同名方法，取最后的实现
class Man with Run, Walk, Talk {}

void main() {
  //打印talk
  Man().same();
  Man().running();
  Man().walking();
  Man().talking();
}

• mixins可以指定异常类型，用on关键字

class F {
  f() {}
}

mixin E on F {}

///G类想要混入E时，本身必须是实现了F接口或者继承于F或者继承于实现了F的类才能混入E
class G extends F with E {
  @override
  f() {}
}

//实现了F的类
class Gimp implements F {
  @override
  f() {}
}

class Gext extends Gimp with E {}

extends

Dart中的继承是单继承，子类重写父类的方法要用@override，不会强制重写父类的方法，子类调用父类的方法要用super

class Parent {
  work() {}
  study() {}
}

class Child extends Parent {
  @override
  work() {
    super.work();
    super.study();
  }
}

关于Dart单线程模型

Dart是单线程语言，所有的main函数中的代码都是在一个main isolate中完成的。我们一般的异步操作，实际上是通过单线程异步调度任务有优先级完成的，也就是所谓的Future。为了保证较高的响应性，一般特别耗时的任务都会重开一个isolate来执行，执行完成之后通过isolate之间的通信返回结果到main isolate中。

Dart事件机制

dart中有两个任务队列，Micotask queue和event queue，isolate中的代码是按顺序执行的

• 首先执行main函数中的代码。

• 执行完main函数中代码后，会检查并执行Microtask queue中的任务，通常使用scheduleMicrotask向Microtask queue添加任务。

• 最后执行Event queue队列中的代码，通常使用Future向队列中添加任务，或者使用async await方式添加。

• 总结:Main ==> Microtask queue ==> Event queue

Future的.then方法会将其中的代码放入Microtask队列，在Future执行完毕后立即执行，因为Microtask队列优先级更高。

下面用一段代码来验证执行顺序

void main() {
  print('main 1');
  new Future(() => print('future 1'));
  scheduleMicrotask(() => print('micro 1'));
  new Future(() => print('future 2'));
  scheduleMicrotask(() => print('micro 2'));
  print('main 2');
}

//打印
main 1
main 2
micro 1
micro 2
future 1
future 2
Exited

Stream和Future

Stream和Future都是dart中用来处理异步事件的，Future表示稍后处理一个事件。区别在于Future只能处理单个异步事件，stream是处理一系列异步事件流。Stream详细在前几篇博文中可以找到，这里不再赘述。
需要补充的是，await可以等待当前异步操作完成，await for就是等待当前异步事件流(stream)完成，并可以通过yield返回每一个异步事件的结果。

其实await并不会阻塞main函数中的代码，它具体的实现是，当dart执行到有await的地方时，将整个Future函数返回为一个Future对象，放入Event队列中稍后异步执行，而await后面的代码才会跟着一起执行完毕。这一切都是在main中的代码都执行完毕之后完成的。

await for 示例

awaitFor() async {
  print('awaitFor begin');
  await for (var item in Stream.fromIterable([1, 2, 3])) {
    print(item);
  }
  print('awaitFor end');
}

//打印
awaitFor begin
1
2
3
awaitFor end
Exited

StatefulWidget的生命周期

initState

当此对象插入树中时调用。
框架将为其创建的每个 [State] 对象调用此方法一次。

此时State对象还没有和context绑定，通常拿来做一些初始化操作。比如事件监听，channel初始化

didChangeDependencies

当此 [State] 对象的依赖项发生更改时调用。

例如，如果上一次调用 [build] 引用了后来更改的 [InheritedWidget]，则框架将调用此方法以通知此对象有关更改的信息。

此方法也会在 [initState] 之后立即调用。从此方法调用 [BuildContext.dependOnInheritedWidgetOfExactType] 是安全的。

在initState之后理解调用，此时已经和context绑定，可以拿来初始化一些和基于context的内容，当有依赖改变时，也会调用此方法通知更改信息

didUpdateWidget

每当小组件配置更改时调用。

如果父小组件重新生成并请求更新树中的此位置以显示具有相同 [runtimeType] 和 [Widget.key] 的新小部件，则框架将更新此 [State] 对象的 [widget] 属性以引用新小部件，然后使用以前的小部件作为参数调用此方法。

框架总是在调用[didUpdateWidget]之后调用[build]，这意味着在[didUpdateWidget]中对[setState]的任何调用都是多余的。

如果 [State] 的 [build] 方法依赖于本身可以更改状态的对象，例如 [ChangeNotifier] 或 [Stream]，或者可以订阅以接收通知的其他对象，请确保在 [initState]、[didUpdateWidget] 和 [dispose] 中正确订阅和取消订阅

当父组件有改变时，此方法会调用，并且通过旧的小组件生成新的小组件，在调用此方法后会立即调用build方法，如果有stream或者ChangeNotifier，确保在didUpdateWidget方法中取消订阅

build

描述此小组件所表示的用户界面部分。

该框架在许多不同的情况下调用此方法。例如：

• 调用 [initState] 之后。

• 在调用 [didUpdateWidget] 之后。

• 在接到对 [setState] 的调用后。

• 在此 [State] 对象的依赖项发生更改（例如，先前的 [build] 更改所引用的 [InheritedWidget] 之后。

• 调用 [停用]，然后将 [State] 对象重新插入到树中的其他位置后。

构造界面方法，在一些其他时候会调用，比如didChangeDependencies，didUpdateWidget，setState等

deactivate

每当框架从树中删除此 [State] 对象时，它都会调用此方法。在某些情况下，框架会将 [State] 对象重新插入到树的另一部分（例如，如果包含此 [State] 对象的子树由于使用了 [GlobalKey] 而从树中的一个位置移植到另一个位置）。

如果发生这种情况，框架将调用[激活]，以使[State]对象有机会重新获取它在[停用]中释放的任何资源。然后，它还将调用 [build]，以使 [State] 对象有机会适应其在树中的新位置。

当移出Widget tree时调用，如果框架将State对象再次插入Widget tree时，调用build方法

dispose

从树中永久删除此对象时调用。

当此 [State] 对象永远不会再次生成时，框架将调用此方法。在框架调用 [dispose] 之后，[State] 对象被视为未装载，并且 [mounted] 属性为 false。此时调用 [setState] 是错误的。生命周期的此阶段是终端阶段：无法重新挂载已释放的 [State] 对象。

对象被销毁时调用，比如路由中的pop操作，此时可用来释放资源，例如AnimationController，StreamController等，如果此对象由于某些延时操作导致在销毁后调用setState，会抛出异常，建议用if(mounted)判断是否还在当前页面

Key

Flutter中有LocalKey和GolbalKey两种形式的key，key是用来指明widget身份的唯一标识符

LocalKey

• ValueKey

value类型为文本，当有widget内容是恒定且不同的，可以用ValueKey来指定，不会产生混淆

• ObjectKey

如果说WIdget拥有更复杂的数据结构，比如一个用户信息的地址簿应用。任何单个字段（如名字或生日）可能与另一个条目相同，但是每一个数据组合是唯一的，此时就更适合使用ObjectKey

• UniqueKey

如果集合中拥有多个相同值的Widget，或者想确保每个Widget和Widget都是不同的就可以使用UniqueKey

GlobalKeys

允许 Widget 在应用中的任何位置更改父级而不会丢失 State ，或者可以使用它们在 Widget 树 的完全不同的部分中访问有关另一个 Widget 的信息。

代码示例

import 'package:flutter/material.dart';

class PageA extends StatefulWidget {
  const PageA({Key? key}) : super(key: key);

  @override
  State<PageA> createState() => _PageAState();
}

class _PageAState extends State<PageA> {
  //创建一个_PageBState类型的GlobalKey
  final GlobalKey<_PageBState> akey = GlobalKey();
  pagea() {}
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      body: PageB(key: akey),
      floatingActionButton: TextButton(
        onPressed: () {
          //可以通过此key的currentState调用_PageBState的pageb方法
          akey.currentState!.pageb();
        },
        child: Text('text'),
      ),
    );
  }
}

class PageB extends StatefulWidget {
  const PageB({Key? key}) : super(key: key);

  @override
  State<PageB> createState() => _PageBState();
}

class _PageBState extends State<PageB> {
  //同理创建一个_PageAState类型的GlobalKey
  final GlobalKey<_PageAState> bkey = GlobalKey();
  pageb() {}
  @override
  Widget build(BuildContext context) {
    return Scaffold(
      floatingActionButton: TextButton(
        onPressed: () {
           //一样可以通过此key的currentState调用_PageAState的pagea方法
          bkey.currentState!.pagea();
        },
        child: Text('text'),
      ),
    );
  }
}

什么是Navigator? MaterialApp做了什么

Navigator是在Flutter中负责管理维护页面堆栈的导航器。MaterialApp在需要的时候，会自动为我们创建Navigator。Navigator.of(context)，会使用context来向上遍历Element树，找到MaterialApp提供的_NavigatorState再调用其push/pop方法完成导航操作。

全局Error捕获和处理

参考

Flutter 框架可以捕获运行期间的错误，包括构建期间、布局期间和绘制期间。
所有 Flutter 的错误均会被回调方法 FlutterError.onError 捕获。默认情况下，会调用 FlutterError.dumpErrorToConsole 方法，正如方法名表示的那样，将错误转储到当前的设备日志中。当从 IDE 运行应用时，检查器重写了该方法，错误也被发送到 IDE 的控制台，可以在控制台中检查出错的对象。
当构建期间发生错误时，回调函数 ErrorWidget.builder 会被调用，来生成一个新的 widget，用来代替构建失败的 widget。默认情况，debug 模式下会显示一个红色背景的错误页面， release 模式下会展示一个灰色背景的空白页面。
如果在调用堆栈上没有 Flutter 回调的情况下发生错误（这里可以理解为FlutterError.onError仅仅可以捕获主线程的错误，而其他异步线程的错误则需要Zone来捕获），它们由发生区域的 Zone 处理。 Zone 在默认情况下仅会打印错误，而不会执行其他任何操作。
这些回调方法都可以被重写，通常在 void main() 方法中重写。
下面来看看如何处理。

捕获Flutter错误

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';

void main() {
  FlutterError.onError = (FlutterErrorDetails details) {
    FlutterError.dumpErrorToConsole(details);
    if (kReleaseMode) {
      //处理线上错误，如统计上传
    }
  };
  runApp(MyApp());
}

上面我们重写了FlutterError.onError，这样就可以捕获到错误，第一行代码就是将error展示到控制台，这样我开发时就会在控制台很方便的看到错误。下面代码就是在线上环境下，对错误进一步处理，比如统计上传。

自定义error widget

上面我们知道，构建时发生错误会默认展示一个错误页面，但是这个页面很不友好，我们可以自定义一个错误页面。定义一个自定义的 error widget，以当 builder 构建 widget 失败时显示，请使用 MaterialApp.builder。

class MyApp extends StatelessWidget {
  const MyApp({Key? key}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      builder: (context, child) {
        Widget error = Text('rendering error');
        if (child is Scaffold || child is Navigator) {
          error = Scaffold(body: Center(child: error));
        }
        ErrorWidget.builder = (FlutterErrorDetails errorDetails) => error;
        return error;
      },
    );
  }
}

无法捕获的错误

假设一个 onPressed 回调调用了异步方法，例如 MethodChannel.invokeMethod (或者其他 plugin 的方法)

如果 invokeMethod 抛出了错误，它不会传递至 FlutterError.onError，而是直接进入 runApp 的 Zone。

如果你想捕获这样的错误，请使用 runZonedGuarded。代码如下

void main() {
  runZonedGuarded(() {
    runApp(MyApp());
  }, (Object object, StackTrace stackTrace) {
    //处理错误
  });
}

请注意，如果你的应用在 runApp 中调用了 WidgetsFlutterBinding.ensureInitialized() 方法来进行一些初始化操作（例如 Firebase.initializeApp()），则必须在 runZonedGuarded 中调用 WidgetsFlutterBinding.ensureInitialized()：

void main() {
  runZonedGuarded(() {
    WidgetsFlutterBinding.ensureInitialized();
    await Firebase.initializeApp();
    runApp(MyApp());
  }, (Object object, StackTrace stackTrace) {
    //处理错误
  });
}

Flutter的线程管理模型

默认情况下，Flutter会创建一个主isolate，并且dart代码会默认在这个isolate中执行，必要时可以通过isolate.spawn或者solate.spawnUri来创建新的isolate(注：Flutter中不支持isolate.spawnUri)，新建的isolate由Flutter统一管理。

事实上，Flutter并不会管理线程，线程的创建和管理是通过比Flutter引擎更底层的Embeder层负责的，Embeder层是将引擎移植在平台的中间层代码，Flutter Engine层架构如下图

Embeder层提供四个Task Runner，分别是platform task runner，UI task runner，GPU task runner，I/O task runner，Flutter Engine并不关心task runner运行在哪个线程，只关心线程在整个生命周期内保持稳定。