如何在Flutter中手动实现依赖注入？Injector实例化位置咨询

Nice work putting together that manual singleton-based injector for Flutter—since the team doesn’t offer an official DI library, this is a solid starting point! Let’s tackle your question about where to instantiate it for global access, and whether global variables are the way to go.

First, let’s confirm your injector implementation is on the right track:

class Injector{ 
  Injector._internal(); 
  static final _singleton = Injector._internal(); 
  factory Injector() => _singleton; 

  SomeClass get someClass => SomeClass(); 
}

Is a Global Variable Suitable? #

A global variable (like final injector = Injector(); declared at the top level of a file) will absolutely let you access the injector anywhere in your code. It’s quick and easy to set up, but it comes with some tradeoffs:

• Testing headaches: Global instances are hard to mock or replace, making unit tests where you need a fake SomeClass implementation much trickier.
• No lifecycle control: If your dependencies ever need to clean up resources (like closing a database connection), a global variable can’t tie into Flutter’s widget lifecycle.
• Tight coupling: Every piece of code that uses the injector will directly depend on this global instance, making future refactors more painful.

So while it works, it’s not the most maintainable long-term solution.

Better Alternatives #

1. Tie the Injector to Flutter’s Widget Tree (Recommended)

Flutter’s widget system gives us a clean way to pass dependencies down the tree using InheritedWidget. This keeps your injector accessible globally without the downsides of a global variable.

Here’s a simple wrapper you can build:

class InjectorProvider extends InheritedWidget {
  final Injector injector;

  const InjectorProvider({
    super.key,
    required this.injector,
    required super.child,
  });

  // Helper method to fetch the injector from any child widget
  static InjectorProvider? of(BuildContext context) {
    return context.dependOnInheritedWidgetOfExactType<InjectorProvider>();
  }

  @override
  bool updateShouldNotify(InjectorProvider oldWidget) {
    return injector != oldWidget.injector;
  }
}

Then wrap your root MaterialApp with this provider when your app starts:

void main() {
  runApp(
    InjectorProvider(
      injector: Injector(),
      child: const MyApp(),
    ),
  );
}

Now, in any child widget, you can grab the injector using the context:

final injector = InjectorProvider.of(context)!.injector;
final someClassInstance = injector.someClass;

This approach shines because:

• It decouples your code from a global instance
• Testing becomes easy: you can wrap your test widgets with a InjectorProvider that uses a mock injector
• You can add lifecycle logic later (like disposing dependencies) by turning InjectorProvider into a StatefulWidget

2. Lazy-Initialized Static Instance

If you don’t want to mess with the widget tree, you can tweak your injector to initialize itself lazily the first time it’s used, no global variable needed:

class Injector{ 
  Injector._internal(); 
  static Injector? _singleton;

  static Injector get instance {
    _singleton ??= Injector._internal();
    return _singleton!;
  }

  SomeClass get someClass => SomeClass(); 
}

Then access it anywhere with Injector.instance.someClass. This is cleaner than a global variable, but it still has the same testing limitations as a global—so it’s a middle ground between quick and maintainable.

Final Takeaway #

• Use a global variable only for small, simple apps where testing and long-term maintenance aren’t big concerns.
• For most apps, tying the injector to the widget tree with InheritedWidget is the best balance of accessibility, flexibility, and maintainability.
• The lazy static instance is a good compromise if you want to avoid widget tree setup but still skip the global variable.

内容的提问来源于stack exchange，提问作者Toni Joe