Flutter插件molc的使用_MoLc 是一个基于 Provider 的 UI 组件

Flutter插件molc的使用_MoLc 是一个基于 Provider 的 UI 组件

MoLc介绍

MoLc 是一个基于 Provider 的 UI 组件。

通过使用 MoLc，您可以：

  • 解耦业务逻辑、UI 和 UI 状态模型。
  • 实现跨页面的状态共享。
  • 实现全局模型的部分刷新。

MoLcWidget 示例

首先，您需要在您的项目中引入 molc 插件。然后，您可以在需要的地方使用 MoLcWidget。

class ExamplePage extends StatelessWidget {
  const ExamplePage({Key? key}) : super(key: key);

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MoLcWidget<_ExampleModel, _ExampleLogic>(
      modelCreate: (_) => _ExampleModel(), // 创建一个实例化的 _ExampleModel
      logicCreate: (_) => _ExampleLogic(), // 创建一个实例化的 _ExampleLogic
      init: (_, model, logic) => logic.init(model), // 初始化逻辑
      builder: (context, model, logic, __) => Container(), // 构建 UI
    );
  }
}

class _ExampleModel extends Model {}

class _ExampleLogic extends Logic {
  void init(_ExampleModel model) {}
}

分享你的模型步骤

首先，您需要在应用的顶层包裹一个 TopProvider。这样可以将顶层模型传递给整个应用。

TopProvider(
  providers: ..., // 您可以在这里自定义顶层模型
  child: MaterialApp(
    home: MainPage(),
  ),
)

接下来，您需要在您想要共享的模型上混入 PartModel。

class Test1Model extends WidgetModel with PartModel {}

现在，您可以在任何地方找到并使用该部分模型，如果它存在且处于活动状态。

find<Test1Model>()?.refresh();

全局模型的部分刷新

为了实现全局模型的部分刷新，您可以定义一个事件枚举，并将其混合到顶层模型中。

enum TestEvent { event1, event2, event3 }

然后，在顶层模型中混入 EventModel。

class TestTopModel extends TopModel with EventModel<TestEvent> {}

在事件监听器模型中混入 EventConsumerForModel。

class Test2Model extends Model with EventConsumerForModel {}

现在，您可以部分刷新全局模型。

testTopModel.refreshEvent(TestEvent.event1);

完整示例代码

以下是完整的示例代码，展示了如何使用 MoLc 插件。

import 'dart:async';

import 'package:flutter/material.dart';
import 'package:molc/molc.dart';

void main() {
  runApp(
    TopProvider(
      providers: topModels,
      child: MaterialApp(
        home: MainPage(),
      ),
    ),
  );
}

final topModels = [
  ChangeNotifierProvider(create: (_) => TestEventModel()),
];

enum TestEvent { event1, event2, event3, event4 }

class TestEventModel extends TopModel with EventModel<TestEvent> {}

class MainPage extends StatelessWidget {
  MainPage({Key? key}) : super(key: key);

  final abc = 100.mt;

  final def = 999.mt;

  final ghi = 100.mt;

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MoLcWidget<_MainModel, _MainLogic>(
      modelCreate: (_) => _MainModel(),
      logicCreate: (_) => _MainLogic(),
      init: (_, model, logic) => logic.init(model),
      builder: (_, model, logic, __) {
        debugPrint('build==>$runtimeType');
        return Scaffold(
          appBar: AppBar(),
          body: CustomScrollView(
            slivers: [
              SliverToBoxAdapter(
                child: Container(
                  color: Colors.white,
                  child: Column(
                    mainAxisSize: MainAxisSize.min,
                    crossAxisAlignment: CrossAxisAlignment.start,
                    children: [
                      TextButton(
                        onPressed: () {
                          model.refresh();
                        },
                        child: const Text('刷新 MainModel'),
                      ),
                      TextButton(
                        onPressed: () {
                          context
                              .read<TestEventModel>()
                              .refreshEvent(TestEvent.event4);
                          logic.listen();
                        },
                        child: const Text('刷新 event4'),
                      ),
                      TextButton(
                        onPressed: () {
                          find<_Part1Model>()?.refresh();
                        },
                        child: const Text('刷新 Part1'),
                      ),
                      const Part1(),
                      const SizedBox(
                        height: 20,
                      ),
                      const Part2(),
                      const SizedBox(
                        height: 20,
                      ),
                      const Part3(),
                      const SizedBox(
                        height: 20,
                      ),
                      const Part4(),
                      const SizedBox(
                        height: 20,
                      ),
                      NoMoWidget<int>(
                        value: 99,
                        builder: (_, model, __) {
                          debugPrint('build==> $runtimeType');
                          return Row(
                            children: [
                              Text(
                                'nomo2:${model.value}',
                              ),
                              TextButton(
                                onPressed: () {
                                  model
                                    ..value += 1
                                    ..refresh();
                                },
                                child: const Text('刷新 _NoMo2'),
                              ),
                            ],
                          );
                        },
                      ),
                      const SizedBox(
                        height: 20,
                      ),
                    ],
                  ),
                ),
              ),
              SliverToBoxAdapter(
                child: SizedBox(
                  height: 100,
                  child: ListView.builder(
                    itemCount: 10,
                    itemBuilder: (_, __) => Column(
                      children: [
                        MutableWidget(
                          (context) => Row(
                            children: [
                              Text(def.value.toString()),
                              TextButton(
                                  onPressed: () {
                                    def.value -= 1;
                                  },
                                  child: const Text('-1')),
                              MutableWidget(
                                (context) => Row(
                                  children: [
                                    Text((ghi.value + abc.value).toString()),
                                    TextButton(
                                        onPressed: () {
                                          ghi.value += 1;
                                        },
                                        child: const Text('+1')),
                                  ],
                                ),
                              )
                            ],
                          ),
                        ),
                        MutableWidget(
                          (context) => Row(
                            children: [
                              Text(abc.value.toString()),
                              TextButton(
                                  onPressed: () {
                                    abc.value += 1;
                                  },
                                  child: const Text('+1')),
                            ],
                          ),
                        ),
                      ],
                    ),
                  ),
                ),
              ),
            ],
          ),
        );
      },
    );
  }
}

class _MainModel extends WidgetModel {}

class _MainLogic extends Logic {
  StreamController? controller;
  StreamSubscription? sub;

  void init(_MainModel model) {
    model.context.read<TestEventModel>();
    controller = StreamController();
    listen();
  }

  listen() {
    sub?.cancel();
    sub = controller?.stream.asBroadcastStream().listen((event) {
      debugPrint('$event');
    });
  }
}

class Part1 extends StatelessWidget {
  const Part1({Key? key}) : super(key: key);

  [@override](/user/override)
  Widget build(BuildContext context) {
    return ModelWidget<_Part1Model>(
      create: (_) => _Part1Model(),
      builder: (_, model, __) {
        debugPrint('build==> $runtimeType');
        return Row(
          children: [
            Text(
              'part1:${model.part1Num}',
            ),
            TextButton(
              onPressed: () {
                model.part1Num += 1;
                model.refresh();
              },
              child: const Text('刷新 _Part1Model'),
            ),
          ],
        );
      },
    );
  }
}

class _Part1Model extends Model with ExposedMixin {
  int part1Num = 66;
}

class Part2 extends StatelessWidget {
  const Part2({Key? key}) : super(key: key);

  [@override](/user/override)
  Widget build(BuildContext context) {
    return LogicWidget<_Part2Logic>(
      create: (_) => _Part2Logic(),
      init: (_, logic) => logic.init(),
      builder: (context, logic) {
        debugPrint('build==> $runtimeType');
        return Row(
          children: [
            TextButton(
              onPressed: () {
                logic.request(context);
              },
              child: const Text('_Part2Logic.request\n然后刷新 _MainModel'),
            ),
          ],
        );
      },
    );
  }
}

class _Part2Logic extends Logic {
  void init() {}

  void request(BuildContext context) async {
    await Future.delayed(const Duration(seconds: 1));
    context.read<_MainModel>().refresh();
  }
}

class Part3 extends StatelessWidget {
  const Part3({Key? key}) : super(key: key);

  [@override](/user/override)
  Widget build(BuildContext context) {
    return NoMoWidget<int>(
      value: 99,
      builder: (_, model, __) {
        debugPrint('build==> $runtimeType');
        return Row(
          children: [
            Text(
              'nomo:${model.value}',
            ),
            TextButton(
              onPressed: () {
                model
                  ..value += 1
                  ..refresh();
              },
              child: const Text('刷新 _NoMo'),
            ),
          ],
        );
      },
    );
  }
}

class Part4 extends StatelessWidget {
  const Part4({Key? key}) : super(key: key);

  [@override](/user/override)
  Widget build(BuildContext context) {
    return MoLcWidget<_Part4Model, _Part4Logic>(
        modelCreate: (_) => _Part4Model(),
        logicCreate: (_) => _Part4Logic(),
        init: (_, model, logic) => logic.init(model),
        builder: (_, model, logic, __) {
          debugPrint('build==> $runtimeType');

          return Row(
            children: const [
              Text('part4'),
            ],
          );
        });
  }
}

class _Part4Model extends Model with ExposedMixin, EventConsumerMixin {}

class _Part4Logic extends Logic {
  void init(_Part4Model model) {
    model.listenTopModelEvent(TestEvent.event4);
  }
}

更多关于Flutter插件molc的使用_MoLc 是一个基于 Provider 的 UI 组件的实战教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter插件molc的使用_MoLc 是一个基于 Provider 的 UI 组件的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


在Flutter开发中，插件是扩展应用程序功能的重要方式。由于你提到的插件名称为“molc”且描述未定义，我将基于该名称进行合理推测，并提供一些可能的用途和示例，帮助你理解如何可能使用这个插件。

1. 合理推测插件功能

“molc”这个名称可能代表以下几种功能：

  • MOLC (Mobile Offline Local Cache): 可能与本地缓存、离线存储相关。
  • MOLC (Multi-Option List Chooser): 可能是一个多选列表或选择器插件。
  • MOLC (Mobile Online Local Communication): 可能是用于本地与在线通信的插件。

接下来，我将基于这些推测，分别给出可能的使用场景和示例代码。

2. 推测1：本地缓存（Mobile Offline Local Cache）

如果molc是一个本地缓存插件，它可能用于存储数据以支持离线模式。

示例代码：

import 'package:flutter/material.dart';
import 'package:molc/molc.dart'; // 假设的molc插件

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: CacheExample(),
    );
  }
}

class CacheExample extends StatefulWidget {
  [@override](/user/override)
  _CacheExampleState createState() => _CacheExampleState();
}

class _CacheExampleState extends State<CacheExample> {
  String _cachedData = 'No data';

  Future<void> _loadCachedData() async {
    String data = await Molc.load('key'); // 假设Molc提供load方法
    setState(() {
      _cachedData = data ?? 'No data found';
    });
  }

  Future<void> _saveData() async {
    await Molc.save('key', 'Hello, MOLC!'); // 假设Molc提供save方法
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('MOLC Cache Example')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Cached Data: $_cachedData'),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: _saveData,
              child: Text('Save Data'),
            ),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: _loadCachedData,
              child: Text('Load Cached Data'),
            ),
          ],
        ),
      ),
    );
  }
}

3. 推测2：多选列表（Multi-Option List Chooser）

如果molc是一个多选列表插件，它可能用于实现选项选择功能。

示例代码：

import 'package:flutter/material.dart';
import 'package:molc/molc.dart'; // 假设的molc插件

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: MultiSelectExample(),
    );
  }
}

class MultiSelectExample extends StatefulWidget {
  [@override](/user/override)
  _MultiSelectExampleState createState() => _MultiSelectExampleState();
}

class _MultiSelectExampleState extends State<MultiSelectExample> {
  List<String> _selectedItems = [];

  Future<void> _openMultiSelect() async {
    final List<String>? result = await Molc.showMultiSelect(
      items: ['Option 1', 'Option 2', 'Option 3'], // 假设Molc提供showMultiSelect方法
    );
    if (result != null) {
      setState(() {
        _selectedItems = result;
      });
    }
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('MOLC Multi-Select Example')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Selected Items: ${_selectedItems.join(", ")}'),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: _openMultiSelect,
              child: Text('Open Multi-Select'),
            ),
          ],
        ),
      ),
    );
  }
}

4. 推测3：本地与在线通信（Mobile Online Local Communication）

如果molc是一个通信插件，它可能用于管理本地与服务器之间的数据同步。

示例代码：

import 'package:flutter/material.dart';
import 'package:molc/molc.dart'; // 假设的molc插件

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      home: CommunicationExample(),
    );
  }
}

class CommunicationExample extends StatefulWidget {
  [@override](/user/override)
  _CommunicationExampleState createState() => _CommunicationExampleState();
}

class _CommunicationExampleState extends State<CommunicationExample> {
  String _response = 'No response';

  Future<void> _fetchData() async {
    String data = await Molc.fetchData(); // 假设Molc提供fetchData方法
    setState(() {
      _response = data;
    });
  }

  [@override](/user/override)
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: Text('MOLC Communication Example')),
      body: Center(
        child: Column(
          mainAxisAlignment: MainAxisAlignment.center,
          children: [
            Text('Server Response: $_response'),
            SizedBox(height: 20),
            ElevatedButton(
              onPressed: _fetchData,
              child: Text('Fetch Data'),
            ),
          ],
        ),
      ),
    );
  }
}
回到顶部