Flutter抽象注册管理插件reg_it_abstract的使用

reg it abstract 是一个用于在Dart中实现依赖注入（DI）容器抽象的库。它提供了一种灵活且强大的方式来管理应用程序中的依赖项。

安装

将 reg_it_abstract 添加到您的 pubspec.yaml 文件中：

dependencies:
  reg_it_abstract:
    git:
      url: https://github.com/your_username/reg_it_abstract.git
      ref: main

然后运行以下命令安装依赖：

flutter pub get

使用

核心抽象与默认实现

以下是 reg_it_abstract 中的核心接口和默认实现：

import 'package:reg_it_abstract/reg_it_abstract.dart';

// 注册器接口
abstract interface class Registrar<T> {
  T get instance;
  void dispose();
}

// 同步工厂接口
abstract class SyncFactory<T> implements Registrar<SyncFactory<T>> {
  T call();
}

// 异步工厂接口
abstract class AsyncFactory<T> implements Registrar<AsyncFactory<T>> {
  Future<T> call();
}

// 单例注册器
class SingletonRegistrar<T> implements Registrar<T> {
  @override
  final T instance;

  const SingletonRegistrar(this.instance);

  @override
  void dispose() {}
}

// 同步工厂注册器
class SyncFactoryRegistrar<T> implements SyncFactory<T> {
  final T Function() _constructor;

  const SyncFactoryRegistrar(this._constructor);

  @override
  SyncFactory<T> get instance => this;

  @override
  T call() => _constructor();

  @override
  void dispose() {}
}

// 异步工厂注册器
class AsyncFactoryRegistrar<T> implements AsyncFactory<T> {
  final Future<T> Function() _constructor;

  AsyncFactoryRegistrar(this._constructor);

  @override
  Future<T> call() => _constructor();

  @override
  AsyncFactory<T> get instance => this;

  @override
  void dispose() {}
}

// 懒加载单例注册器
class LazySingletonRegistrar<T> implements Registrar<T> {
  T? _instance;
  final T Function() _constructor;

  LazySingletonRegistrar(this._constructor);

  @override
  T get instance => _instance ??= _constructor();

  @override
  void dispose() {}
}

// 注册表接口
abstract interface class Registry {
  void put<T>(final Registrar<T> registrar);
  T get<T>();
  void drop<T>();
}

// 智能工厂接口
abstract class SmartFactory<T, A> implements Registrar<SmartFactory<T, A>> {
  abstract final T Function(A args) builder;

  T call(A args);
}

// 智能工厂注册器
class SmartFactoryRegistrar<T, A> {
  final T Function(A args) builder;

  SmartFactoryRegistrar(this.builder);

  T call(A args) => builder(args);
}

使用示例

注册并检索单例

void main() {
  final registry = RegistryImpl(); // 创建注册表实例

  // 注册单例
  final singletonRegistrar = SingletonRegistrar<String>('Singleton Instance');
  registry.put<String>(singletonRegistrar);

  // 获取单例
  final instance = registry.get<String>();
  print(instance); // 输出: Singleton Instance
}

使用工厂创建对象

void main() {
  final registry = RegistryImpl();

  // 注册同步工厂
  final factoryRegistrar = SyncFactoryRegistrar<String>(() => 'New Instance');
  registry.put<SyncFactory<String>>(factoryRegistrar);

  // 调用工厂获取新实例
  final instance = registry.get<SyncFactory<String>>().call();
  print(instance); // 输出: New Instance
}

异步工厂

void main() async {
  final registry = RegistryImpl();

  // 注册异步工厂
  final asyncFactoryRegistrar = AsyncFactoryRegistrar<String>(
    () async => 'Async Instance',
  );
  registry.put<AsyncFactory<String>>(asyncFactoryRegistrar);

  // 等待异步工厂返回实例
  final instance = await registry.get<AsyncFactory<String>>().call();
  print(instance); // 输出: Async Instance
}

懒加载单例

void main() {
  final registry = RegistryImpl();

  // 注册懒加载单例
  final lazySingletonRegistrar = LazySingletonRegistrar<String>(
    () => 'Lazy Singleton Instance',
  );
  registry.put<String>(lazySingletonRegistrar);

  // 获取懒加载单例
  final instance = registry.get<String>();
  print(instance); // 输出: Lazy Singleton Instance
}

智能工厂

void main() {
  final registry = RegistryImpl();

  // 注册智能工厂
  final smartFactoryRegistrar = SmartFactoryRegistrar<int, String>(
    (args) => args.length,
  );
  registry.put<SmartFactory<int, String>>(smartFactoryRegistrar);

  // 调用智能工厂
  final length = registry.get<SmartFactory<int, String>>().call('Test');
  print(length); // 输出: 4
}