dependency-injection - 合理使用依赖注入

Question

是否有合理的方式（方法）如何在项目中使用 DI/IoC？根据 DI 概念，所有依赖项都应该是可注入的（在我的例子中，我决定使用构造函数进行注入）。问题是我应该在所有地方和所有课程中使用 DI 吗？不要让我的项目（支持）更复杂？

我将用dart编程语言编写示例。例如，在我的项目中，我需要一些应用程序全局实例（如 SharedPrefences、DatabaseProvider 等）、一些 BLoC/控制器（如 AuthBloc、TeachersBloc、StudentBloc 等）。向用户显示数据的小部件（TeachersPage、StudentsPage 等）。

根据 DI 我需要使用此代码（示例）：

合同

abstract class AuthProvider {}
abstract class DatabaseProvider {}
abstract class BlocProvider {}

具体实例（可能被替换）

class FirestoreAuthProvider implements AuthProvider {
  // Implement auth functionality
}

class FirestoreProvider implements DatabaseProvider {
  // Implement Firestore functionality
}

class AuthBloc implements BlocProvider {
  AuthBloc(this.authProvider);
  final AuthProvider authProvider;

  void signIn() {
    authProvider.signIn(); // use of injection.
  }
}

class StudentsBloc implements BlocProvider {
  StudentsBloc(this.dataProvider);
  final DataProvider dataProvider;

  List<Student> getStudents() {
    return dataProvider.fetchAll(); // use of injection
  }
}

DI组件

// Simple implementation of Dagger container
class AppContainer implements ... {
  DataProvider get dataProvider => ...;
  AuthProvider get authProvider => ...;

  // Other injections belog
  // ...

  static Future<Container> create([List<AppModule> modules]) {
  }
}

图形用户界面

class SignIn extends StatefulWidget {
  SignIn(this.auth);
  final AuthBloc auth;

  void onSignedIn() {
    final component = get<AppComponent>(); // get somehow AppComponent (maybe from service locator)
    final dataProvider = component.dataProvider; // get globally shared component
    final studentBloc = StudentsBloc(dataProvider); // inject data provider to prepare next injection
    final page = StudentsPage(studentBloc); // inject the injection
    Navigator.of(context).push(MaterialPageRoute(builder: (_) => page));
  }
}

class StudentsPage extends StatefulWidget {
  StudentsPage(this.bloc);
  final StudentsBloc bloc;
}

对我来说，这变得太复杂了。是的，我知道我可以dataProvider轻松更换，也许studentBloc也可以更换？但是......是否有任何边界线可以证明使用 DI 是合理的？

标签： dependency-injectioninversion-of-control