Flutter多模块依赖注入插件flutter_multi_module_di的使用

发布于 1周前 作者 sinazl 来自 Flutter

Flutter多模块依赖注入插件flutter_multi_module_di的使用

安装

在你的 pubspec.yaml 文件的 dependencies: 部分添加以下行:

dependencies:
    flutter_multi_module_di: latest_version

重要提示:

从 2.0.0 版本开始,flutter_multi_module_di 使用了 null-safe 代码。

多模块示例

你可以为整个应用程序、小部件和组件使用依赖树。

使用

基础用法

创建一个主页面并使用 ChildInjectorStatefulWidget 包装它。这将创建一个包含子模块和父依赖项的单例模块。

class MainPage extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return ChildInjectorStatefulWidget(
      childModuleBuilder: () => MainModule(context), // 子模块构建器
      injectorBuilder: (i) => _MainWidget(i.get(), i.get(name: "test_1")), // 注入器构建器
    );
  }
}

class _MainWidget extends StatelessWidget {
  final MainBloc _bloc;
  final String _testSrt;

  _MainWidget(this._bloc, this._testSrt);

  [@override](/user/override)
  Widget build(BuildContext context) {
    // 构建小部件...
    return Container();
  }
}

配置依赖项

你可以通过扩展 WidgetModule 类来配置依赖项。

class MainModule extends WidgetModule {
  MainModule(BuildContext context) : super(context);

  [@override](/user/override)
  void configureWidget(Binder binder) {
    binder
      ..bindLazySingleton((i, _) => MainBloc(i.get(), i.get())..add(MainPageOpenedEvent()))
      ..bindLazySingleton((i, _) => MainNavigator(i.get()));
  }
}

或者使用普通的 Dart 模块。

class TestModule extends Module {
  [@override](/user/override)
  void configure(Binder binder) {
    // 配置依赖项...
  }
}

获取依赖项

你可以在任何地方引用注入器,就像引用其他 InheritedWidget 一样。

class SomeWidget extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    final injector = InjectorWidget.of(context);
    final apiKey = injector.get(name: "api_key");
    return SomeContainerNeedingTheKey(apiKey);
  }
}

你也可以使用 InjectorWidgetMixin

class SomeWidget extends StatelessWidget with InjectorWidgetMixin {
  [@override](/user/override)
  Widget buildWithInjector(BuildContext context, Injector injector) {
    final object = injector.get<Object>();
    print(object);
    return Container();
  }
}

全部API

ChildInjectorStatefulWidget

创建一个包含子模块和父依赖项的单例模块。

class MainPage extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return ChildInjectorStatefulWidget(
      childModuleBuilder: () => MainModule(context),
      injectorBuilder: (i) => _MainWidget(i.get(), i.get(name: "test_1")),
    );
  }
}

ChildInjectorWidget

创建一个新的模块,包含子模块和父依赖项。

class MainPage extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return ChildInjectorWidget(
      childModule: MainModule(context),
      injectorBuilder: (injector) {
        // 在这里配置注入器...
        return Container();
      },
    );
  }
}

InjectorWidget

创建一个包含注入器的小部件。

[@override](/user/override)
Widget build(BuildContext context) {
  return InjectorWidget(
    child: Text(""),
    injector: Injector.fromModule(module: ...),
    autoDispose: true, // 默认值为 true
  );
}

InjectorWidgetMixin

使用注入器混合类。

class TestWidget with InjectorWidgetMixin {
  [@override](/user/override)
  Widget buildWithInjector(BuildContext context, Injector injector) {
    injector.get(name: "test_key");
    return Container();
  }
}

WithInjectorWidget & WithInstanceWidget

使用注入器的小部件。

[@override](/user/override)
Widget build(BuildContext context) {
  return WithInjectorWidget(
    builder: (injector) {
      injector.get(name: "test");
      return Container();
    },
  );
}

[@override](/user/override)
Widget build(BuildContext context) {
  return WithInstanceWidget<SharedPreferences>(
    builder: (sharedPrefs) {
      return Container();
    },
  );
}

ModuleWidget

创建一个模块小部件。

class TestWidget extends ModuleWidget {
  [@override](/user/override)
  void configure(Binder binder) {
    // 配置依赖项...
  }
}

完整示例代码

import 'package:flutter/material.dart';
import 'package:flutter_multi_module_di/flutter_multi_module_di.dart';
import 'package:flutter_multi_module_di_example/widget/main_page.dart';

import 'di/app_module.dart';

void main() => runApp(MyApp());

class MyApp extends StatelessWidget {
  [@override](/user/override)
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: Material(
        child: FutureBuilder<Module>(
          future: AppModule.create(context),
          builder: (context, future) {
            if (future?.data == null) {
              return Container();
            }

            return InjectorWidget(
              injector: Injector.fromModule(module: future.data),
              child: MainPage(),
            );
          },
        ),
      ),
    );
  }
}

更多关于Flutter多模块依赖注入插件flutter_multi_module_di的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html

1 回复

更多关于Flutter多模块依赖注入插件flutter_multi_module_di的使用的实战系列教程也可以访问 https://www.itying.com/category-92-b0.html


当然,我可以为你提供一个关于如何使用 flutter_multi_module_di 插件进行多模块依赖注入的示例代码。这个插件允许你在 Flutter 应用中管理跨模块的依赖注入。以下是一个简单的示例,展示如何设置和使用 flutter_multi_module_di

1. 添加依赖

首先,在你的 pubspec.yaml 文件中添加 flutter_multi_module_di 依赖:

dependencies:
  flutter:
    sdk: flutter
  flutter_multi_module_di: ^最新版本号  # 请替换为实际最新版本号

然后运行 flutter pub get 来获取依赖。

2. 配置依赖注入容器

创建一个全局的依赖注入容器。通常在应用的入口文件(如 main.dart)中初始化这个容器。

import 'package:flutter/material.dart';
import 'package:flutter_multi_module_di/flutter_multi_module_di.dart';
import 'module_a/module_a.dart';
import 'module_b/module_b.dart';

void main() {
  // 创建依赖注入容器
  final container = DIContainer();

  // 注册模块 A 和模块 B 的依赖
  container.registerModule(ModuleA());
  container.registerModule(ModuleB());

  // 获取依赖并使用它们
  final myServiceA = container.get<MyServiceA>();
  final myServiceB = container.get<MyServiceB>();

  // 这里只是为了演示,实际中你不会在 main 函数中使用服务
  // 通常你会将这些服务传递给需要的 widget

  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('Flutter Multi Module DI Demo')),
        body: Center(child: Text('Hello, DI!')),
      ),
    );
  }
}

3. 定义模块和依赖

接下来,我们定义两个模块,每个模块都有自己的服务。

Module A

import 'package:flutter_multi_module_di/flutter_multi_module_di.dart';

class MyServiceA {
  void doSomething() {
    print('MyServiceA is doing something');
  }
}

class ModuleA implements DIModule {
  @override
  void registerDependencies(DIContainer container) {
    container.registerSingleton<MyServiceA>(() => MyServiceA());
  }
}

Module B

import 'package:flutter_multi_module_di/flutter_multi_module_di.dart';

class MyServiceB {
  MyServiceB(this.myServiceA);

  final MyServiceA myServiceA;

  void doSomethingWithA() {
    myServiceA.doSomething();
    print('MyServiceB is doing something with MyServiceA');
  }
}

class ModuleB implements DIModule {
  @override
  void registerDependencies(DIContainer container) {
    container.registerFactory<MyServiceB>(
      () => MyServiceB(container.get<MyServiceA>()),
    );
  }
}

4. 使用依赖

最后,在需要使用这些服务的地方,从容器中获取它们。例如,在一个 Widget 中:

import 'package:flutter/material.dart';
import 'package:flutter_multi_module_di/flutter_multi_module_di.dart';
import 'main.dart'; // 假设容器是在 main.dart 中初始化的

class MyWidget extends StatelessWidget {
  final DIContainer container;

  MyWidget({required this.container});

  @override
  Widget build(BuildContext context) {
    final myServiceB = container.get<MyServiceB>();
    return ElevatedButton(
      onPressed: () {
        myServiceB.doSomethingWithA();
      },
      child: Text('Press me'),
    );
  }
}

注意:在实际应用中,通常不会直接从 main.dart 传递 DIContainer 到每个 Widget。相反,你可能会使用某种提供器模式(如 Provider)来在整个应用中访问依赖注入容器。

总结

以上示例展示了如何使用 flutter_multi_module_di 插件进行多模块依赖注入。通过定义模块和服务,并在全局容器中注册它们,你可以轻松地在应用的不同部分共享和重用这些服务。

回到顶部