R1cardo

R1cardo

关注
发信
关注(28)粉丝(399)

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事件机制

Flutter查漏补缺1-LMLPHP

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

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

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

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

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

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

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 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的生命周期

Flutter查漏补缺1-LMLPHP

initState

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

didChangeDependencies

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

didUpdateWidget

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

build

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

deactivate

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

dispose

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

Key

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

LocalKey

  • ValueKey
  • ObjectKey
  • UniqueKey

GlobalKeys

代码示例

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错误

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;
      },
    );
  }
}

无法捕获的错误

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

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层架构如下图

Flutter查漏补缺1-LMLPHP

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

03-27 20:02
Powered by LMLPHP ©2024 R1cardo 0.074655