FlutterDojo设计之道—状态管理之路（六）-低调大师

FlutterDojo设计之道—状态管理之路（六）

2020-09-14 944

经过前面这么多文章的学习，Flutter的状态管理之路终于要接近尾声了。

其实前面讲了这么多，最后的结论依然是——Provider真香。这毕竟是官方推荐的状态管理方案，就目前而言，绝大部分的场景都可以使用Provider来进行状态管理，同时也基本上是最佳方案。

Google的风格还真是这样，先不给出任何指定方案，大家百花齐放，最后选一个好一点的改改，这就成了官方方案！

但是我们为什么还要讲这么多其它的状态管理方案呢？实际上并不多，大家再去翻阅下前面的文章就可以发现，我讲的都是Flutter中的原生方案，关于第三方的Redux、scope_model等方案，其实我也没有涉及，其原因就是希望读者能够从根本原理上来了解「什么是状态管理」、「怎么进行状态管理」以及「状态管理各种方案的优缺点」，只有了解了这些，再使用Provider进行状态管理，就不仅仅是调用API这么简单了，你会对其根源有所了解，这才是本系列文章的核心所在。

Provider是Flutter官方提供的状态管理解决方案，其基本原理是InheritedWidget，Pub地址如下所示。

https://github.com/rrousselGit/provider

引入

Provider的迭代很快，目前最新版本是4.x，在pubspec.yaml中添加Provider的依赖，代码如下所示。

dependencies:
  flutter:
    sdk: flutter

  # The following adds the Cupertino Icons font to your application.
  # Use with the CupertinoIcons class for iOS style icons.
  cupertino_icons: ^0.1.2
  provider: ^4.3.2+1

执行pub get之后，即可更新Provider库。

Provider的核心实际上就是InheritedWidget，它实际上是对InheritedWidget的封装，让InheritedWidget在数据管理上能够更加方便的被开发者所使用。

所以，如果你的InheritedWidget比较熟悉，那么在使用Provider的时候，你一定会有一种似曾相识的感觉。

创建DataModel

在使用Provider之前，首先需要对Model进行下处理，通过mixin，为Model提供notifyListeners的能力。

class TestModel with ChangeNotifier {
  int modelValue;

  int get value => modelValue;

  TestModel({this.modelValue = 0});

  void add() {
    modelValue++;
    notifyListeners();
  }
}

在这个Model中，管理了需要共享的数据，同时，提供了修改数据的方法，唯一不一样的是，在修改数据后，需要通过ChangeNotifier提供的notifyListeners()来刷新数据。

ChangeNotifierProvider

使用ChangeNotifierProvider，维护需要管理的数据，代码如下。

class ProviderState1Widget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => TestModel(modelValue: 1),
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            ChildWidget1(),
            SizedBox(height: 24),
            ChildWidget2(),
          ],
        ),
      ),
    );
  }
}

通过ChangeNotifierProvider的create函数，创建初始化的Model。同时创建其Child，这个风格和InheritedWidget是不是有异曲同工之妙。

Provider提供了很多不同类型的Provider，这里先只用了解ChangeNotifierProvider

管理数据之Provider.of

通过Provider管理的数据，可以通过Provider.of<TestModel>(context);来读取数据，代码如下所示。

var style = TextStyle(color: Colors.white);

class ChildWidget1 extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    debugPrint('ChildWidget1 build');
    var model = Provider.of<TestModel>(context);
    return Container(
      color: Colors.redAccent,
      height: 48,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: <Widget>[
          Text('Child1', style: style),
          Text('Model data: ${model.value}', style: style),
          RaisedButton(
            onPressed: () => model.add(),
            child: Text('add'),
          ),
        ],
      ),
    );
  }
}

还可以通过model来获取操作数据的方法add()。

效果如图所示。

这样就完成了一个最简单的Provider使用方法。

但是通过日志可以发现，每次调用Provider.of<TestModel>(context);后，都会导致Context所处的Widget执行Rebuild。

I/flutter (18490): ChildWidget2 build
I/flutter (18490): ChildWidget1 build

是不是又似曾相识？是的，这就是前面文章中所提到的dependOnInheritedWidgetOfExactType的问题，它会对调用者进行记录，在数据更新时，对数据进行rebuild操作。

另外，上面的例子中，实际上还隐藏了一个很容易被初学者忽视的问题，我们来看下这段代码。

RaisedButton(
  onPressed: () => model.add(),
  child: Text('add'),
),

在button的点击事件中，我们并没有直接使用每次调用Provider.of<TestModel>(context).add()，而是将每次调用Provider.of<TestModel>(context)抽取了出来，为什么要多此一举呢？

其实大家可以尝试下这样调用，点击后，会报错，如下所示。

Tried to listen to a value exposed with provider, from outside of the widget tree.

This is likely caused by an event handler (like a button's onPressed) that called
Provider.of without passing `listen: false`.

To fix, write:
Provider.of<TestModel>(context, listen: false);

It is unsupported because may pointlessly rebuild the widget associated to the
event handler, when the widget tree doesn't care about the value.

简单的说，就是在button的event handler中，触发了Provider.of，但是这个时候，传入的Context并不在Widget中，导致notifyListeners出错。

解决方法有两个，一个就是将Provider.of抽取出来，用Widget的Context来获取Model，另一个呢，就是通过Provider.of的另一个参数来去掉监听的注册。

RaisedButton(
  onPressed: () => Provider.of<TestModel>(context, listen: false).add(),
  child: Text('add'),
),

通过listen: false，去掉默认注册的监听。

Provider.of的默认实现中，listen = true，至于为什么，大家可以看这里的讨论。https://github.com/rrousselGit/provider/issues/188#issuecomment-526259839 https://github.com/rrousselGit/provider/issues/313#issuecomment-576156922

因此，我们总结了两条Provider的使用规则。

Provider.of<T>(context)：用于需要根据数据的变化而自动刷新的场景
Provider.of<T>(context, listen: false)：用于只需要触发Model中的操作而不关心刷新的场景

因此对应的，在新版本的Provider中，作者还提供了两个Context的拓展函数，来进一步简化调用。

T watch<T>()
T read<T>()

他们就分别对应了上面的两个使用场景，所以在上面的示例中，Text获取数据的方式，和在Button中点击的方式还可以写成下面这张形式。

Text('watch: ${context.watch<TestModel>().value}', style: style)

RaisedButton(
  onPressed: () => context.read<TestModel>().add(),
  child: Text('add'),
),

代码地址 Flutter Dojo-Backend-ProviderState1Widget

管理数据之Consumer

获取Provider管理的数据Model，有两种方式，一种是通过Provider.of<T>(context)来获取，另一种，是通过Consumer来获取，在设计Consumer时，作者给它赋予了两个功能。

当传入的BuildContext中，不存在指定的Provider时，Consumer允许我们从Provider中的获取数据（其原因就是Provider使用的是InheritedWidget，所以只能遍历父Widget，当指定的Context对应的Widget与Provider处于同一个Context时，就无法找到指定的InheritedWidget了）
提供更加精细的数据刷新范围，避免无谓的刷新

创建新的Context环境

首先，我们来看下第一个功能。

@override
Widget build(BuildContext context) {
  return ChangeNotifierProvider(
    create: (_) => TestModel(modelValue: 1),
    child: Center(
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Container(
          color: Colors.redAccent,
          height: 48,
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: <Widget>[
              Text('Child1', style: style),
              Text('Model data: ${Provider.of<TestModel>(context).value}', style: style),
              RaisedButton(
                onPressed: () => Provider.of<TestModel>(context, listen: false).add(),
                child: Text('add'),
              ),
            ],
          ),
        ),
      ),
    ),
  );
}

在上面的这个例子中，ChangeNotifierProvider和使用Provider的Widget，使用的是同一个Context，所以肯定是无法找到对应的InheritedWidget的，所以会报错。

The following ProviderNotFoundException was thrown building ProviderState2Widget(dirty):
Error: Could not find the correct Provider<TestModel> above this ProviderState2Widget Widget

This likely happens because you used a `BuildContext` that does not include the provider
of your choice. There are a few common scenarios:

- The provider you are trying to read is in a different route.

  Providers are "scoped". So if you insert of provider inside a route, then
  other routes will not be able to access that provider.

- You used a `BuildContext` that is an ancestor of the provider you are trying to read.

  Make sure that ProviderState2Widget is under your MultiProvider/Provider<TestModel>.
  This usually happen when you are creating a provider and trying to read it immediately.

解决方法也很简单，一个是将需要使用Provider的Widget抽取出来，放入一个新的Widget中，这样在这个Widget中，就有了属于自己的Context，另一种，就是通过Consumer，来创建一个新的Context环境，代码如下所示。

@override
Widget build(BuildContext context) {
  return ChangeNotifierProvider(
    create: (_) => TestModel(modelValue: 1),
    child: Center(
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Container(
          color: Colors.redAccent,
          height: 48,
          child: Consumer<TestModel>(
            builder: (BuildContext context, value, Widget child) {
              return Row(
                mainAxisAlignment: MainAxisAlignment.spaceEvenly,
                children: <Widget>[
                  Text('Child1', style: style),
                  Text('Model data: ${value.value}', style: style),
                  RaisedButton(
                    onPressed: () => Provider.of<TestModel>(context, listen: false).add(),
                    child: Text('add'),
                  ),
                ],
              );
            },
          ),
        ),
      ),
    ),
  );
}

控制更加精细的刷新范围

来看下下面这个例子。

class ProviderState2Widget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => TestModel(modelValue: 1),
      child: NewWidget(),
    );
  }
}

class NewWidget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return Center(
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Container(
          color: Colors.redAccent,
          height: 48,
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: <Widget>[
              Text('Child1', style: style),
              Text('Model data: ${Provider.of<TestModel>(context).value}', style: style),
              RaisedButton(
                onPressed: () => Provider.of<TestModel>(context, listen: false).add(),
                child: Text('add'),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

在调用Provider.of的时候，会造成Context范围内的Widget执行Rebuild，这个在前面的例子中，已经看过了。那么要解决这个问题，也很简单，只需要将需要刷新的Widget，用Consumer包裹即可，这样在收到notifyListeners时，就只有Consumer范围内的Widget会进行刷新了，其它范围的地方，就不会被迫刷新了。在Consumer的builder中，可以获取指定泛型的数据对象，代码如下所示。

@override
Widget build(BuildContext context) {
  return Center(
    child: Padding(
      padding: const EdgeInsets.all(8.0),
      child: Container(
        color: Colors.redAccent,
        height: 48,
        child: Row(
          mainAxisAlignment: MainAxisAlignment.spaceEvenly,
          children: <Widget>[
            Text('Child1', style: style),
            Consumer<TestModel>(
              builder: (BuildContext context, value, Widget child) {
                return Text(
                  'Model data: ${value.value}',
                  style: style,
                );
              },
            ),
            RaisedButton(
              onPressed: () => Provider.of<TestModel>(context, listen: false).add(),
              child: Text('add'),
            ),
          ],
        ),
      ),
    ),
  );
}

代码地址 Flutter Dojo-Backend-ProviderState2Widget

那么Consumer究竟是为什么可以实现更加精细的刷新控制呢？其实原理很简单，前面甚至已经提到了，那就是「在调用Provider.of的时候，会造成Context范围内的Widget执行Rebuild」，所以，只需要将调用的范围尽可能的缩小，那么执行Rebuild的范围就会越小，看下Consumer的源码。

可以发现，Consumer就是通过一个Builder，来进行了一层封装，最终还是调用的Provider.of<T>(context)，看了源码之后，相信大家应该能理解Consumer的这两个功能了。

more Consumer

Consumer中存在多个类型的变种，它代表着使用多个数据模型的数据获取方式，如图所示。

其实说简单点，就是在一个Consumer的builder中，同时获取多个不同类型的数据模型，是一种简单的写法，是一种将嵌套的过程打平的过程。源码中只写到Consumer6，即支持同时最多6个数据类型，如果要支持更多，则需要自己实现了。

管理数据之Selector

Selector同样是获取数据的一种方式，从理论上来说，Selector等于Consumer等于Provider.of，但是它们对数据的控制粒度，才是它们之间根本的区别。

获取数据的方式，从Provider.of，到Consumer，再到Selector，实际上经历了这样一种进化。

Provider.of：Context内容进行Rebuild
Consumer：Model内容变化进行Rebuild
Selector：Model中的指定内容变化进行Rebuild

可以发现，虽然都是获取数据，但是其控制的精细程度确是递增的。

下面就通过一个例子，来演示下Selector的使用场景。

首先，我们定义一个数据模型，代码如下所示。

class TestModel with ChangeNotifier {
  int modelValueA;
  int modelValueB;

  int get valueA => modelValueA;

  int get valueB => modelValueB;

  TestModel({this.modelValueA = 0, this.modelValueB = 0});

  void addA() {
    modelValueA++;
    notifyListeners();
  }

  void addB() {
    modelValueB++;
    notifyListeners();
  }
}

在这个数据模型中，管理了两个类型的数据，modelValueA和modelValueB。

下面是展示界面。

class ProviderState3Widget extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return ChangeNotifierProvider(
      create: (_) => TestModel(modelValueA: 1, modelValueB: 1),
      child: Padding(
        padding: const EdgeInsets.all(8.0),
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: <Widget>[
            ChildWidgetA(),
            SizedBox(height: 24),
            ChildWidgetB(),
          ],
        ),
      ),
    );
  }
}

var style = TextStyle(color: Colors.white);

class ChildWidgetA extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    debugPrint('ChildWidgetA build');
    var model = Provider.of<TestModel>(context);
    return Container(
      color: Colors.redAccent,
      height: 48,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: <Widget>[
          Text('ChildA', style: style),
          Text('Model data: ${model.valueA}', style: style),
          RaisedButton(
            onPressed: () => model.addA(),
            child: Text('add'),
          ),
        ],
      ),
    );
  }
}

class ChildWidgetB extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    debugPrint('ChildWidgetB build');
    var model = Provider.of<TestModel>(context);
    return Container(
      color: Colors.blueAccent,
      height: 48,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: <Widget>[
          Text('ChildB', style: style),
          Text('Model data: ${model.valueB}', style: style),
          RaisedButton(
            onPressed: () => model.addB(),
            child: Text('add'),
          ),
        ],
      ),
    );
  }
}

效果如图所示。

在上面的代码下，不论我们点击ChildA的Add，还是ChildB的Add，整个界面都会Rebuild。即使通过Consumer，也无法做到只刷新对应的数据，原因在于它们的数据模型是同一个，Consumer只能做到数据模型层面上的更新刷新，但是无法针对同一个数据模型中不同字段的变换而进行更新。

所以，Consumer解决方案就是需要将这个数据模式拆成两个，ModelA和ModelB，这样使用MultiProvider管理ChangeNotifierProvider(ModleA)和ChangeNotifierProvider(ModelB)，再通过Consumer分别管理ModelA和ModelB，这样才能做到互补干扰的刷新。

那如果数据模型不能拆分呢？这个时候，就可以使用Selector了，先来看下Selector的构造函数。

A代表传入的数据源，例如前面的TestModel
S代表想要监听的A数据源中的的某个属性，比如TestModel的ModelA
selector的功能，就是从A数据源中筛选出需要监听的数据S，然后将S传递传给builder进行构造
shouldRebuild用来覆盖默认的对比算法，可以不设置

对比算法如下所示。

从源码可以发现，Selector判断的标准就是新旧数据Model是否「==」，如果是Collection类型，则通过DeepCollectionEquality来进行比较，官方建议使用https://pub.flutter-io.cn/packages/tuple 来进行简化判断

有了Selector之后，就可以在同一个数据模型中，根据条件，筛选出不同的刷新条件了，这样就可以避免数据模型中的某个属性变换而引起的整个数据模型刷新了。

通过Selector，将上面的代码进行下改造。

class ChildWidgetA extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    debugPrint('ChildWidgetA build');
    return Selector<TestModel, int>(
      selector: (context, value) => value.modelValueA,
      builder: (BuildContext context, value, Widget child) {
        return Container(
          color: Colors.redAccent,
          height: 48,
          child: Row(
            mainAxisAlignment: MainAxisAlignment.spaceEvenly,
            children: <Widget>[
              Text('ChildA', style: style),
              Text('Model data: $value', style: style),
              RaisedButton(
                onPressed: () => context.read<TestModel>().addA(),
                child: Text('add'),
              ),
            ],
          ),
        );
      },
    );
  }
}

这样通过Selector进行一次筛选，就可以避免同一个Model中不同的数据刷新导致整个Model Rebuild的问题，例如上面的Selector，指定了需要在TestModel中寻找int类型的数据，其过滤条件是TestModel中的modelValueA这样一个int类型的数据，根据ShouldRebuild（默认实现）的判断，返回这个情况下，ChildWidgetA是否需要Rebuild。

与Provider.of类似，在4.1之后，Provider提供了基于BuildContext的拓展函数来简化Selector的使用，例如上面的代码通过selector拓展函数来实现，代码如下所示。

class ChildWidgetB extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    debugPrint('ChildWidgetB build');
    return Container(
      color: Colors.blueAccent,
      height: 48,
      child: Row(
        mainAxisAlignment: MainAxisAlignment.spaceEvenly,
        children: <Widget>[
          Text('ChildB', style: style),
          Builder(
            builder: (BuildContext context) {
              return Text(
                'Model data: ${context.select((TestModel value) => value.modelValueB)}',
                style: style,
              );
            },
          ),
          RaisedButton(
            onPressed: () => context.read<TestModel>().addB(),
            child: Text('add'),
          ),
        ],
      ),
    );
  }
}

不过需要注意的是，这里需要通过Builder来创建一个子类的Context，避免当前Context的刷新。

more Selector

与Consumer类似，Selector同样也有多种不同的实现。

其实很简单，就是实现多种不同的数据类型，在这些数据模型中，找到需要监听的那一种类型，这种情况比较常用于多个数据模型中具体共同参数的场景。

上面就是通过Provider来获取被管理的数据的三种方式：Provider.of，Consumer和Selector，它们的功能完全一致，区别仅仅在于刷新的控制粒度。

本文分享自微信公众号 - Android群英传（android_heroes）。
如有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一起分享。

微信关注我们

原文链接：https://my.oschina.net/u/4582626/blog/4562431

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

可以提高你的图像识别模型准确率的7个技巧

假定，你已经收集了一个数据集，建立了一个神经网络，并训练了您的模型。但是，尽管你投入了数小时(有时是数天)的工作来创建这个模型，它还是能得到50-70%的准确率。这肯定不是你所期望的。下面是一些提高模型性能指标的策略或技巧，可以大大提升你的准确率。得到更多的数据这无疑是最简单的解决办法，深度学习模型的强大程度取决于你带来的数据。增加验证准确性的最简单方法之一是添加更多数据。如果您没有很多训练实例，这将特别有用。如果您正在处理图像识别模型，您可以考虑通过使用数据增强来增加可用数据集的多样性。这些技术包括从将图像翻转到轴上、添加噪声到放大图像。如果您是一个强大的机器学习工程师，您还可以尝试使用GANs进行数据扩充。请注意，您使用的增强技术会更改图像的整个类。例如，在y轴上翻转的图像没有意义! 添加更多的层向模型中添加更多层可以增强它更深入地学习数据集特性的能力，因此它将能够识别出作为人类可能没有注意到的细微差异。这个技巧图解决的任务的性质。对于复杂的任务，比如区分猫和狗的品种，添加更多的层次是有意义的，因为您的模型将能够学习区分狮子狗和西施犬的微妙特征。对于简单的任务，...

2020-09-12

709

点击蓝色“程序员的时光”关注我，标注“星标”，及时阅读最新技术文章写在前面：小伙伴儿们，大家好！上一篇我们了解到了Docker容器的操作命令——久等了！Docker容器常用命令今天来学习Docker端口映射！持续更新，敬请期待！思维导图： 1，Docker映射是什么？容器里面运行着应用，外部需要访问交互，涉及到容器里面的端口和宿主机之间的映射；通过端口映射，我们就可以从外部访问宿主机的指定端口来访问到容器的应用； 2，如何实现Docker映射？这里我们以Tomcat为例子，我们看看如何在外部通过Docker端口映射来访问宿主主机里面的Tomca。 2.1，下载tomcat容器镜像下载镜像：docker pull tomcat:tag，不加版本号的话默认是下载最新版本查看所有镜像：docker images，我这里是已经下载了三个版本的tomcat 2.2，创建并启动tomcat容器创建启动tomcat容器：docker run --name tomcat1 -d tomcat :latest, 其中-d是表示后台运行容器，tomcat1是容器名称，tomcat :l...

2020-09-14

546

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。