【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第1张图片

前言

人心中的成见是一座大山，任你怎么努力都休想搬动。

这是电影《哪吒》里申公豹说的一句话，也是贯彻整部电影的一个主题；或许这句话引起了太多人的共鸣：35岁职场危机，大厂卡本科学历，无房无车结婚难等等，所以，这句话也经常被人提起。

同时，因为GetX作者的一些言论，也让一些成见一直伴随着GetX这个框架。

我写这篇文章，并不是为GetX正名

  • 我自问自己并不是任何一个状态框架的死忠者，Provider和Bloc，我写了相关使用、原理剖析文章和相关代码生成插件
  • 在我心中，这类框架并没有多么神秘
  • 因为对其原理较熟，上手使用是一件较为容易的事，所以切换相关框架没有多大的时间成本
  • 所以，我无需去做一个卫道者

GetX整体设计，有不少优秀点思想，我希望将这些优秀设计思路展现给大家；或许会对你设计自己的框架有一些帮助，同时也是对自己思考历程的一个记录。

前置知识

在说GetX设计思想之前，需要先介绍几个知识，在Flutter茁壮发展的历程里，他们都留下了浓墨重彩的一笔

InheritedWidget

不得不说，这个控件真的是一个神奇控件，它就仿佛是一把神兵利器

  • 宝刀屠龙，号令天下，莫敢不从，倚天不出，谁与争锋
  • 倚天剑，剑藏《九阴真经》
  • 屠龙刀，刀藏《降龙十八掌》、《武穆遗书》

InheritedWidget这把神兵藏有什么？

  • 依赖节点，数据传输
  • 定点刷新机制

数据传输

InheritedWidget是我们统称的一个控件名，精髓还是InheritedElement，InheritedWidget的数据传递，来看下存和取这俩个过程

存数据
  • InheritedWidget存数据，是一个比较简单的操作，存储在InheritedElement中即可
class TransferDataWidget extends InheritedWidget {
  TransferDataWidget({required Widget child}) : super(child: child);

  @override
  bool updateShouldNotify(InheritedWidget oldWidget) => false;

  @override
  InheritedElement createElement() => TransferDataElement(this);
}

class TransferDataElement extends InheritedElement {
  TransferDataElement(InheritedWidget widget) : super(widget);

  ///随便初始化什么, 设置只读都行
  String value = '传输数据';
}
取数据
  • 只要是 TransferDataWidget（上面InheritedWidget的子类） 的子节点，通过子节点的BuildContext（Element是BuildContext的实现类），都可以无缝的取数据
var transferDataElement = context.getElementForInheritedWidgetOfExactType()
            as TransferDataElement?;
var msg = transferDataElement.value;

可以发现，我们只需要通过Element的getElementForInheritedWidgetOfExactType方法，就可以拿到父节点的TransferDataElement实例（必须继承InheritedElement）

拿到实例后，自然就可以很简单的拿到相应数据了

原理

  • 可以发现我们是拿到了XxxInheritedElement实例，继而拿到了储存的值，所以关键在 getElementForInheritedWidgetOfExactType() 这个方法

    • 代码很简单，就是从 _inheritedWidgets这个map里取值，泛型T是key
abstract class Element extends DiagnosticableTree implements BuildContext {

    Map? _inheritedWidgets;

    @override
    InheritedElement? getElementForInheritedWidgetOfExactType() {
        assert(_debugCheckStateIsActiveForAncestorLookup());
        final InheritedElement? ancestor = _inheritedWidgets == null ? null : _inheritedWidgets![T];
        return ancestor;
    }
    
    ...
}
  • 接下来只要搞清楚 _inheritedWidgets 是怎么存值，那么一切都会明朗
abstract class ComponentElement extends Element {
    
  @mustCallSuper
  void mount(Element? parent, dynamic newSlot) {
    ...
    _updateInheritance();
  }
    
  void _updateInheritance() {
    assert(_lifecycleState == _ElementLifecycle.active);
    _inheritedWidgets = _parent?._inheritedWidgets;
  }
    
    ...
}

abstract class ProxyElement extends ComponentElement {
    ...
}

class InheritedElement extends ProxyElement {
    InheritedElement(InheritedWidget widget) : super(widget);

    @override
    void _updateInheritance() {
        assert(_lifecycleState == _ElementLifecycle.active);
        final Map? incomingWidgets = _parent?._inheritedWidgets;
        if (incomingWidgets != null)
            _inheritedWidgets = HashMap.from(incomingWidgets);
        else
            _inheritedWidgets = HashMap();
        _inheritedWidgets![widget.runtimeType] = this;
    }
}

整体上逻辑还是比较清晰

  1. 遇到某个节点为 InheritedWidget 时，会将父节点的 _inheritedWidgets 变量给 incomingWidgets 这个临时变量

    1. incomingWidgets 为空：为父类Element的 _inheritedWidgets 变量， 实例了一个map对象
    2. incomingWidgets 不为空：将父节点_inheritedWidgets 所有数据深拷贝，返回一个全新的Map实例（含有父节点 _inheritedWidgets 所有数据），赋值给父类Element的 _inheritedWidgets 变量
  2. 将自身实例赋值给父类Element的 _inheritedWidgets 变量，key为其widget的runtimeType
为什么任何一个Widget的Element实例的 _inheritedWidgets 变量，可直接拿到父节点InheritedElement实例？
  • Element中做了一个父节点向子节点赋值的操作：整个数据传输链清晰了
abstract class Element extends DiagnosticableTree implements BuildContext {

    Map? _inheritedWidgets;

    void _updateInheritance() {
        assert(_lifecycleState == _ElementLifecycle.active);
        _inheritedWidgets = _parent?._inheritedWidgets;
    }

    ...
}
  • 图示

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第2张图片

刷新机制

InheritedElement和Element之间有一些交互，实际上自带了一套刷新机制
  • InheritedElement存子节点Element： _dependents，这个变量是用来存储，需要刷新的子Element
class InheritedElement extends ProxyElement {
  InheritedElement(InheritedWidget widget) : super(widget);

  final Map _dependents = HashMap();

  @protected
  void setDependencies(Element dependent, Object? value) {
    _dependents[dependent] = value;
  }

  @protected
  void updateDependencies(Element dependent, Object? aspect) {
    setDependencies(dependent, null);
  }
}

  • InheritedElement刷新子Element

    • notifyClients这个方法就是将 _dependents 存储的Element，全部拿了出来，传入notifyDependent
    • 在notifyDependent方法中，传入Element调用了自身didChangeDependencies()方法
    • Element的didChangeDependencies() 方法会调用 markNeedsBuild() ，来刷新自身
class InheritedElement extends ProxyElement {
  InheritedElement(InheritedWidget widget) : super(widget);

  final Map _dependents = HashMap();

  @protected
  void notifyDependent(covariant InheritedWidget oldWidget, Element dependent) {
    dependent.didChangeDependencies();
  }
    
  @override
  void notifyClients(InheritedWidget oldWidget) {
    for (final Element dependent in _dependents.keys) {
      ...
      notifyDependent(oldWidget, dependent);
    }
  }
}

abstract class Element extends DiagnosticableTree implements BuildContext {
  ...
    
  @mustCallSuper
  void didChangeDependencies() {
    assert(_lifecycleState == _ElementLifecycle.active); // otherwise markNeedsBuild is a no-op
    assert(_debugCheckOwnerBuildTargetExists('didChangeDependencies'));
    markNeedsBuild();
  }
    
  ...
}

InheritedWidget的子节点是怎么将自身Element

添加到InheritedElement的_dependents变量里的呢？

  • Element里面有个 dependOnInheritedElement 方法

    • Element中dependOnInheritedElement方法，会传入InheritedElement实例 ancestor
    • ancestor调用updateDependencies方法，将自身的Element实例传入
    • InheritedElement中就将这个Element，添加到_dependents变量中了
abstract class Element extends DiagnosticableTree implements BuildContext {
  ...
    
  @override
  InheritedWidget dependOnInheritedElement(InheritedElement ancestor, { Object? aspect }) {
    assert(ancestor != null);
    _dependencies ??= HashSet();
    _dependencies!.add(ancestor);
    ancestor.updateDependencies(this, aspect);
    return ancestor.widget;
  }
    
  ...
}

class InheritedElement extends ProxyElement {
  InheritedElement(InheritedWidget widget) : super(widget);

  final Map _dependents = HashMap();

  @protected
  void setDependencies(Element dependent, Object? value) {
    _dependents[dependent] = value;
  }

  @protected
  void updateDependencies(Element dependent, Object? aspect) {
    setDependencies(dependent, null);
  }
}

  • dependOnInheritedElement该方法的使用也很简单

    • 一般来说在某个Widget使用 getElementForInheritedWidgetOfExactType 获取父节点的 InheritedElement
    • 然后将其传入 dependOnInheritedElement 方法中即可
// 举例
var inheritedElement = context
            .getElementForInheritedWidgetOfExactType>()
        as EasyPInheritedElement?;
context.dependOnInheritedElement(inheritedElement);
Provider核心原理，就是采用了InheritedWidget这种刷新机制

想详细了解Provider相关原理，可参考下面文章

图示
  • 来看下InheritedWidget刷新机制的图示

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第3张图片

路由小知识

  • 路由Navigator中基本都是些操作路由的静态方法，NavigatorState是实现的具体逻辑

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第4张图片

大家在使用InheritedWidget获取数据的时候，或许有过这样一种困扰：A页面 ---> B页面 ---> C页面

如果我在A页面使用InheritedWidget储存了数据，跳转到B页面或者C页面，会发现使用context获取不到A页面的InheritedElement

这侧面证明了Navigator路由跳转：A页面跳转B页面，B页面并不是A页面的子节点

  • 大致结构：可勉强理解为，Navigator是所有页面父节点，页面与页面之间是平级关系

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第5张图片

这里我画了下大致结构，如有偏差，请务必指出来，我会尽快修改

关于Flutter路由原理解析，可参考此文章（作者为啥现在不更文了呢 ~~）：Flutter 路由原理解析

思考

InheritedWidget为我们带了很多便利

  • 可以在一个Widget树范围，获取到我们想要InheritedElement（通过泛型区分即可）
  • InheritedElement和Element各种交互，也实现了一套极其简洁的刷新机制
  • 进行一些深度封装，甚至可以无缝的管理很多控件的资源释放

但是，Element提供的获取InheritedElement的方式，终究和路由机制无法很好的结合；这也模块设计无法避免的事情，或许某些模块设计的最优解，很难顾忌到其它模快的一些机制

InheritedWidget这把神兵利器，在我们学习Flutter历程中给予了很多帮助

  • 但是，当需求逐渐复杂，你的技术不断精进
  • 屠龙刀这把神兵，或许渐渐的，不太适合你了
  • 有时候，它甚至制约了你的出招
  • 一位制造神兵的铁匠，在他心中，最好的神兵利器，或许永远是下一把

大部分的状态管理框架，将界面层和逻辑层分开，都是逻辑层来处理界面的刷新；逻辑层可以交给InheritedWidget存储管理；说明，我们自己也一定可以存储管理！

  • 自己来管理逻辑层，可以摆脱Element树的约束，不用被困在Element树的父子节点中
  • 在路由跳转的页面中，可以很轻松的获取上一页面，下一个页面或者上上一个页面逻辑层。

这也是GetX中一个核心思想，这并不是一个多么新颖或高深技术，但是，我这觉得这是一种思维上的突破，可以带来更多的可能

依赖注入

说明

依赖注入有如下实现方式（维基百科）：

  • 基于接口。实现特定接口以供外部容器注入所依赖类型的对象。
  • 基于 set 方法。实现特定属性的public set方法，来让外部容器调用传入所依赖类型的对象。
  • 基于构造函数。实现特定参数的构造函数，在新建对象时传入所依赖类型的对象。
  • 基于注解。基于Java的注解功能，在私有变量前加“@Autowired”等注解，不需要显式的定义以上三种代码，便可以让外部容器传入对应的对象。该方案相当于定义了public的set方法，但是因为没有真正的set方法，从而不会为了实现依赖注入导致暴露了不该暴露的接口（因为set方法只想让容器访问来注入而并不希望其他依赖此类的对象访问）。
强耦合类型的，基于构造函数 
class Test {
  String msg;

  Test(String msg) {
    this.msg = msg;
  }
}
set方式 
class Test {
  String? _msg;

  void setMsg(String msg) {
    this._msg = msg;
  }
}

如果在Java中，图一时方便，直接在构造函数里面传值，然后需要的值越来越多，导致需要增加该构造函数传参，因为强耦合很多类，一改构造函数，爆红一大片（Dart构造函数可选参数的特性，就没有这类问题了）

  • Getx注入的GetXController都是由GetX框架自己来维护的，如果没有GetX这个中间层会是什么样的？

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第6张图片

  • 引入GetX这个中间层来管理

    • 看下图，瞬间就想到了中介者模式
    • 这也是控制反转的思想（创建对象的控制权本来在自己手上，现在交给了第三方）

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第7张图片

Put

来看下GetX注入的操作
  • put使用
var controller = Get.put(XxxGetxController());

  • 看看内部操作

    • 哎，各种骚操作
    • 主要逻辑在Inst中，Inst是GetInterface的扩展类
class _GetImpl extends GetInterface {}

final Get = _GetImpl();

extension Inst on GetInterface {
  S put(S dependency,
          {String? tag,
          bool permanent = false,
          InstanceBuilderCallback? builder}) =>
      GetInstance().put(dependency, tag: tag, permanent: permanent);
}

  • 主要的逻辑看来还是GetInstance中

    • 大家可以看看这地方单例的实现，我发现很多源码都用这种方式写的，非常简洁

    • 全局的数据都是存在 _singl 中，这是个Map

      • key：对象的runtimeType或者类的Type + tag
      • value：_InstanceBuilderFactory类，我们传入dependedt对象会存入这个类中

    • _singl 这个map存值的时候，不是用的put，而是用的putIfAbsent

      • 如果map中有key和传入key相同的数据，传入的数据将不会被存储
      • 也就是说相同类实例的对象，传入并不会被覆盖，只会存储第一条数据，后续被放弃
    • 最后使用find方法，返回传入的实例
class GetInstance {
  factory GetInstance() => _getInstance ??= GetInstance._();

  const GetInstance._();

  static GetInstance? _getInstance;

  static final Map _singl = {};

  S put(
    S dependency, {
    String? tag,
    bool permanent = false,
    @deprecated InstanceBuilderCallback? builder,
  }) {
    _insert(
        isSingleton: true,
        name: tag,
        permanent: permanent,
        builder: builder ?? (() => dependency));
    return find(tag: tag);
  }

  void _insert({
    bool? isSingleton,
    String? name,
    bool permanent = false,
    required InstanceBuilderCallback builder,
    bool fenix = false,
  }) {
    final key = _getKey(S, name);
    _singl.putIfAbsent(
      key,
      () => _InstanceBuilderFactory(
        isSingleton,
        builder,
        permanent,
        false,
        fenix,
        name,
      ),
    );
  }
    
  String _getKey(Type type, String? name) {
    return name == null ? type.toString() : type.toString() + name;
  }
    
  S find({String? tag}) {
    final key = _getKey(S, tag);
    if (isRegistered(tag: tag)) {
      if (_singl[key] == null) {
        if (tag == null) {
          throw 'Class "$S" is not registered';
        } else {
          throw 'Class "$S" with tag "$tag" is not registered';
        }
      }
      final i = _initDependencies(name: tag);
      return i ?? _singl[key]!.getDependency() as S;
    } else {
      // ignore: lines_longer_than_80_chars
      throw '"$S" not found. You need to call "Get.put($S())" or "Get.lazyPut(()=>$S())"';
    }
  }
}

find

  • find方法还是蛮简单的，就是从map中取数据的操作
S find({String? tag}) => GetInstance().find(tag: tag);

  • 看下具体逻辑

    • 先判断 _singl 中是否含有该key的数据，有则取，无则抛异常
    • 关键代码： _singl[key]!.getDependency() as S ，直接通过key去map取值就行了
class GetInstance {
  factory GetInstance() => _getInstance ??= GetInstance._();

  const GetInstance._();

  static GetInstance? _getInstance;

  static final Map _singl = {};
    
  String _getKey(Type type, String? name) {
    return name == null ? type.toString() : type.toString() + name;
  }
    
  bool isRegistered({String? tag}) => _singl.containsKey(_getKey(S, tag));
    
  S find({String? tag}) {
    final key = _getKey(S, tag);
    if (isRegistered(tag: tag)) {
      if (_singl[key] == null) {
        if (tag == null) {
          throw 'Class "$S" is not registered';
        } else {
          throw 'Class "$S" with tag "$tag" is not registered';
        }
      }
      final i = _initDependencies(name: tag);
      return i ?? _singl[key]!.getDependency() as S;
    } else {
      // ignore: lines_longer_than_80_chars
      throw '"$S" not found. You need to call "Get.put($S())" or "Get.lazyPut(()=>$S())"';
    }
  }
}

GetBuilder刷新机制

使用

为了知识的连续性，此处简单的写下使用

  • 逻辑层
class GetCounterEasyLogic extends GetxController {
  var count = 0;

  void increase() {
    ++count;
    update();
  }
}
  • 界面
class GetCounterEasyPage extends StatelessWidget {
  final GetCounterEasyLogic logic = Get.put(GetCounterEasyLogic());

  @override
  Widget build(BuildContext context) {
    return BaseScaffold(
      appBar: AppBar(title: const Text('计数器-简单式')),
      body: Center(
        child: GetBuilder(builder: (logic) {
          return Text(
            '点击了 ${logic.count} 次',
            style: TextStyle(fontSize: 30.0),
          );
        }),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => logic.increase(),
        child: Icon(Icons.add),
      ),
    );
  }
}

GetBuilder

有一天，我躺在床上思考

  • Obx的状态管理，GetXController实例回收是放在路由里面，在很多场景下，存在一些局限性
  • 后来我想到，GetBuilder使用带泛型，这就能拿到GetxController实例，GetBuilder又是StatefulWidget
  • 这样就可以使用它来回收实例，能解决很多场景下，GetXController实例无法回收的问题（不使用Getx路由）
  • 我兴致冲冲的打开Getx项目，准备提PR，然后发现GetBuilder已经在dispose里面写了回收实例的操作
  • 淦！

内置回收机制

  • 此处精简很多代码，只展示回收机制的代码
class GetBuilder extends StatefulWidget {
  final GetControllerBuilder builder;
  final bool global;
  final String? tag;
  final bool autoRemove;
  final T? init;

  const GetBuilder({
    Key? key,
    this.init,
    this.global = true,
    required this.builder,
    this.autoRemove = true,
    this.initState,
    this.tag,
  }) : super(key: key);


  @override
  GetBuilderState createState() => GetBuilderState();
}

class GetBuilderState extends State>
    with GetStateUpdaterMixin {
  T? controller;
  bool? _isCreator = false;
  VoidCallback? _remove;
  Object? _filter;

  @override
  void initState() {
    super.initState();
    widget.initState?.call(this);

    var isRegistered = GetInstance().isRegistered(tag: widget.tag);

    if (widget.global) {
      if (isRegistered) {
        controller = GetInstance().find(tag: widget.tag);
      } else {
        controller = widget.init;
        GetInstance().put(controller!, tag: widget.tag);
      }
    } else {
      controller = widget.init;
      controller?.onStart();
    }

  }

  @override
  void dispose() {
    super.dispose();
    widget.dispose?.call(this);
    if (_isCreator! || widget.assignId) {
      if (widget.autoRemove && GetInstance().isRegistered(tag: widget.tag)) {
        GetInstance().delete(tag: widget.tag);
      }
    }

    _remove?.call();

    controller = null;
    _isCreator = null;
    _remove = null;
    _filter = null;
  }


  @override
  Widget build(BuildContext context) {
    return widget.builder(controller!);
  }
}

代码里的逻辑还是相当清晰的，initState获取实例，dispose回收实例

  1. 通过GetBuilder上泛型获取相应GetXController实例

    • 不存在：使用init传入的实例
    • 存在：直接使用；init传入的实例无效

  2. autoRemove可以控制是否自动回收GetXController实例

    • 默认为true：默认开启自动回收
    • true：开启自动回收 false：关闭自动回收

刷新逻辑

  • 这里仅保留刷新逻辑的相关代码，去掉了无需关注的代码
mixin GetStateUpdaterMixin on State {
  void getUpdate() {
    if (mounted) setState(() {});
  }
}

class GetBuilder extends StatefulWidget {
  final GetControllerBuilder builder;
  final bool global;
  final T? init;
  final Object? id;
    
  const GetBuilder({
    Key? key,
    this.init,
    this.id,
    this.global = true,
    required this.builder,
  }) : super(key: key);


  @override
  GetBuilderState createState() => GetBuilderState();
}

class GetBuilderState extends State>
    with GetStateUpdaterMixin {
  T? controller;

  @override
  void initState() {
    super.initState();
    ...
     
    if (widget.global) {
      if (isRegistered) {
        controller = GetInstance().find(tag: widget.tag);
      } else {
        controller = widget.init;
        GetInstance().put(controller!, tag: widget.tag);
      }
    } else {
      controller = widget.init;
      controller?.onStart();
    }

    _subscribeToController();
  }

  void _subscribeToController() {
    _remove?.call();
    _remove = (widget.id == null)
        ? controller?.addListener(
            _filter != null ? _filterUpdate : getUpdate,
          )
        : controller?.addListenerId(
            widget.id,
            _filter != null ? _filterUpdate : getUpdate,
          );
  }

  void _filterUpdate() {
    var newFilter = widget.filter!(controller!);
    if (newFilter != _filter) {
      _filter = newFilter;
      getUpdate();
    }
  }

  @override
  void didChangeDependencies() {
    super.didChangeDependencies();
    widget.didChangeDependencies?.call(this);
  }

  @override
  void didUpdateWidget(GetBuilder oldWidget) {
    super.didUpdateWidget(oldWidget as GetBuilder);
    if (oldWidget.id != widget.id) {
      _subscribeToController();
    }
    widget.didUpdateWidget?.call(oldWidget, this);
  }

  @override
  Widget build(BuildContext context) {
    return widget.builder(controller!);
  }
}

关键步骤

  1. 通过泛型获取注入的GetXController实例

  2. 添加监听代码

    • addListener：添加监听回调
    • addListenerId：添加监听回调，必须设置id，update刷新的时候也必须写上配套的id

  3. 监听代码：核心代码就是getUpdate方法，方法在 GetStateUpdaterMixin 中

    • getUpdate()逻辑就是 setState()，刷新当前GetBuilder
图示

【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第8张图片

Update

  • 触发逻辑还是很简单的，使用update即可

    • Ids：和上面的Getbuilder对应起来了，可刷新对应设置id的GetBuilder
    • condition：是否刷新一个判断条件，默认为true（假设必须某个id大于3才能刷新：update([1, 2, 3, 4], index > 3) ）
abstract class GetxController extends DisposableInterface with ListNotifier {
  void update([List? ids, bool condition = true]) {
    if (!condition) {
      return;
    }
    if (ids == null) {
      refresh();
    } else {
      for (final id in ids) {
        refreshGroup(id);
      }
    }
  }
} 
 
     
  
  • 看下关键方法 refresh()，在ListNotifier类中
     
   
       
    
    • 可以发现，_updaters中泛型就是一个方法
      •  
    
    • 在GetBuilder中添加的监听就是一个方法参数，方法体里面就是 setState()
      •  
    
    • 齐活了！GetBuilder添加方法（方法体是setState），update遍历触发所有添加方法
      •  
   
    •  
 
 
 
typedef GetStateUpdate = void Function();
class ListNotifier implements Listenable {
  List? _updaters = [];

  HashMap>? _updatersGroupIds =
      HashMap>();

  @protected
  void refresh() {
    assert(_debugAssertNotDisposed());
    _notifyUpdate();
  }

  void _notifyUpdate() {
    for (var element in _updaters!) {
      element!();
    }
  }

  ...
}
 
 
     
  
  • 如果在update中加了id参数，会走refreshGroup方法，逻辑和refresh几乎一样，差别是对id的判断：有则执行，无则跳过
     
   
       
    
    • 遍历所有ids，然后执行refreshGroup方法
      •  
   
    •  
 
 
 
abstract class GetxController extends DisposableInterface with ListNotifier {
  void update([List? ids, bool condition = true]) {
    if (!condition) {
      return;
    }
    if (ids == null) {
      refresh();
    } else {
      for (final id in ids) {
        refreshGroup(id);
      }
    }
  }
}

class ListNotifier implements Listenable {
  HashMap>? _updatersGroupIds =
      HashMap>();

  void _notifyIdUpdate(Object id) {
    if (_updatersGroupIds!.containsKey(id)) {
      final listGroup = _updatersGroupIds![id]!;
      for (var item in listGroup) {
        item();
      }
    }
  }

  @protected
  void refreshGroup(Object id) {
    assert(_debugAssertNotDisposed());
    _notifyIdUpdate(id);
  }
} 
 
总结
 
 
     
  
  • 来看下GetBuilder刷新图示
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第9张图片
 
 
Obx刷新机制
 
 
这套刷新机制，和我们常用的状态管理框架（provider，bloc）以及上面的GetBuilder，在使用上有一些区别
 
 
     
  
  • 变量上：基础类型，实体以及列表之类的数据类型，作者都封装了一套Rx类型，快捷在数据后加obs
     
   
       
    
    • 例如：RxString msg = "test".obs（var msg = "test".obs）
      •  
   
    •  
  
  • 更新上：基础类型直接更新数据就行，实体需要以 .update() 的形式
    •  
  
  • 使用上：使用这类变量，一般要加上 .value ，作者也给出一个快捷方式变量后面加个 ()
     
   
       
    
    • 我不太推荐加 () 的形式，对后续维护项目人太不友好了
      •  
   
    •  
 
 
 
Obx刷新机制，最有趣应该就是变量改变后，包裹该变量的Obx会自动刷新！注意喔，仅仅是包裹该变量的Obx会刷新！其它的Obx并不会刷新。
 
 
这是怎么做到的呢？
 
 
     
  
  • 实际上，实现起来很简单
    •  
  
  • 但是，如果没有接触过这个思路，恐怕抓破头，都很难想出来，还能这么玩。。。
    •  
 
 
 
使用
 
 
简单的来看下使用
 
 
     
  
  • logic
    •  
 
 
 
class GetCounterRxLogic extends GetxController {
  var count = 0.obs;

  ///自增
  void increase() => ++count;
}
 
 
     
  
  • view
    •  
 
 
 
class GetCounterRxPage extends StatelessWidget {
  final GetCounterRxLogic logic = Get.put(GetCounterRxLogic());

  @override
  Widget build(BuildContext context) {
    return BaseScaffold(
      appBar: AppBar(title: const Text('计数器-响应式')),
      body: Center(
        child: Obx(() {
          return Text(
            '点击了 ${logic.count.value} 次',
            style: TextStyle(fontSize: 30.0),
          );
        }),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => logic.increase(),
        child: Icon(Icons.add),
      ),
    );
  }
}
 
 
Rx类变量
 
 
此处以 RxInt 为例，来看下其内部实现
 
 
     
  
  • 先来看下整型后面的拓展 obs ，这是一个扩展类，0.obs 等同 RxInt(0)
    •  
 
 
 
extension IntExtension on int {
  /// Returns a `RxInt` with [this] `int` as initial value.
  RxInt get obs => RxInt(this);
}
 
 
     
  
  • 来看下RxInt：这地方明确了使用 .value 运行时，会自动返回一个当前实例，并修改相应value数值
    •  
 
 
 
class RxInt extends Rx {
  RxInt(int initial) : super(initial);

  /// Addition operator.
  RxInt operator +(int other) {
    value = value + other;
    return this;
  }

  /// Subtraction operator.
  RxInt operator -(int other) {
    value = value - other;
    return this;
  }
}
 
 
     
  
  • 来看下父类 Rx
     
   
       
    
    • 这地方出现了一个很重要的类： _RxImpl
      •  
   
    •  
 
 
 
class Rx extends _RxImpl {
  Rx(T initial) : super(initial);

  @override
  dynamic toJson() {
    try {
      return (value as dynamic)?.toJson();
    } on Exception catch (_) {
      throw '$T has not method [toJson]';
    }
  }
}
 
 
     
  
  • _RxImpl 类继承了 RxNotifier 和 with 了 RxObjectMixin
     
   
       
    
    • 这个类内容是比较庞大的，主要是 RxNotifier 和 RxObjectMixin 内容很多
      •  
    
    • 代码很多，先展示下完整代码；在下一个说明处会进行简化
      •  
   
    •  
 
 
 
abstract class _RxImpl extends RxNotifier with RxObjectMixin {
  _RxImpl(T initial) {
    _value = initial;
  }

  void addError(Object error, [StackTrace? stackTrace]) {
    subject.addError(error, stackTrace);
  }

  Stream map(R mapper(T? data)) => stream.map(mapper);

  void update(void fn(T? val)) {
    fn(_value);
    subject.add(_value);
  }

  void trigger(T v) {
    var firstRebuild = this.firstRebuild;
    value = v;
    if (!firstRebuild) {
      subject.add(v);
    }
  }
}

class RxNotifier = RxInterface with NotifyManager;

mixin NotifyManager {
  GetStream subject = GetStream();
  final _subscriptions = >{};

  bool get canUpdate => _subscriptions.isNotEmpty;

  void addListener(GetStream rxGetx) {
    if (!_subscriptions.containsKey(rxGetx)) {
      final subs = rxGetx.listen((data) {
        if (!subject.isClosed) subject.add(data);
      });
      final listSubscriptions =
          _subscriptions[rxGetx] ??= [];
      listSubscriptions.add(subs);
    }
  }

  StreamSubscription listen(
    void Function(T) onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) =>
      subject.listen(
        onData,
        onError: onError,
        onDone: onDone,
        cancelOnError: cancelOnError ?? false,
      );

  void close() {
    _subscriptions.forEach((getStream, _subscriptions) {
      for (final subscription in _subscriptions) {
        subscription.cancel();
      }
    });

    _subscriptions.clear();
    subject.close();
  }
}

mixin RxObjectMixin on NotifyManager {
  late T _value;

  void refresh() {
    subject.add(value);
  }

  T call([T? v]) {
    if (v != null) {
      value = v;
    }
    return value;
  }

  bool firstRebuild = true;

  String get string => value.toString();

  @override
  String toString() => value.toString();

  dynamic toJson() => value;

  @override
  bool operator ==(dynamic o) {
    if (o is T) return value == o;
    if (o is RxObjectMixin) return value == o.value;
    return false;
  }

  @override
  int get hashCode => _value.hashCode;

  set value(T val) {
    if (subject.isClosed) return;
    if (_value == val && !firstRebuild) return;
    firstRebuild = false;
    _value = val;

    subject.add(_value);
  }

  T get value {
    if (RxInterface.proxy != null) {
      RxInterface.proxy!.addListener(subject);
    }
    return _value;
  }

  Stream get stream => subject.stream;

  void bindStream(Stream stream) {
    final listSubscriptions =
        _subscriptions[subject] ??= [];
    listSubscriptions.add(stream.listen((va) => value = va));
  }
}
 
 
     
  
  • 简化 _RxImpl，上面内容太多了，我这地方简化下，把需要关注的内容展示出来：此处有几个需要重点关注的点
     
   
       
    
    • RxInt是一个内置callback的数据类型（GetStream）
      •  
    
    • RxInt的value变量改变的时候（set value），会触发subject.add(_value)，内部逻辑是自动刷新操作
      •  
    
    • 获取RxInt的value变量的时候（get value），会有一个添加监听的操作，这个灰常重要！
      •  
   
    •  
 
 
 
abstract class _RxImpl extends RxNotifier with RxObjectMixin {

  void update(void fn(T? val)) {
    fn(_value);
    subject.add(_value);
  }
}

class RxNotifier = RxInterface with NotifyManager;

mixin NotifyManager {
  GetStream subject = GetStream();
  final _subscriptions = >{};

  bool get canUpdate => _subscriptions.isNotEmpty;

  void addListener(GetStream rxGetx) {
    if (!_subscriptions.containsKey(rxGetx)) {
      final subs = rxGetx.listen((data) {
        if (!subject.isClosed) subject.add(data);
      });
      final listSubscriptions =
          _subscriptions[rxGetx] ??= [];
      listSubscriptions.add(subs);
    }
  }
}

mixin RxObjectMixin on NotifyManager {
  late T _value;

  void refresh() {
    subject.add(value);
  }

  set value(T val) {
    if (subject.isClosed) return;
    if (_value == val && !firstRebuild) return;
    firstRebuild = false;
    _value = val;

    subject.add(_value);
  }

  T get value {
    if (RxInterface.proxy != null) {
      RxInterface.proxy!.addListener(subject);
    }
    return _value;
  }
}
 
 
     
  
  • 为啥GetStream的add会有刷新操作：删了很多代码，保留了重点代码
     
   
       
    
    • 调用add方法时候，会调用 _notifyData 方法
      •  
    
    • _notifyData 方法中，会遍历 _onData 列表，根据条件会执行其泛型的 _data 的方法
      •  
    
    • 我猜，_data 中的方法体，十有八九在某个地方肯定添加了 setState()
      •  
   
    •  
 
 
 
class GetStream {
  GetStream({this.onListen, this.onPause, this.onResume, this.onCancel});
  List>? _onData = >[];

  FutureOr addSubscription(LightSubscription subs) async {
    if (!_isBusy!) {
      return _onData!.add(subs);
    } else {
      await Future.delayed(Duration.zero);
      return _onData!.add(subs);
    }
  }

  void _notifyData(T data) {
    _isBusy = true;
    for (final item in _onData!) {
      if (!item.isPaused) {
        item._data?.call(data);
      }
    }
    _isBusy = false;
  }

  T? _value;

  T? get value => _value;

  void add(T event) {
    assert(!isClosed, 'You cannot add event to closed Stream');
    _value = event;
    _notifyData(event);
  }
}

typedef OnData = void Function(T data);

class LightSubscription extends StreamSubscription {
  OnData? _data;
}
 
 
     
  
  • 图示，先来看下，Rx类具有的功能
     
   
       
    
    • get value 添加监听
      •  
    
    • set value 执行已添加的监听
      •  
   
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第10张图片
 
 
Obx刷新机制
 
 

   Obx最大的特殊之处，应该就是使用它的时候，不需要加泛型且能自动刷新，这是怎么做到的呢？ 
 
 
 
     
  
  • Obx：代码并不多，但是皆有妙用
     
   
       
    
    • Obx继承ObxWidget，ObxWidget实际上也是一个StatefulWidget
      •  
    
    • _ObxState 中代码就是核心代码了
      •  
   
    •  
 
 
 
class Obx extends ObxWidget {
  final WidgetCallback builder;

  const Obx(this.builder);

  @override
  Widget build() => builder();
}


abstract class ObxWidget extends StatefulWidget {
  const ObxWidget({Key? key}) : super(key: key);

  @override
  _ObxState createState() => _ObxState();

  @protected
  Widget build();
}

class _ObxState extends State {
  RxInterface? _observer;
  late StreamSubscription subs;

  _ObxState() {
    _observer = RxNotifier();
  }

  @override
  void initState() {
    subs = _observer!.listen(_updateTree, cancelOnError: false);
    super.initState();
  }

  void _updateTree(_) {
    if (mounted) {
      setState(() {});
    }
  }

  @override
  void dispose() {
    subs.cancel();
    _observer!.close();
    super.dispose();
  }

  Widget get notifyChilds {
    final observer = RxInterface.proxy;
    RxInterface.proxy = _observer;
    final result = widget.build();
    if (!_observer!.canUpdate) {
      throw """
      [Get] the improper use of a GetX has been detected. 
      You should only use GetX or Obx for the specific widget that will be updated.
      If you are seeing this error, you probably did not insert any observable variables into GetX/Obx 
      or insert them outside the scope that GetX considers suitable for an update 
      (example: GetX => HeavyWidget => variableObservable).
      If you need to update a parent widget and a child widget, wrap each one in an Obx/GetX.
      """;
    }
    RxInterface.proxy = observer;
    return result;
  }

  @override
  Widget build(BuildContext context) => notifyChilds;
}
 
 
添加监听
 
 

   一个控件想刷新，肯定有添加监听的逻辑，再在某个地方手动触发 
 
 
 
     
  
  • 看下_ObxState类在哪添加监听：只展示监听添加的代码
    •  
  
  • _ObxState初始化的时候，会实例化一个 RxNotifier() 对象，使用 _observer变量接受：这个操作很重要
    •  
  
  • initState中做了一个比较关键的操作，_observer的listener方法中，将 _updateTree方法传进去了，这个方法中的逻辑体就是 setState()
    •  
 
 
 
class _ObxState extends State {
  RxInterface? _observer;
  late StreamSubscription subs;

  _ObxState() {
    _observer = RxNotifier();
  }

  @override
  void initState() {
    subs = _observer!.listen(_updateTree, cancelOnError: false);
    super.initState();
  }

  void _updateTree(_) {
    if (mounted) {
      setState(() {});
    }
  }
}
 
 
上述很多逻辑和 RxNotifier 类相关，来看下这个类
 
 
     
  
  • RxNotifier 这个类，内部会实例一个 GetStream() 对象，然后赋值给 subject
    •  
  
  • 上面赋值 _updateTree 方法被传入的 GetStream() 类中，最终添加 _onData 该列表变量中
    •  
  
  • 瞟一眼 _notifyData方法，是不是遍历执行了 _onData 列表中item的方法（ item. _data?.call(data) ）
    •  
 
 
 
class RxNotifier = RxInterface with NotifyManager;

mixin NotifyManager {
  GetStream subject = GetStream();
  final _subscriptions = >{};

  bool get canUpdate => _subscriptions.isNotEmpty;

  StreamSubscription listen(
    void Function(T) onData, {
    Function? onError,
    void Function()? onDone,
    bool? cancelOnError,
  }) =>
      subject.listen(
        onData,
        onError: onError,
        onDone: onDone,
        cancelOnError: cancelOnError ?? false,
      );
}

class GetStream {
  void Function()? onListen;
  void Function()? onPause;
  void Function()? onResume;
  FutureOr Function()? onCancel;

  GetStream({this.onListen, this.onPause, this.onResume, this.onCancel});
  List>? _onData = >[];

  FutureOr addSubscription(LightSubscription subs) async {
    if (!_isBusy!) {
      return _onData!.add(subs);
    } else {
      await Future.delayed(Duration.zero);
      return _onData!.add(subs);
    }
  }

  int? get length => _onData?.length;

  bool get hasListeners => _onData!.isNotEmpty;
    
  void _notifyData(T data) {
    _isBusy = true;
    for (final item in _onData!) {
      if (!item.isPaused) {
        item._data?.call(data);
      }
    }
    _isBusy = false;
  }

  LightSubscription listen(void Function(T event) onData,
      {Function? onError, void Function()? onDone, bool? cancelOnError}) {
    final subs = LightSubscription(
      removeSubscription,
      onPause: onPause,
      onResume: onResume,
      onCancel: onCancel,
    )
      ..onData(onData)
      ..onError(onError)
      ..onDone(onDone)
      ..cancelOnError = cancelOnError;
    addSubscription(subs);
    onListen?.call();
    return subs;
  }
}
 
 
     
  
  • 上面代码流程有一点绕，下面画了一个图，希望对各位有所帮助
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第11张图片
 
 
监听转移
 
 
 
  
在_ObxState类中做了一个很重要，监听对象转移的操作
 
  
_observer中的对象已经拿到了Obx控件内部的setState方法，现在需要将它转移出去啦！
 
 
 
 
     
  
  • 下面贴下将 _observer 中对象转移出去的代码：主要的逻辑就是在 notifyChilds 方法中
     
   
       
    
    • RxInterface 类中有个 proxy 静态变量，这个变量十分重要，他是一个中转变量！
      •  
   
    •  
 
 
 
`class _ObxState extends State {
  RxInterface? _observer;

  _ObxState() {
    _observer = RxNotifier();
  }

  Widget get notifyChilds {
    final observer = RxInterface.proxy;
    RxInterface.proxy = _observer;
    final result = widget.build();
    if (!_observer!.canUpdate) {
      throw """
      [Get] the improper use of a GetX has been detected. 
      You should only use GetX or Obx for the specific widget that will be updated.
      If you are seeing this error, you probably did not insert any observable variables into GetX/Obx 
      or insert them outside the scope that GetX considers suitable for an update 
      (example: GetX => HeavyWidget => variableObservable).
      If you need to update a parent widget and a child widget, wrap each one in an Obx/GetX.
      """;
    }
    RxInterface.proxy = observer;
    return result;
  }

  @override
  Widget build(BuildContext context) => notifyChilds;
}

abstract class RxInterface {
  bool get canUpdate;

  void addListener(GetStream rxGetx);

  void close();

  static RxInterface? proxy;

  StreamSubscription listen(void Function(T event) onData,
      {Function? onError, void Function()? onDone, bool? cancelOnError});
}
 
 
notifyChilds中的几行代码都有深意，一行行的解读下
 
 
     
  
  • final observer = RxInterface.proxy：RxInterface.proxy正常情况为空，但是，可能作为中间变量暂存对象的情况，现在暂时将他的对象取出来，存在observer变量中
    •  
  
  • RxInterface.proxy = _observer：将我们在 _ObxState类中实例化的 RxNotifier() 对象的地址，赋值给了RxInterface.proxy
     
   
       
    
    • 注意：这里，RxInterface.proxy中 RxNotifier() 实例，有当前Obx控件的setState() 方法
      •  
   
    •  
  
  • final result = widget.build()：这个赋值相当重要了！调用我们在外部传进的Widget
     
   
       
    
    • 如果这个Widget中有响应式变量，那么一定会调用该变量中获取 get value
      •  
    
    • 还记得get value的代码吗？
      mixin RxObjectMixin on NotifyManager {
  late T _value;
    
  T get value {
    if (RxInterface.proxy != null) {
      RxInterface.proxy!.addListener(subject);
    }
    return _value;
  }
}

mixin NotifyManager {
  GetStream subject = GetStream();
}
      •  
    
    • 终于建立起联系了，将变量中 GetStream 实例，添加到了Obx中的 RxNotifier() 实例；RxNotifier() 实例中有一个 subject（GetStream ） 实例，Rx类型中数据变化会触发 subject 变化，最终刷新Obx
      mixin NotifyManager {
  GetStream subject = GetStream();
  final _subscriptions = >{};

  bool get canUpdate => _subscriptions.isNotEmpty;
    
  void addListener(GetStream rxGetx) {
    if (!_subscriptions.containsKey(rxGetx)) {
      //重点 GetStream中listen方法是用来添加监听方法的，add的时候会刷新监听方法
      final subs = rxGetx.listen((data) {
        if (!subject.isClosed) subject.add(data);
      });
      final listSubscriptions =
          _subscriptions[rxGetx] ??= [];
      listSubscriptions.add(subs);
    }
  }
}
      •  
   
    •  
  
  • if (!_observer!.canUpdate) {}：这个判断就很简单了，如果我们传入的Widget中没有Rx类型变量， _subscriptions数组就会为空，这个判断就会过不了
    •  
  
  • RxInterface.proxy = observer：将RxInterface.proxy中原来的值，重新赋给自己，至此 _ObxState 中的 _observer对象地址，进行了一番奇幻旅游后，结束了自己的使命
    •  
 
 
 

   图示 
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第12张图片
 
 
总结
 
 
Obx的刷新机制，还是蛮有有趣的
 
 
     
  
  • Rx变量改变，自动刷新包裹其变量Obx控件，其它的Obx控件并不会刷新
    •  
  
  • 使用Obx控件，不需要写泛型！牛批！
    •  
 
 
 
但是，我认为Obx刷新机制，也是有着自身的缺陷的，从其实现原理上看，这是无法避免的
 
 
     
  
  • 因为Obx的自动刷新，必须需要每一个变量都自带监听触发机制；所以，所有的基础类型，实体以及列表，都需要重新封装，这会造成很严重的使用影响：变量的赋值，类型标定，刷新都很正常写法有差异，不熟悉该写法的人，看了后，会很难受
    •  
  
  • 因为对所有类型重新封装，经过上面的代码回溯，大家也发现，封装类型的代码相当多；封装类型占用资源肯定要比dart自带类型的大（这个问题可以避免：封装一个响应式的变量，并不一定需要很多代码，下面我给出了一个封装参考）
    •  
 
 
 
手搓一个状态管理框架
 
 
 
  
GetX内置了俩套状态管理机制，这边也会按照其刷新机制，手搓俩套出来
 
  
我会用极其简单的代码，再现俩套经典的机制
 
 
 
 
依赖注入
 
 
     
  
  • 在做刷新机制前，首先必须写一个依赖注入的类，我们需要自己管理逻辑层的那些实例
     
   
       
    
    • 我这边写了一个极其简单，仅实现三种基础功能：注入，获取，删除
      •  
   
    •  
 
 
 
///依赖注入，外部可将实例，注入该类中，由该类管理
class Easy {
  ///注入实例
  static T put(T dependency, {String? tag}) =>
      _EasyInstance().put(dependency, tag: tag);

  ///获取注入的实例
  static T find({String? tag, String? key}) =>
      _EasyInstance().find(tag: tag, key: key);

  ///删除实例
  static bool delete({String? tag, String? key}) =>
      _EasyInstance().delete(tag: tag, key: key);
}

///具体逻辑
class _EasyInstance {
  factory _EasyInstance() => _instance ??= _EasyInstance._();

  static _EasyInstance? _instance;

  _EasyInstance._();

  static final Map _single = {};

  ///注入实例
  T put(T dependency, {String? tag}) {
    final key = _getKey(T, tag);
    //只保存第一次注入：针对自动刷新机制优化，每次热重载的时候，数据不会重置
    _single.putIfAbsent(key, () => _InstanceInfo(dependency));
    return find(tag: tag);
  }

  ///获取注入的实例
  T find({String? tag, String? key}) {
    final newKey = key ?? _getKey(T, tag);
    var info = _single[newKey];

    if (info?.value != null) {
      return info!.value;
    } else {
      throw '"$T" not found. You need to call "Easy.put($T())""';
    }
  }

  ///删除实例
  bool delete({String? tag, String? key}) {
    final newKey = key ?? _getKey(T, tag);
    if (!_single.containsKey(newKey)) {
      print('Instance "$newKey" already removed.');
      return false;
    }

    _single.remove(newKey);
    print('Instance "$newKey" deleted.');
    return true;
  }

  String _getKey(Type type, String? name) {
    return name == null ? type.toString() : type.toString() + name;
  }
}

class _InstanceInfo {
  _InstanceInfo(this.value);

  T value;
}
 
 
     
  
  • 自定义一个监听类，这个类很重要，下面俩种机制都需要用到
    •  
 
 
 
///自定义个监听触发类
class EasyXNotifier {
  List _listeners = [];

  void addListener(VoidCallback listener) {
    _listeners.add(listener);
  }

  void removeListener(VoidCallback listener) {
    for (final entry in _listeners) {
      if (entry == listener) {
        _listeners.remove(entry);
        return;
      }
    }
  }

  void dispose() {
    _listeners.clear();
  }

  void notify() {
    if (_listeners.isEmpty) return;

    for (final entry in _listeners) {
      try {
        entry.call();
      } catch (e) {
        print(e.toString());
      }
    }
  }
}
 
 
EasyBuilder
 
 
实现
 
 
     
  
  • 该模式需要自定义一个基类
     
   
       
    
    • 我这地方写的极简，相关生命周期都没加，这个加起来也很容易，定义各个生命周期，在Builder控件里面触发，就可以了
      •  
    
    • 为了代码简洁，这个暂且不表
      •  
   
    •  
 
 
 
class EasyXController {
  EasyXNotifier xNotifier = EasyXNotifier();

  ///刷新控件
  void update() {
    xNotifier.notify();
  }
}
 
 
     
  
  • 再来看看最核心的EasyBuilder控件：这就搞定了！
     
   
       
    
    • 实现代码写的极其简单，希望大家思路能有所明晰
      •  
   
    •  
 
 
 
///刷新控件,自带回收机制
class EasyBuilder extends StatefulWidget {
  final Widget Function(T logic) builder;

  final String? tag;
  final bool autoRemove;

  const EasyBuilder({
    Key? key,
    required this.builder,
    this.autoRemove = true,
    this.tag,
  }) : super(key: key);

  @override
  _EasyBuilderState createState() => _EasyBuilderState();
}

class _EasyBuilderState
    extends State> {
  late T controller;

  @override
  void initState() {
    super.initState();

    controller = Easy.find(tag: widget.tag);
    controller.xNotifier.addListener(() {
      if (mounted) setState(() {});
    });
  }

  @override
  void dispose() {
    if (widget.autoRemove) {
      Easy.delete(tag: widget.tag);
    }
    controller.xNotifier.dispose();

    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return widget.builder(controller);
  }
}
 
 
使用
 
 
     
  
  • 使用很简单，先看下逻辑层
    •  
 
 
 
class EasyXCounterLogic extends EasyXController {
  var count = 0;

  void increase() {
    ++count;
    update();
  }
}
 
 
     
  
  • 界面层
    •  
 
 
 
class EasyXCounterPage extends StatelessWidget {
  final EasyXCounterLogic logic = Easy.put(EasyXCounterLogic());

  @override
  Widget build(BuildContext context) {
    return BaseScaffold(
      appBar: AppBar(title: const Text('EasyX-自定义EasyBuilder刷新机制')),
      body: Center(
        child: EasyBuilder(builder: (logic) {
          return Text(
            '点击了 ${logic.count} 次',
            style: TextStyle(fontSize: 30.0),
          );
        }),
      ),
      floatingActionButton: FloatingActionButton(
        onPressed: () => logic.increase(),
        child: Icon(Icons.add),
      ),
    );
  }
}
 
 
     
  
  • 效果图
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第13张图片
 
 
Ebx：自动刷新机制
 
 
 
  
自动刷新机制，因为没加泛型，所以无法确定自己内部使用了哪个注入实例，Getx中是在路由里面去回收这些实例的，但是，如果你没使用GetX的路由，又用Obx，你会发现，GetXController居然无法自动回收！！！
 
  
此处针对该场景，我会给出一种解决方案
 
 
 
 
实现
 
 
     
  
  • 在自动刷新的机制中，需要将基础类型进行封装
     
   
       
    
    • 主要逻辑在Rx中
      •  
    
    • set value 和 get value是关键
      •  
   
    •  
 
 
 
///拓展函数
extension IntExtension on int {
  RxInt get ebs => RxInt(this);
}

extension StringExtension on String {
  RxString get ebs => RxString(this);
}

extension DoubleExtension on double {
  RxDouble get ebs => RxDouble(this);
}

extension BoolExtension on bool {
  RxBool get ebs => RxBool(this);
}

///封装各类型
class RxInt extends Rx {
  RxInt(int initial) : super(initial);

  RxInt operator +(int other) {
    value = value + other;
    return this;
  }

  RxInt operator -(int other) {
    value = value - other;
    return this;
  }
}

class RxDouble extends Rx {
  RxDouble(double initial) : super(initial);

  RxDouble operator +(double other) {
    value = value + other;
    return this;
  }

  RxDouble operator -(double other) {
    value = value - other;
    return this;
  }
}

class RxString extends Rx {
  RxString(String initial) : super(initial);
}

class RxBool extends Rx {
  RxBool(bool initial) : super(initial);
}

///主体逻辑
class Rx {
  EasyXNotifier subject = EasyXNotifier();

  Rx(T initial) {
    _value = initial;
  }

  late T _value;

  bool firstRebuild = true;

  String get string => value.toString();

  @override
  String toString() => value.toString();

  set value(T val) {
    if (_value == val && !firstRebuild) return;
    firstRebuild = false;
    _value = val;

    subject.notify();
  }

  T get value {
    if (RxEasy.proxy != null) {
      RxEasy.proxy!.addListener(subject);
    }
    return _value;
  }
}
 
 
     
  
  • 需要写一个非常重要的中转类，这个也会储存响应式变量的监听对象
     
   
       
    
    • 这个类有着非常核心的逻辑：他将响应式变量和刷新控件关联起来了！
      •  
   
    •  
 
 
 
class RxEasy {
  EasyXNotifier easyXNotifier = EasyXNotifier();

  Map _listenerMap = {};

  bool get canUpdate => _listenerMap.isNotEmpty;

  static RxEasy? proxy;

  void addListener(EasyXNotifier notifier) {
    if (!_listenerMap.containsKey(notifier)) {
      //变量监听中刷新
      notifier.addListener(() {
        //刷新ebx中添加的监听
        easyXNotifier.notify();
      });
      //添加进入map中
      _listenerMap[notifier] = '';
    }
  }
}
 
 
     
  
  • 刷新控件Ebx
    •  
 
 
 
typedef WidgetCallback = Widget Function();

class Ebx extends StatefulWidget {
  const Ebx(this.builder, {Key? key}) : super(key: key);

  final WidgetCallback builder;

  @override
  _EbxState createState() => _EbxState();
}

class _EbxState extends State {
  RxEasy _rxEasy = RxEasy();

  @override
  void initState() {
    super.initState();

    _rxEasy.easyXNotifier.addListener(() {
      if (mounted) setState(() {});
    });
  }

  Widget get notifyChild {
    final observer = RxEasy.proxy;
    RxEasy.proxy = _rxEasy;
    final result = widget.builder();
    if (!_rxEasy.canUpdate) {
      throw 'Widget lacks Rx type variables';
    }
    RxEasy.proxy = observer;
    return result;
  }

  @override
  Widget build(BuildContext context) {
    return notifyChild;
  }

  @override
  void dispose() {
    _rxEasy.easyXNotifier.dispose();

    super.dispose();
  }
}
 
 
     
  
  • 在上面说了，在自动刷新机制中，自动回收依赖实例是个蛋筒的问题，此处我写了一个回收控件，可以解决此问题
     
   
       
    
    • 使用时，必须套一层了；如果大家有更好的思路，麻烦在评论里告知
      •  
   
    •  
 
 
 
class EasyBindWidget extends StatefulWidget {
  const EasyBindWidget({
    Key? key,
    this.bind,
    this.tag,
    this.binds,
    this.tags,
    required this.child,
  })  : assert(
          binds == null || tags == null || binds.length == tags.length,
          'The binds and tags arrays length should be equal\n'
          'and the elements in the two arrays correspond one-to-one',
        ),
        super(key: key);

  final Object? bind;
  final String? tag;

  final List? binds;
  final List? tags;

  final Widget child;

  @override
  _EasyBindWidgetState createState() => _EasyBindWidgetState();
}

class _EasyBindWidgetState extends State {
  @override
  Widget build(BuildContext context) {
    return widget.child;
  }

  @override
  void dispose() {
    _closeController();
    _closeControllers();

    super.dispose();
  }

  void _closeController() {
    if (widget.bind == null) {
      return;
    }

    var key = widget.bind.runtimeType.toString() + (widget.tag ?? '');
    Easy.delete(key: key);
  }

  void _closeControllers() {
    if (widget.binds == null) {
      return;
    }

    for (var i = 0; i < widget.binds!.length; i++) {
      var type = widget.binds![i].runtimeType.toString();

      if (widget.tags == null) {
        Easy.delete(key: type);
      } else {
        var key = type + (widget.tags?[i] ?? '');
        Easy.delete(key: key);
      }
    }
  }
} 
 
使用
 
 
     
  
  • 逻辑层，这次，咱们连基类都不需要写
    •  
 
 
 
class EasyXEbxCounterLogic {
  RxInt count = 0.ebs;

  ///自增
  void increase() => ++count;
}
 
 
     
  
  • 界面层：页面顶节点套了一个EasyBindWidget，可以保证依赖注入实例可以自动回收
    •  
 
 
 
class EasyXEbxCounterPage extends StatelessWidget {
  final EasyXEbxCounterLogic logic = Easy.put(EasyXEbxCounterLogic());

  @override
  Widget build(BuildContext context) {
    return EasyBindWidget(
      bind: logic,
      child: BaseScaffold(
        appBar: AppBar(title: const Text('EasyX-自定义Ebx刷新机制')),
        body: Center(
          child: Ebx(() {
            return Text(
              '点击了 ${logic.count.value} 次',
              style: TextStyle(fontSize: 30.0),
            );
          }),
        ),
        floatingActionButton: FloatingActionButton(
          onPressed: () => logic.increase(),
          child: Icon(Icons.add),
        ),
      ),
    );
  }
}
 
 
     
  
  • 效果图
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第14张图片
 
 
总结
 
 
这俩种刷新模式，含金量高的，应该还是自动刷新的机制，思路很有趣，响应式变量和刷新控件通过静态变量的形式建立起联系，cool！又是一种骚操作！
 
 
这俩套状态管理机制，我都给出了对依赖注入对象，自动回收的解决方案，希望对大家的思路有所启迪。
 
 
最后
 
 
终于把最后一篇GetX的原理剖析写完了（只针对GetX状态管理这部分内容），了了一桩心事。。。
 
 
     
  
  • 有些流程比较绕，特地画了一些图，图文并茂总会让人心情愉悦嘛......
    •  
 
 
 
【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）_第15张图片
 
 
如果大家认真看完了整片文章，可能会发现：状态管理+依赖注入，可以使得使用场景大大的被拓展
 
 
     
  
  • GetBuilder的自动回收就是借助依赖注入，无缝获取注入实例，从而实现自动回收的操作
    •  
  
  • 而且GetBuilder还无需额外传参数！
    •  
 
 
 
整篇文章写下来，我真的尽力了
 
 
     
  
  • 从InheritedWidget到路由
    •  
  
  • 然后到依赖注入
    •  
  
  • 再就是俩种状态框架原理剖析
    •  
  
  • 最后依据俩种刷新机制，手搓俩套状态管理框架
    •  
 
 
 
也算是层层递进的将其中的知识，一点点的展示在大家的面前，希望可以帮到各位！！！
 
 
 
  系列文章 + 相关地址 
 
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(【源码篇】Flutter GetX深度剖析 | 我们终将走出自己的路（万字图文）)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • 《策划经理回忆录之二》
                        路基雅虎

                        
    话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
    
                    
    • 
                    
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update
                        iBaoxing
github
                        
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）
                        研学随笔
arcgis经验分享
                        
    我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                    
  • 我的烦恼
                        余建梅

                        
    我的烦恼。女儿问我：“你给学生布置什么作文题目？”“《我的烦恼》。”“他们都这么大了，你觉得他们还有烦恼吗？”“有啊！每个人都会有自己烦恼。”“我不相信，大人是没有烦恼的，如果说一定有的话，你的烦恼和我写作业有关，而且是小烦恼。不像我，天天被你说，有这样的妈妈，烦恼是没完没了。”女儿愤愤不平。每个人都会有自己的烦恼，处在上有老下有小的年纪，烦恼多的数不完。想干好工作带好孩子，想孝顺父母又想经营好自
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 活给自己看，笑容才灿烂
                        听着了么

                        
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 怎么起诉借钱不还的人？怎样起诉欠款不还的人？
                        影子爱学习

                        
    怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
    
                    
    • 
                    
  • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
    第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • 今日囧事
                        唯愿岁月可回首

                        
    今天晚上，房东打来电话说晚上过来取个东西。晚上到家后，洗了一下水果，把卧室的空调打开，在卧室的阳台叠衣服。不一会儿，听见了敲门声，老公和丫头出去开门，果然是房东来了。由于我在叠衣服，床上比较乱，老公随手就把卧室门带上了。我赶紧把衣服收在柜子里，一拧门，好吧，打不开。听见外面热热闹闹的，我喊老公帮我开门，开了几次都开不开。丫头说：妈妈，你先在里面休息一会，我们正在找钥匙。听见外面房东拿了自己东西，老
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                                
  • 枚举的构造函数中抛出异常会怎样
                                    bylijinnan
javaenum单例
                                    
    首先从使用enum实现单例说起。 
 
为什么要用enum来实现单例？ 
这篇文章（ 
http://javarevisited.blogspot.sg/2012/07/why-enum-singleton-are-better-in-java.html）阐述了三个理由： 
1.enum单例简单、容易，只需几行代码： 
 

public enum Singleton {
	INSTANCE;
    
                                
    • 
                                
  • CMake 教程
                                    aigo
C++
                                    
    转自：http://xiang.lf.blog.163.com/blog/static/127733322201481114456136/ 
  
CMake是一个跨平台的程序构建工具，比如起自己编写Makefile方便很多。 
介绍：http://baike.baidu.com/view/1126160.htm 
本文件不介绍CMake的基本语法，下面是篇不错的入门教程： 
http:
    
                                
    • 
                                
  • cvc-complex-type.2.3: Element 'beans' cannot have character
                                    Cb123456
springWebgis
                                    
      cvc-complex-type.2.3: Element 'beans' cannot have character 
    Line 33 in XML document from ServletContext resource [/WEB-INF/backend-servlet.xml] is i
    
                                
    • 
                                
  • jquery实例:随页面滚动条滚动而自动加载内容
                                    120153216
jquery
                                    
    <script language="javascript">
$(function (){
	var i = 4;$(window).bind("scroll", function (event){
		//滚动条到网页头部的 高度，兼容ie,ff,chrome
		var top = document.documentElement.s
    
                                
    • 
                                
  • 将数据库中的数据转换成dbs文件
                                    何必如此
sqldbs
                                    
    旗正规则引擎通过数据库配置器（DataBuilder）来管理数据库，无论是Oracle，还是其他主流的数据都支持，操作方式是一样的。旗正规则引擎的数据库配置器是用于编辑数据库结构信息以及管理数据库表数据，并且可以执行SQL 语句，主要功能如下。 
1)数据库生成表结构信息： 
        主要生成数据库配置文件(.conf文
    
                                
    • 
                                
  • 在IBATIS中配置SQL语句的IN方式
                                    357029540
ibatis
                                    
    在使用IBATIS进行SQL语句配置查询时，我们一定会遇到通过IN查询的地方，在使用IN查询时我们可以有两种方式进行配置参数：String和List。具体使用方式如下： 
 
1.String:定义一个String的参数userIds，把这个参数传入IBATIS的sql配置文件，sql语句就可以这样写： 
 
 
 
<select id="getForms" param
    
                                
    • 
                                
  • Spring3 MVC 笔记（一）
                                    7454103
springmvcbeanRESTJSF
                                    
        
     自从 MVC 这个概念提出来之后 struts1.X  struts2.X   jsf 。。。。。 
这个view 层的技术一个接一个！ 都用过！不敢说哪个绝对的强悍！ 
要看业务，和整体的设计！ 
 
     最近公司要求开发个新系统！
    
                                
    • 
                                
  • Timer与Spring Quartz 定时执行程序
                                    darkranger
springbean工作quartz
                                    
    有时候需要定时触发某一项任务。其实在jdk1.3，java sdk就通过java.util.Timer提供相应的功能。一个简单的例子说明如何使用，很简单： 1、第一步，我们需要建立一项任务，我们的任务需要继承java.util.TimerTask package com.test; import java.text.SimpleDateFormat; import java.util.Date; 
    
                                
    • 
                                
  • 大端小端转换，le32_to_cpu 和cpu_to_le32
                                    aijuans
C语言相关
                                    
    大端小端转换，le32_to_cpu 和cpu_to_le32   字节序  
http://oss.org.cn/kernel-book/ldd3/ch11s04.html 
        小心不要假设字节序. PC 存储多字节值是低字节为先(小端为先, 因此是小端), 一些高级的平台以另一种方式(大端)
    
                                
    • 
                                
  • Nginx负载均衡配置实例详解
                                    avords

                                    
    [导读] 负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。负载均衡先来简单了解一下什么是负载均衡，单从字面上的意思来理解就可以解  负载均衡是我们大流量网站要做的一个东西，下面我来给大家介绍在Nginx服务器上进行负载均衡配置方法，希望对有需要的同学有所帮助哦。 
负载均衡 
先来简单了解一下什么是负载均衡
    
                                
    • 
                                
  • 乱说的
                                    houxinyou
框架敏捷开发软件测试
                                    
    从很久以前，大家就研究框架，开发方法，软件工程，好多！反正我是搞不明白！   
这两天看好多人研究敏捷模型，瀑布模型！也没太搞明白.    
不过感觉和程序开发语言差不多，   
瀑布就是顺序，敏捷就是循环.    
瀑布就是需求、分析、设计、编码、测试一步一步走下来。而敏捷就是按摸块或者说迭代做个循环，第个循环中也一样是需求、分析、设计、编码、测试一步一步走下来。   
  
也可以把软件开发理
    
                                
    • 
                                
  • 欣赏的价值——一个小故事
                                    bijian1013
有效辅导欣赏欣赏的价值
                                    
    　　第一次参加家长会，幼儿园的老师说："您的儿子有多动症，在板凳上连三分钟都坐不了，你最好带他去医院看一看。"　　回家的路上，儿子问她老师都说了些什么，她鼻子一酸，差点流下泪来。因为全班30位小朋友，惟有他表现最差；惟有对他，老师表现出不屑，然而她还在告诉她的儿子："老师表扬你了，说宝宝原来在板凳上坐不了一分钟，现在能坐三分钟。其他妈妈都非常羡慕妈妈，因为全班只有宝宝
    
                                
    • 
                                
  • 包冲突问题的解决方法
                                    bingyingao
eclipsemavenexclusions包冲突
                                    
    包冲突是开发过程中很常见的问题： 
其表现有： 
1.明明在eclipse中能够索引到某个类，运行时却报出找不到类。 
2.明明在eclipse中能够索引到某个类的方法，运行时却报出找不到方法。 
3.类及方法都有，以正确编译成了.class文件，在本机跑的好好的，发到测试或者正式环境就 
抛如下异常： 
 
java.lang.NoClassDefFoundError: Could not in
    
                                
    • 
                                
  • 【Spark七十五】Spark Streaming整合Flume-NG三之接入log4j
                                    bit1129
Stream
                                    
    先来一段废话： 
实际工作中，业务系统的日志基本上是使用Log4j写入到日志文件中的，问题的关键之处在于业务日志的格式混乱，这给对日志文件中的日志进行统计分析带来了极大的困难，或者说，基本上无法进行分析，每个人写日志的习惯不同，导致日志行的格式五花八门，最后只能通过grep来查找特定的关键词缩小范围，但是在集群环境下，每个机器去grep一遍，分析一遍，这个效率如何可想之二，大好光阴都浪费在这上面了
    
                                
    • 
                                
  • sudoku solver in Haskell
                                    bookjovi
sudokuhaskell
                                    
    这几天没太多的事做，想着用函数式语言来写点实用的程序，像fib和prime之类的就不想提了（就一行代码的事），写什么程序呢？在网上闲逛时发现sudoku游戏，sudoku十几年前就知道了，学生生涯时也想过用C/Java来实现个智能求解，但到最后往往没写成，主要是用C/Java写的话会很麻烦。 
  
现在写程序，本人总是有一种思维惯性，总是想把程序写的更紧凑，更精致，代码行数最少，所以现
    
                                
    • 
                                
  • java apache ftpClient
                                    bro_feng
java
                                    
    最近使用apache的ftpclient插件实现ftp下载，遇见几个问题，做如下总结。 
1. 上传阻塞，一连串的上传，其中一个就阻塞了，或是用storeFile上传时返回false。查了点资料，说是FTP有主动模式和被动模式。将传出模式修改为被动模式ftp.enterLocalPassiveMode();然后就好了。 
 
看了网上相关介绍，对主动模式和被动模式区别还是比较的模糊，不太了解被动模
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-工厂方法模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 
 
 


package design.pattern;

/*
 * 工厂方法模式：使一个类的实例化延迟到子类
 * 某次，我在工作不知不觉中就用到了工厂方法模式（称为模板方法模式更恰当。2012-10-29）：
 * 有很多不同的产品，它
    
                                
    • 
                                
  • 面试记录语
                                    chenyu19891124
招聘
                                    
    或许真的在一个平台上成长成什么样，都必须靠自己去努力。有了好的平台让自己展示，就该好好努力。今天是自己单独一次去面试别人，感觉有点小紧张，说话有点打结。在面试完后写面试情况表，下笔真的好难，尤其是要对面试人的情况说明真的好难。 
今天面试的是自己同事的同事，现在的这个同事要离职了，介绍了我现在这位同事以前的同事来面试。今天这位求职者面试的是配置管理，期初看了简历觉得应该很适合做配置管理，但是今天面
    
                                
    • 
                                
  • Fire Workflow 1.0正式版终于发布了
                                    comsci
工作workflowGoogle
                                    
    Fire Workflow 是国内另外一款开源工作流，作者是著名的非也同志，哈哈.... 
 官方网站是 http://www.fireflow.org 
 
 经过大家努力,Fire Workflow 1.0正式版终于发布了 
 
 正式版主要变化: 
1、增加IWorkItem.jumpToEx(...)方法，取消了当前环节和目标环节必须在同一条执行线的限制，使得自由流更加自由 
2、增加IT
    
                                
    • 
                                
  • Python向脚本传参
                                    daizj
python脚本传参
                                    
    如果想对python脚本传参数，python中对应的argc, argv(c语言的命令行参数)是什么呢？ 
需要模块：sys 
参数个数：len(sys.argv) 
脚本名：    sys.argv[0] 
参数1：     sys.argv[1] 
参数2：     sys.argv[
    
                                
    • 
                                
  • 管理用户分组的命令gpasswd
                                    dongwei_6688
passwd
                                    
    NAME：  gpasswd - administer the /etc/group file 
SYNOPSIS： 
 gpasswd group 
 gpasswd -a user group 
 gpasswd -d user group 
 gpasswd -R group 
 gpasswd -r group 
 gpasswd [-A user,...] [-M user,...] g
    
                                
    • 
                                
  • 郝斌老师数据结构课程笔记
                                    dcj3sjt126com
数据结构与算法
                                    
    <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
                                
    • 
                                
  • yii2 cgridview加上选择框进行操作
                                    dcj3sjt126com
GridView
                                    
    页面代码
<?=Html::beginForm(['controller/bulk'],'post');?>
<?=Html::dropDownList('action','',[''=>'Mark selected as: ','c'=>'Confirmed','nc'=>'No Confirmed'],['class'=>'dropdown',])
    
                                
    • 
                                
  • linux mysql
                                    fypop
linux
                                    
    enquiry mysql version in centos linux 
yum list installed | grep mysql 
yum -y remove mysql-libs.x86_64 
enquiry mysql version in yum repositoryyum list | grep mysql oryum -y list mysql* 
install mysq
    
                                
    • 
                                
  • Scramble String
                                    hcx2013
String
                                    
    Given a string s1, we may represent it as a binary tree by partitioning it to two non-empty substrings recursively. 
Below is one possible representation of s1 = "great":
    
                                
    • 
                                
  • 跟我学Shiro目录贴
                                    jinnianshilongnian
跟我学shiro
                                    
    历经三个月左右时间，《跟我学Shiro》系列教程已经完结，暂时没有需要补充的内容，因此生成PDF版供大家下载。最近项目比较紧，没有时间解答一些疑问，暂时无法回复一些问题，很抱歉，不过可以加群（334194438/348194195）一起讨论问题。 
  
  
----广告-----------------------------------------------------
    
                                
    • 
                                
  • nginx日志切割并使用flume-ng收集日志
                                    liyonghui160com

                                    
      
   nginx的日志文件没有rotate功能。如果你不处理，日志文件将变得越来越大，还好我们可以写一个nginx日志切割脚本来自动切割日志文件。第一步就是重命名日志文件，不用担心重命名后nginx找不到日志文件而丢失日志。在你未重新打开原名字的日志文件前，nginx还是会向你重命名的文件写日志，linux是靠文件描述符而不是文件名定位文件。第二步向nginx主
    
                                
    • 
                                
  • Oracle死锁解决方法
                                    pda158
oracle
                                    
    　select p.spid,c.object_name,b.session_id,b.oracle_username,b.os_user_name from v$process p,v$session a, v$locked_object b,all_objects c where p.addr=a.paddr and a.process=b.process and c.object_id=b.
    
                                
    • 
                                
  • java之List排序
                                    shiguanghui
list排序
                                    
       在Java Collection Framework中定义的List实现有Vector，ArrayList和LinkedList。这些集合提供了对对象组的索引访问。他们提供了元素的添加与删除支持。然而，它们并没有内置的元素排序支持。 　　你能够使用java.util.Collections类中的sort()方法对List元素进行排序。你既可以给方法传递
    
                                
    • 
                                
  • servlet单例多线程
                                    utopialxw
单例多线程servlet
                                    
    转自http://www.cnblogs.com/yjhrem/articles/3160864.html 
和   http://blog.chinaunix.net/uid-7374279-id-3687149.html 
Servlet 单例多线程 
Servlet如何处理多个请求访问？Servlet容器默认是采用单实例多线程的方式处理多个请求的：1.当web服务器启动的
    
                                
    •