การฉีดการพึ่งพาด้วย get_it และ injectable

In a clean, modular Flutter app you want your presentation layer to depend on abstractions, not on the concrete classes that build them. Manually constructing objects (RemoteApi(HttpClient(...))) everywhere leaks construction details and makes testing painful.

A service locator centralizes object creation and lookup. get_it is the de-facto service locator for Dart/Flutter: you register how to build a type once, then resolve it anywhere with a single call.

• Decoupling — widgets ask for an interface, not a constructor.
• Testability — swap a real implementation for a fake in tests.
• Lifecycle control — singleton vs. fresh instance per request.

GetIt exposes a global singleton via GetIt.instance (commonly aliased getIt or sl). You can also create isolated instances with GetIt.asNewInstance() for tests.

The plain Dart API mirrors what code generation will produce later, so it pays to understand it first. Below is the locator pattern modeled with plain classes — no Flutter needed.

get_it offers three core registration kinds. Choosing correctly is the key architectural decision:

• registerFactory<T>() — runs the builder every time you resolve. Use for short-lived, stateful objects (e.g. a fresh BLoC per screen).
• registerSingleton<T>(instance) — you provide a ready instance; created eagerly at startup.
• registerLazySingleton<T>() — built once on first resolve, then cached. Ideal for repositories and API clients you don't need until used.

Clean Architecture says the domain layer defines an interface (e.g. AuthRepository) and the data layer implements it (AuthRepositoryImpl). Register the abstract type as the generic, and return the concrete implementation from the builder.

Consumers resolve getIt<AuthRepository>() and never learn the implementation — you can swap it without touching call sites.

From any widget you call the locator directly. Because BLoCs are usually registerFactory, each screen gets a fresh instance, and you dispose it with the widget.

A common pattern: resolve the factory-built BLoC in BlocProvider(create: ...), while repositories/clients stay lazy singletons shared across the app.

Writing configureDependencies() by hand grows unwieldy in a large modular app. injectable is a code generator that scans annotations and emits the registration code for you, wiring constructor parameters automatically.

You need three dev/runtime dependencies:

• injectable — the annotations.
• get_it — the runtime locator it targets.
• injectable_generator + build_runner — dev-only code generation.

Annotate a class with @injectable and the generator registers it as a factory. Its constructor parameters are resolved from the locator recursively, so you never wire them by hand.

To bind an interface to an implementation, annotate the impl and use @Injectable(as: AuthRepository) — the generic registration becomes the abstraction.

injectable mirrors get_it's lifetimes through annotations:

• @singleton — eager singleton, created when DI is configured.
• @lazySingleton — created on first resolve, then cached.
• @injectable — factory (new instance each time).

Pick @lazySingleton for repositories, data sources, and clients; @injectable for BLoCs/Cubits scoped to a screen.

You can't annotate classes you don't own (Dio, SharedPreferences). A register module solves this: declare an abstract class annotated @module, and expose getters/methods that build those types.

Async dependencies (like SharedPreferences.getInstance()) return a Future and are registered as @preResolve so DI awaits them at startup.

Create a single entry point annotated with @InjectableInit. Run the generator and it emits *.config.dart containing init(getIt), which you call from your function.

Generate with:

• dart run build_runner build --delete-conflicting-outputs

Then call configureDependencies() before runApp. With @preResolve dependencies present, the function is async and must be awaited.

For testing you replace real registrations with fakes. With plain get_it you call getIt.unregister<T>() then re-register a mock, or use a fresh GetIt.asNewInstance(). With injectable, the @Environment annotation (e.g. @dev, @test) selects implementations per environment passed to init.

The pattern below shows the test-override idea with plain Dart so it runs standalone.

You have a UserRepository backed by a Dio HTTP client shared across the app, and a ProfileCubit that holds per-screen UI state and must be disposed when its screen closes. Which injectable annotations best fit each?

You now know how to wire dependencies in a modular Flutter app:

• get_it is the runtime service locator — registerFactory, registerSingleton, and registerLazySingleton control lifetime.
• Register against abstractions (registerLazySingleton<AuthRepository>) so call sites stay decoupled from implementations.
• injectable generates that registration code from annotations: @injectable (factory), @lazySingleton, @singleton, and @Injectable(as: ...) to bind interfaces.
• Use @module with @preResolve for third-party and async dependencies like Dio and SharedPreferences.
• @InjectableInit + build_runner produce getIt.init(); await configureDependencies() before runApp.

Rule of thumb: lazy singletons for repositories/clients, factories for screen-scoped BLoCs/Cubits.