flutter Bloc 实现原理示例解析

import 'dart:async';
abstract class ACubit<State> {
  StreamController<State> _controller = StreamController<State>.broadcast();
  State _state;
  State get state => _state;
  ACubit(this._state);
  ///发送State状态到流里面
  void emit(State state) {
    if (_controller.isClosed) return;
    if (state == _state) return;
    _state = state;
    _controller.add(_state);
  }
  ///提供方法外部监听State
  StreamSubscription<State> listen(
    void Function(State state) onData, {
    Function onError,
    void Function() onDone,
    bool cancelOnError,
  }) {
    return _controller.stream.listen(
      onData,
      onError: onError,
      onDone: onDone,
      cancelOnError: cancelOnError,
    );
  }
  Future<void> close() {
    return _controller.close();
  }
}

abstract class ABloc<Event, State> extends ACubit<State> {
  final _eventController = StreamController<Event>.broadcast();
  ABloc(State initState) : super(initState) {
    _bindEventToState();
  }
  ///发送事件
  void add(Event event) {
    if (_eventController.isClosed) return;
    _eventController.add(event);
  }
  ///需上层实现 （根据event转成state）
  Stream<State> mapEventToState(Event event);
  ///将事件流（event）转换成状态流（state）
  _bindEventToState() {
    _eventController.stream
        // asyncExpand 将流内容进行类型转换，结果还是流
        .asyncExpand((event) => mapEventToState(event))
        .listen((nextState) {
      ///将nextState与当前state进行比对,比对成功后放入流中
      emit(nextState);
    });
  }
}

import 'package:flutter/material.dart';
import 'a_bloc.dart';
class BlocBuilder<T extends ACubit<S>, S> extends StatefulWidget {
  final T cubit;
  final Widget Function(BuildContext context, S state) builder;
  const BlocBuilder({
    Key key,
    @required this.cubit,
    @required this.builder,
  }) : super(key: key);
  @override
  _BlocBuilderState<S> createState() => _BlocBuilderState<S>();
}
class _BlocBuilderState<S> extends State<BlocBuilder> {
  void _update() {
    setState(() {});
  }
  @override
  void initState() {
    ///监听state状态变更
    widget.cubit?.listen((_) {
      _update();
    });
    super.initState();
  }
  @override
  void dispose() {
    widget.cubit?.close();
    super.dispose();
  }
  @override
  Widget build(BuildContext context){
    return widget.builder(
      context,
      widget.cubit.state,
    );
  }
}

return BlocBuilder<CountBloc, CountState>(
      cubit: CountBloc(CountState(1)),
      builder: (context, state) {
       return Container(...省略业务代码)
      },
    )