为了弄懂Flutter的状态管理,-我用10种方法改造了counter-app(2)

2401_84150043

于 2024-05-06 19:16:38 发布

阅读量597

点赞数 21

分类专栏：程序员文章标签： flutter

本文链接：https://blog.csdn.net/2401_84150043/article/details/138505211

版权

程序员专栏收录该内容

262 篇文章 0 订阅

订阅专栏

其次, InheritedWidget它包含的数据是不可变的, 如果想让它跟踪变化的数据:

把它包在一个StatefulWidget里.
在InheritedWidget中使用ValueNotifier, ChangeNotifier或steams.

这个方案也是了解一下, 实际的全局状态管理还是用更成熟的方案.
但是它的原理会被用到其他方案中作为对象传递的方式.

Scoped Model

scoped model是一个外部package: https://pub.dev/packages/scoped_model
Scoped Model是基于InheritedWidget的. 思想仍然是把状态提到上层去, 并且封装了状态改变的通知部分.

Scoped Model实现

它官方提供例子就是改造counter: https://pub.dev/packages/scoped_model#-example-tab-

添加scoped_model依赖.
创建数据类, 继承Model.

import ‘package:scoped_model/scoped_model.dart’;

class CounterModel extends Model {
int _counter = 0;

int get counter => _counter;

void increment() {
_counter++;
notifyListeners();
}

void decrement() {
_counter–;
notifyListeners();
}
}

其中数据变化的部分会通知listeners, 它们收到通知后会rebuild.

在上层初始化并提供数据类, 用ScopeModel.

访问数据有两种方法:

用ScopedModelDescendant包裹widget.
用ScopedModel.of静态方法.

使用的时候注意要提供泛型类型, 会帮助我们找到离得最近的上层ScopedModel.

ScopedModelDescendant(
builder: (context, child, model) {
return Text(
model.counter.toString(),
);
}),

数据改变后, 只有ScopedModelDescendant会收到通知, 从而rebuild.

ScopedModelDescendant有一个rebuildOnChange属性, 这个值默认是true.
对于button来说, 它只是控制改变, 自身并不需要重绘, 可以把这个属性置为false.

ScopedModelDescendant(
rebuildOnChange: false,
builder: (context, child, model) {
return FloatingActionButton(
onPressed: model.increment,
tooltip: ‘Increment’,
child: Icon(Icons.add),
);
},
),

scoped model这个库帮我们解决了数据访问和通知的问题, 但是rebuild范围需要自己控制.

access state
notify other widgets
minimal rebuild -> X -> 因为需要开发者自己来决定哪一部分是否需要被重建, 容易被忘记.

代码分支: scoped-model

Provider

Provider是官方文档的例子用的方法.
去年的Google I/O 2019也推荐了这个方法.
和BLoC的流式思想相比, Provider是一个观察者模式, 状态改变时要notifyListeners().

有一个counter版本的sample: https://github.com/flutter/samples/tree/master/provider_counter

Provider的实现在内部还是利用了InheritedWidget.
Provider的好处: dispose指定后会自动被调用, 支持MultiProvider.

Provider实现

model类继承ChangeNotifer, 也可以用with.

class CounterModel extends ChangeNotifier {
int value = 0;

void increment() {
value++;
notifyListeners();
}

void decrement() {
value–;
notifyListeners();
}
}

数据提供者: ChangeNotifierProvider.

void main() => runApp(ChangeNotifierProvider(
create: (context) => CounterModel(),
child: MyApp(),
));

数据消费者/操纵者, 有两种方式: Consumer包裹, 用Provider.of.

Consumer(
builder: (context, counter, child) => Text(
‘${counter.value}’,
),
),

FAB:

FloatingActionButton(
onPressed: () =>
Provider.of(context, listen: false).increment(),
),

这里listen置为false表明状态变化时并不需要rebuild FAB widget.

Provider性能相关的实现细节

Consumer包裹的范围要尽量小.
listen变量.
child的处理. Consumer中builder方法的第三个参数.

可以用于缓存一些并不需要重建的widget:

return Consumer(
builder: (context, cart, child) => Stack(
children: [
// Use SomeExpensiveWidget here, without rebuilding every time.
child,
Text(“Total price: ${cart.totalPrice}”),
],
),
// Build the expensive widget here.
child: SomeExpensiveWidget(),
);

代码分支: provider.

BLoC

BLoC模式的全称是: business logic component.

所有的交互都是a stream of asynchronous events.
Widgets + Streams = Reactive.

BLoC的实现的主要思路: Events in -> BloC -> State out.

Google I/O 2018上推荐的还是这个, 2019就推荐Provider了.
当然也不是说这个模式不好, 架构模式本来也没有对错之分, 只是技术选型不同.

BLoC手动实现

不添加任何依赖可以手动实现BLoC, 利用:

Dart SDK > dart:async > Stream.
Flutter的StreamBuilder: 输入是一个stream, 有一个builder方法, 每次stream中有新值, 就会rebuild.

可以有多个stream, UI只在自己感兴趣的信息发生变化的时候重建.

BLoC中:

输入事件: Sink<Event> input.
输出数据: Stream<Data> output.

CounterBloc类:

class CounterBloc {
int _counter = 0;

final _counterStateController = StreamController();

StreamSink get _inCounter => _counterStateController.sink;

Stream get counter => _counterStateController.stream;

final _counterEventController = StreamController();

Sink get counterEventSink => _counterEventController.sink;

CounterBloc() {
_counterEventController.stream.listen(_mapEventToState);
}

void _mapEventToState(CounterEvent event) {
if (event is IncrementEvent) {
_counter++;
} else if (event is DecrementEvent) {
_counter–;
}
_inCounter.add(_counter);
}

void dispose() {
_counterStateController.close();
_counterEventController.close();
}
}

有两个StreamController, 一个控制state, 一个控制event.

读取状态值要用StreamBuilder:

StreamBuilder(
stream: _bloc.counter,
initialData: 0,
builder: (BuildContext context, AsyncSnapshot snapshot) {
return Text(
‘${snapshot.data}’,
);
},
)

而改变状态是发送事件:

FloatingActionButton(
onPressed: () => _bloc.counterEventSink.add(IncrementEvent()),
),

实现细节:

每个屏幕有自己的BLoC.
每个BLoC必须有自己的dispose()方法. -> BLoC必须和StatefulWidget一起使用, 利用其生命周期释放.

代码分支: bloc

BLoC传递: 用InheritedWidget

手动实现的BLoC模式, 可以结合InheritedWidget, 写一个Provider, 用来做BLoC的传递.

代码分支: bloc-with-provider

BLoC rxdart实现

用了rxdart package之后, bloc模块的实现可以这样写:

class CounterBloc {
int _counter = 0;

final _counterSubject = BehaviorSubject();

Stream get counter => _counterSubject.stream;

final _counterEventController = StreamController();

Sink get counterEventSink => _counterEventController.sink;

CounterBloc() {
_counterEventController.stream.listen(_mapEventToState);
}

void _mapEventToState(CounterEvent event) {
if (event is IncrementEvent) {
_counter++;
} else if (event is DecrementEvent) {
_counter–;
}
_counterSubject.add(_counter);
}

void dispose() {
_counterSubject.close();
_counterEventController.close();
}
}

BehaviorSubject也是一种StreamController, 它会记住自己最新的值, 每次注册监听, 会立即给你最新的值.

代码分支: bloc-rxdart.

BLoC Library

可以用这个package来帮我们简化代码: https://pub.dev/packages/flutter_bloc

自己只需要定义Event和State的类型并传入, 再写一个逻辑转化的方法:

class CounterBloc extends Bloc<CounterEvent, CounterState> {
@override
CounterState get initialState => CounterState.initial();

@override
Stream mapEventToState(CounterEvent event) async* {
if (event is IncrementEvent) {
yield CounterState(counter: state.counter + 1);
} else if (event is DecrementEvent) {
yield CounterState(counter: state.counter - 1);
}
}
}

用BlocProvider来做bloc的传递, 从而不用在构造函数中一传到底.

访问的时候用BlocBuilder或BlocProvider.of<CounterBloc>(context).

BlocBuilder(
bloc: BlocProvider.of(context),
builder: (BuildContext context, CounterState state) {
return Text(
‘${state.counter}’,
);
},
),

这里bloc参数如果没有指定, 会自动向上寻找.

BlocBuilder有一个参数condition, 是一个返回bool的函数, 用来精细控制是否需要rebuild.

FloatingActionButton(
onPressed: () =>
BlocProvider.of(context).add(IncrementEvent()),
),

代码分支: bloc-library.

rxdart

这是个原始版本的流式处理.

和BLoC相比, 没有专门的逻辑模块, 只是改变了数据的形式.

利用rxdart, 把数据做成流:

class CounterModel {
BehaviorSubject _counter = BehaviorSubject.seeded(0);

get stream$ => _counter.stream;

int get current => _counter.value;

increment() {
_counter.add(current + 1);
}

decrement() {
_counter.add(current - 1);
}
}

获取数据用StreamBuilder, 包围的范围尽量小.

StreamBuilder(
stream: counterModel.stream $KaTeX parse error: Expected '}', got 'EOF' at end of input: \dots return Text( '$ {snapshot.data}',
);
},
),

Widget dispose的时候会自动解绑.

数据传递的部分还需要进一步处理.

代码分支: rxdart.

Redux

Redux是前端流行的, 一种单向数据流架构.

概念:

Store: 用于存储State对象, 代表整个应用的状态.
Action: 事件操作.
Reducer: 用于处理和分发事件的方法, 根据收到的Action, 用一个新的State来更新Store.
View: 每次Store接到新的State, View就会重建.

Reducer是唯一的逻辑处理部分, 它的输入是当前State和Action, 输出是一个新的State.

Flutter Redux状态管理实现

首先定义好action, state:

enum Actions {
Increment,
Decrement,
}

class CounterState {
int _counter;

int get counter => _counter;

CounterState(this._counter);
}

reducer方法根据action和当前state产生新的state:

CounterState reducer(CounterState prev, dynamic action) {
if (action == Actions.Increment) {
return new CounterState(prev.counter + 1);
} else if (action == Actions.Decrement) {
return new CounterState(prev.counter - 1);
} else {
return prev;
}
}

数据提供者: StoreProvider.
放在上层:

StoreProvider(
store: store,
child: MaterialApp(
title: ‘Flutter Demo’,
theme: ThemeData(
primarySwatch: Colors.blue,
),
home: MyHomePage(title: ‘Flutter Demo Home Page’),
),
);

数据消费者: StoreConnector, 可读可写.

读状态:

StoreConnector<CounterState, String>(
converter: (store) => store.state.counter.toString(),
builder: (context, count) {
return Text(
‘$count’,
);
},
)

改变状态: 发送action:

StoreConnector<CounterState, VoidCallback>(
converter: (store) {
return () => store.dispatch(action.Actions.Increment);
},
builder: (context, callback) {
return FloatingActionButton(
onPressed: callback,
);
},
),

代码分支: redux.

MobX

MobX本来是一个JavaScript的状态管理库, 它迁移到dart的版本: mobxjs/mobx.dart.

核心概念:

Observables
Actions
Reactions

MobX状态管理实现

官网提供了一个counter的指导: https://mobx.netlify.com/getting-started

这个库的实现需要先生成一些代码.
先写类:

import ‘package:mobx/mobx.dart’;

part ‘counter.g.dart’;

class Counter = _Counter with _$Counter;

abstract class _Counter with Store {
@observable
int value = 0;

@action
void increment() {
value++;
}

@action
void decrement() {
value–;
}
}

运行命令flutter packages pub run build_runner build, 生成counter.g.dart.

改完之后就不需要再使用StatefulWidget了.

找一个合适的地方初始化数据对象并保存:

final counter = Counter();

读取值的地方用Observer包裹:

Observer(
builder: (_) => Text(
‘${counter.value}’,
style: Theme.of(context).textTheme.display1,
),
),

改变值的地方:

FloatingActionButton(
onPressed: counter.increment,
tooltip: ‘Increment’,
child: Icon(Icons.add),
),

代码分支: mobx.

Flutter hooks

React hooks的Flutter实现.
package: https://pub.dev/packages/flutter_hooks

Hooks存在的目的是为了增加widgets之间的代码共享, 取代StatefulWidget.

首页的例子是: 对一个使用了AnimationController的StatefulWidget的简化.

flutter_hooks包中已经内置了一些已经写好的hooks.

最后

感觉现在好多人都在说什么安卓快凉了，工作越来越难找了。又是说什么程序员中年危机啥的，为啥我这年近30的老农根本没有这种感觉，反倒觉得那些贩卖焦虑的都是瞎j8扯谈。当然，职业危机意识确实是要有的，但根本没到那种草木皆兵的地步好吗？

Android凉了都是弱者的借口和说辞。虽然 Android 没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明 Android 中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。

所以，最后这里放上我耗时两个月，将自己8年Android开发的知识笔记整理成的Android开发者必知必会系统学习资料笔记，上述知识点在笔记中都有详细的解读，里面还包含了腾讯、字节跳动、阿里、百度2019-2021面试真题解析，并且把每个技术点整理成了视频和PDF（知识脉络 + 诸多细节）。