flutter生命周期

生命周期的基本概念：

一、什么是生命周期：
    1、生命周期是人家封装好的一套接口，然后提供的回调方法，当发生变化时，我们只需要取实现它。（按通俗的讲，就是回调方法（函数））。
    2、让你知道我封装好的这个widget它处于什么样的状态了！
二、那生命周期有什么作用
    1、监听Widget的事件
    2、初始化数据
        （1）、创建数据
        （2）、发送网络请求
    3、内存管理
        （1）、销毁数据、销毁监听者
        （2）、销毁Timer等等

接下来我们来看一下Widget的生命周期

首先我们来实现一下无状态的StatelessWidget的生命周期

代码

class MyHomePages extends StatelessWidget{
  final String title;
  MyHomePages({this.title}){
    print("构造函数被调用");
  }
  @override
  Widget build(BuildContext context) {
    // TODO: implement build
    print("build方法被调用了");
    return Center(
      child: Text(title),
    );
  }
}

然后执行程序，打印结果为

flutter: 构造函数被调用
flutter: build方法被调用了
flutter: 构造函数被调用
flutter: build方法被调用了
Application finished.

从上面的结果，可以看到打印了两次，那为什么会打印两次呢？
原因是as的bug，接下来我们用ios模拟器运行一下程序
你会发现它只打印了一次

2020-06-15 23:55:03.352660+0800 Runner[89125:1491460] flutter: 构造函数被调用
2020-06-15 23:55:03.831544+0800 Runner[89125:1491460] flutter: build方法被调用了

所以说这是android stido的bug，这个我们就不去管它了（也可以用终端运行程序，也只是运行一次，这边不再尝试了）。

从执行结果可以看出，在StatelessWidget的生命周期中，会调用一个构造方法和一个build方法。（StatelessWidget没有dispose方法）。

接下来来到有状态的StatefulWidget的生命周期

代码

class MyHomePages extends StatefulWidget{
  final String title;
  MyHomePages({this.title}){
    print('构造函数被调用了!');
  }
  @override
  _MyHomePageState createState() => _MyHomePageState();
}
class _MyHomePageState extends State<MyHomePages>{
  int _count = 0;

  _MyHomePageState(){
    print('State的构造方法');
  }
  @override
  void initState() {
    // TODO: implement initState
    super.initState();
    print('State的init方法');
  }
  @override
  Widget build(BuildContext context) {
    // TODO: implement build
    print('State的build方法');
    return Column(
      children: [
        RaisedButton(
            child:  Icon(Icons.add),
            onPressed: (){
          _count ++;
          setState(() {
          });
        }),
        Text('$_count'),
      ],
    );
  }
  @override
  void didChangeDependencies() {
    // TODO: implement didChangeDependencies
    print('didChangeDependencies');
    super.didChangeDependencies();
  }

  //当State对象从渲染树中移出的时候,就会调用!即将销毁!
  @override
  void deactivate() {
    // TODO: implement deactivate
    print('deactivate');
    super.deactivate();
  }

  @override
  void dispose() {
    // TODO: implement dispose
    super.dispose();
    print('State的dispose');
  }
}


打印结果:

flutter: 构造函数被调用了!
flutter: State的构造方法
flutter: State的init方法
flutter: didChangeDependencies
flutter: State的build方法

省略了as重复的调用

从上面的执行结果，我们可以看出，首先调用的是StatefulWidget的构造方法，然后通过createState调用State的构造方法；
顺序依次为:Widget的构造方法->Widget的createState方法->State的构造方法->State的initState方法->didChangeDependencies方法（改变依赖关系）->State的build方法->Widget销毁方法dispose。

而当我们点击按钮时，你会发现，程序只调用了State的build方法，因为在StatefulWidget中，状态管理都用通过setState重新渲染的，那么我们可以查看setState的源代码

15922379242714.png

上图中有很多断言，是用来筛选判断用的
我们看到_element.markNeedsBuild();这一行代码主要工作原理是通过标记需要重新构建的代码。那么element用来做什么的，在后面会详细介绍。
由此可以得出，这是一个增量渲染，widget的Render Tree会将旧数据与新数据进行比较，当数据发生变化时，会对更新的一部分进行重新渲染，未更新的就会不对它进行变化。那么element是做什么用的呢？我们点进去element的源码（BuildContext get context => _element;），可以看出，这个element就是一个context。

那么，我们如何去证明这个呢？
我们在build的方法里创建一个element变量

StatefulElement element = context;

将setState方法换成

element.markNeedsBuild();

得到的结果与用setState方法调用顺序一样。

flutter: 构造函数被调用了!
flutter: State的构造方法
flutter: State的init方法
flutter: didChangeDependencies
flutter: State的build方法
flutter: 构造函数被调用了!
flutter: State的build方法
flutter: State的build方法
flutter: State的build方法
flutter: State的build方法

但是呢，我们并不会这样用，因为这样不安全，只是告诉你们可以这样用。用setState会更安全。

当我们点击了按钮，count值发生了变化，可以看到State的build被调用了，因此可以得到结论，当setState方法被调用，build方法会重新渲染。

从上面的程序可以得到deactivate方法并没有调用，那是因为这个方法是当State对象从渲染树中移出的时候,就会调用!即将销毁!
这个方法你们可以用push去尝试一下，这边不再尝试。

这边来详细讲述一下didChangeDependencies这个方法。

在介绍之前，我们先总结一下StatelessWidget的生命周期：

Stateless:
1、构造方法
2、build方法
Stateful：
1、widget构造方法
2、widget的createState
3、state的构造方法
4、State的initState方法
5、didChangeDependencies方法（改变依赖关系，依赖的InheritedWidget发生变化之后，方法也会调用）
6、State的build（当调用setState方法，会重新调用build进行渲染）
7、当widget销毁的时候，调用State的dispose

在我们开发当中，如果需要层层传递参数时，我们通常会怎么去写，是每个类里面都创建一个参数，然后层层传递吗？这个方法是很麻烦的，那么我们就要用到一个InheritedWidget类来实现共享数据。

代码

class MyData extends InheritedWidget{
  MyData({this.data,Widget child}) : super(child:child);
  final int data;//需要在子Widget中共享数据！

  //提供一个方法让子Widget访问共享数据
  static MyData of(BuildContext context){
    return context.dependOnInheritedWidgetOfExactType<MyData>();
  }
    
更新通知，可以判断数据是否发生变化，如果发生变化，就更新数据
  @override
  bool updateShouldNotify(MyData oldWidget) {
    // TODO: implement updateShouldNotify
    return oldWidget.data != data;
  }
}

class InheritedDemo extends StatefulWidget{
  @override
  _InheritedDemoState createState() => _InheritedDemoState();
}

class _InheritedDemoState extends State<InheritedDemo>{
  int count = 1;

  @override
  Widget build(BuildContext context) {
    // TODO: implement build
  return MyData(
    data: count,
    child: Column(
      children: [
        Test1(),
        RaisedButton(
          child: Text('我是按钮'),
          onPressed: () => setState((){
            count++;
          }),
        ),
      ],
    ),
  );
  }
}


中间省略部分嵌套代码

class Test3 extends StatefulWidget{
//  final count;
//  Test3(this.count);
  @override
  _Test3State createState() => _Test3State();
}

class _Test3State extends State<Test3>{
  @override
  Widget build(BuildContext context) {
    // TODO: implement build
    return Text(MyData.of(context).data.toString());
  }

  @override
  void didChangeDependencies() {
    // TODO: implement didChangeDependencies
    print('didChangeDependencies');
    super.didChangeDependencies();
  }
}

当我们创建了一个MyData类继承InheritedWidget时，我们就可以在需要用到这个数据的类中使用这个数据，以此来实现数据的共享。这样就不需要通过层层嵌套去实现数据的传输。当我们点击按钮时，didChangeDependencies这个方法会调用。

那么会有疑问，MyData每次都是递增的，这个数值是怎么保持的？
注意：Widget是没有递增的，而渲染是递增渲染的，递增改变是值数据发生变化，渲染只渲染发生变化的一部分，但是widget是全部重新创建的一个对象，这个widget可以看成渲染界面的描述。

Widget渲染原理

下图是一个Widget树。

15923244969816.png

Widget是一个很不稳定的，一但重新build，就会重新渲染，这个是非常影响性能的。那么，Widget如何知道哪些数据是要重新渲染，而那些是不需要重新渲染的呢？
下面我们就介绍一下Render Tree。这歌Render是一个RenderObject，并不是所有widget都会变成RenderObject。
我们结合源码来看：
StatelessWidget和StatefulWidget都是继承自Widget，所以说像StatelessWidget，StatefulWidget是不会创建RenderObject。
因此可以得出结论，只有继承RenderObject的类才能创建RenderObject并加入到RenderObject树，例如Row，Column都是继承RenderObjectWidget，而我们点进去看RenderObjectWidget也是继承至widget。

部分Flex源代码下有一个createRenderObject对象

@override
  RenderFlex createRenderObject(BuildContext context) {
    return RenderFlex(
      direction: direction,
      mainAxisAlignment: mainAxisAlignment,
      mainAxisSize: mainAxisSize,
      crossAxisAlignment: crossAxisAlignment,
      textDirection: getEffectiveTextDirection(context),
      verticalDirection: verticalDirection,
      textBaseline: textBaseline,
    );
  }
  
  
  点击RenderFlex对象，RenderFlex又继承至RenderBox，点击RenderBox，又继承于RenderObject，所以说这是一个子类对象。
  
  class RenderFlex extends RenderBox with ContainerRenderObjectMixin<RenderBox, FlexParentData>,
                                        RenderBoxContainerDefaultsMixin<RenderBox, FlexParentData>,
                                        DebugOverflowIndicatorMixin {
  /// Creates a flex render object.
  ///
  /// By default, the flex layout is horizontal and children are aligned to the
  /// start of the main axis and the center of the cross axis.
  RenderFlex({
    List<RenderBox> children,
    Axis direction = Axis.horizontal,
    MainAxisSize mainAxisSize = MainAxisSize.max,
    MainAxisAlignment mainAxisAlignment = MainAxisAlignment.start,
    CrossAxisAlignment crossAxisAlignment = CrossAxisAlignment.center,
    TextDirection textDirection,
    VerticalDirection verticalDirection = VerticalDirection.down,
    TextBaseline textBaseline,
     }) : assert(direction != null),
       assert(mainAxisAlignment != null),
       assert(mainAxisSize != null),
       assert(crossAxisAlignment != null),
       _direction = direction,
       _mainAxisAlignment = mainAxisAlignment,
       _mainAxisSize = mainAxisSize,
       _crossAxisAlignment = crossAxisAlignment,
       _textDirection = textDirection,
       _verticalDirection = verticalDirection,
       _textBaseline = textBaseline {
    addAll(children);
  }
  

通过上面的源码，可以得到并不是所有的widget都会被独立渲染，只有继承RenderObjectWidget才会创建RenderObject对象。

而我们去查看RenderObjectWidget源码，会调用两个方法，一个是createElement(),一个是createRenderObject(BuildContext context),而createElement是一个十分重要的方法。

源码部分我就不展示了，直接上结论！

在flutter渲染流程中，有三颗重要的树，flutter是针对Render树进行渲染！
Widget树，Element树，Render树
一、每一个Widget都会创建一个Element对象
1、隐式的调用createElement方法，Element加入Element树种（它会创建三种Element）
二、RenderElement主要创建RenderOnject对象（继承RenderObjectWidget的Widget会创建RenderElement）
1、创建RenderElement
2、flutter会调用mount方法，调用createRenderObject方法
三、StatefulElement继承ComponentElement（StatefulWidget会创建StatefulElement）
1、调用createState，创建state
2、将widget赋值给state
3、调用State的build方法并且将自己的（element）传出去（build里面的context就是Widget的element！）
四、StatelessElement继承ComponentElement（StatelessWidget会创建StatelessElement）
1、主要就是调用build方法，并且将自己（element）传出去。

感谢大家观看，小白一个，欢迎大神纠错！