基于RepositoryProvider与BLoC的依赖注入：如何初始化带BaseOptions的Dio并实现便捷Mock？

你当前的写法确实会导致依赖耦合过紧，Mock起来不够灵活——所有实例化逻辑都堆在main函数里，要替换Dio或者BaseOptions就得修改main函数，测试时特别麻烦。下面是几个实用的解决思路，帮你解耦依赖，让Mock变得轻松：

思路1：分层使用RepositoryProvider（推荐） #

不要直接传入已实例化好的Repository，而是通过MultiRepositoryProvider分层提供各个依赖，让Provider自己负责依赖的创建。这样在测试时，你可以轻松替换某一层的依赖（比如Mock Dio），而不需要修改整个初始化流程。

实现代码： #

首先重构你的App组件，用MultiRepositoryProvider依次提供Dio、DataSource、Repository：

class App extends StatelessWidget {
  const App({super.key});

  @override
  Widget build(BuildContext context) {
    return MultiRepositoryProvider(
      providers: [
        // 提供Dio实例，这里可以直接初始化BaseOptions
        RepositoryProvider<Dio>(
          create: (_) => Dio(BaseOptions(baseUrl: "https://myapi.com")),
        ),
        // 从context获取Dio，创建DataSource
        RepositoryProvider<DataSource>(
          create: (context) => DataSource(context.read<Dio>()),
        ),
        // 再获取DataSource创建Repository
        RepositoryProvider<Repository>(
          create: (context) => Repository(context.read<DataSource>()),
        ),
      ],
      child: const MaterialApp(home: HomeScreen()), // 替换成你的根页面
    );
  }
}

然后main函数就变得非常简洁：

void main() {
  runApp(const App());
}

测试时Mock的方式： #

测试时，你只需要用RepositoryProvider<Dio>.value传入Mock的Dio，就能覆盖原来的Provider：

import 'package:mockito/mockito.dart'; // 假设用mockito做Mock

class MockDio extends Mock implements Dio {}

void main() {
  testWidgets('测试Repository使用Mock Dio的场景', (tester) async {
    final mockDio = MockDio();
    // 在这里设置mockDio的行为，比如返回模拟的API响应
    when(mockDio.get('/some-endpoint')).thenAnswer((_) async => Response(data: {}, statusCode: 200));

    await tester.pumpWidget(
      RepositoryProvider<Dio>.value(
        value: mockDio,
        child: const App(),
      ),
    );

    // 执行你的测试断言，比如验证页面是否显示了正确的数据
  });
}

思路2：配合依赖注入框架（比如GetIt） #

如果你的项目依赖较多，可以用依赖注入框架（比如GetIt）来管理所有依赖的创建，这样不管是生产环境还是测试环境，都能轻松切换依赖实现。

实现代码： #

首先初始化GetIt并注册依赖：

final getIt = GetIt.instance;

void setupDependencies() {
  // 懒加载Dio实例
  getIt.registerLazySingleton<Dio>(() => Dio(BaseOptions(baseUrl: "https://myapi.com")));
  // 依赖Dio创建DataSource
  getIt.registerLazySingleton<DataSource>(() => DataSource(getIt<Dio>()));
  // 依赖DataSource创建Repository
  getIt.registerLazySingleton<Repository>(() => Repository(getIt<DataSource>()));
}

然后在App的RepositoryProvider里从GetIt获取Repository：

class App extends StatelessWidget {
  const App({super.key});

  @override
  Widget build(BuildContext context) {
    return RepositoryProvider<Repository>(
      create: (_) => getIt<Repository>(),
      child: const MaterialApp(home: HomeScreen()),
    );
  }
}

main函数里只需要初始化依赖并启动App：

void main() {
  setupDependencies();
  runApp(const App());
}

测试时Mock的方式： #

测试前重置GetIt并注册Mock依赖即可：

void main() {
  setUp(() {
    getIt.reset();
    // 注册Mock的Dio
    getIt.registerLazySingleton<Dio>(() => MockDio());
    // 其他依赖照常注册，会自动使用Mock的Dio
    getIt.registerLazySingleton<DataSource>(() => DataSource(getIt<Dio>()));
    getIt.registerLazySingleton<Repository>(() => Repository(getIt<DataSource>()));
  });

  testWidgets('使用Mock依赖的测试', (tester) async {
    await tester.pumpWidget(const App());
    // 执行测试逻辑
  });
}

思路3：用环境配置类区分环境 #

如果只是需要切换BaseOptions（比如生产/测试API地址），可以创建一个抽象的环境配置类，通过传入不同的配置实现环境切换。

实现代码： #

首先定义抽象配置类和具体实现：

abstract class EnvConfig {
  BaseOptions get baseOptions;
}

// 生产环境配置
class ProdConfig implements EnvConfig {
  @override
  BaseOptions get baseOptions => BaseOptions(baseUrl: "https://myapi.com");
}

// 测试环境配置
class TestConfig implements EnvConfig {
  @override
  BaseOptions get baseOptions => BaseOptions(baseUrl: "https://test-api.com");
}

然后让App接收EnvConfig参数：

class App extends StatelessWidget {
  final EnvConfig envConfig;

  const App({super.key, required this.envConfig});

  @override
  Widget build(BuildContext context) {
    return RepositoryProvider<Repository>(
      create: (_) {
        final dio = Dio(envConfig.baseOptions);
        return Repository(DataSource(dio));
      },
      child: const MaterialApp(home: HomeScreen()),
    );
  }
}

main函数使用生产配置：

void main() {
  runApp(const App(envConfig: ProdConfig()));
}

测试时的用法： #

测试时传入TestConfig，或者直接传入Mock Dio：

// 使用测试配置
testWidgets('测试环境下的页面行为', (tester) async {
  await tester.pumpWidget(const App(envConfig: TestConfig()));
  // 测试逻辑
});

// 直接使用Mock Dio
testWidgets('用Mock Dio测试', (tester) async {
  final mockDio = MockDio();
  await tester.pumpWidget(
    RepositoryProvider<Repository>.value(
      value: Repository(DataSource(mockDio)),
      child: const MaterialApp(home: HomeScreen()),
    ),
  );
});

这些思路的核心都是解耦依赖的创建与使用，让你可以在不修改核心业务代码的前提下，轻松替换依赖实现，不管是测试Mock还是环境切换都能搞定。

内容的提问来源于stack exchange，提问作者Stefan Galler