0Pricing
Flutter Mobile Development · Lección

Inyección de dependencias con get_it e injectable

Registre y resuelva dependencias mediante los localizadores de servicios de get_it y la generación de código de injectable.

Inyección de dependencias con get_it e injectable es una lección gratuita de Flutter Mobile Development en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Flutter Mobile Development, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Flutter Mobile Development incluye 4 lecciones en total.

Partes de esta lección aún no han sido traducidas y se muestran en inglés.

Why a Service Locator?

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.

The GetIt Instance

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.

// A tiny hand-rolled service locator to show the idea.
class Locator {
  final _factories = <Type, Object Function()>{};
  final _singletons = <Type, Object>{};

  void registerFactory<T>(T Function() create) =>
      _factories[T] = () => create() as Object;

  void registerSingleton<T>(T instance) =>
      _singletons[T] = instance as Object;

  T get<T>() {
    if (_singletons.containsKey(T)) return _singletons[T] as T;
    final f = _factories[T];
    if (f == null) throw StateError('No registration for $T');
    return f() as T;
  }
}

class ApiClient {
  final String baseUrl;
  ApiClient(this.baseUrl);
}

void main() {
  final sl = Locator();
  sl.registerSingleton<ApiClient>(ApiClient('https://api.example.com'));
  final api = sl.get<ApiClient>();
  print('Resolved ApiClient -> ${api.baseUrl}');
}

Registration Lifetimes

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.
import 'package:get_it/get_it.dart';

final getIt = GetIt.instance;

void configureDependencies() {
  getIt.registerLazySingleton<Dio>(() => Dio());
  getIt.registerLazySingleton<AuthRemoteSource>(
    () => AuthRemoteSource(getIt<Dio>()),
  );
  getIt.registerFactory<LoginBloc>(
    () => LoginBloc(getIt<AuthRemoteSource>()),
  );
}

Registering Against Abstractions

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.

abstract class AuthRepository {
  Future<String> login(String email, String password);
}

class AuthRepositoryImpl implements AuthRepository {
  final AuthRemoteSource remote;
  AuthRepositoryImpl(this.remote);

  @override
  Future<String> login(String email, String password) =>
      remote.authenticate(email, password);
}

void registerRepositories() {
  // Generic is the ABSTRACTION, builder returns the IMPL.
  getIt.registerLazySingleton<AuthRepository>(
    () => AuthRepositoryImpl(getIt<AuthRemoteSource>()),
  );
}

Resolving Inside Widgets

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.

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

  @override
  Widget build(BuildContext context) {
    return BlocProvider<LoginBloc>(
      // Fresh BLoC from the factory registration.
      create: (_) => getIt<LoginBloc>(),
      child: const _LoginView(),
    );
  }
}

Enter injectable

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.
# pubspec.yaml
dependencies:
  get_it: ^7.7.0
  injectable: ^2.4.0

dev_dependencies:
  build_runner: ^2.4.0
  injectable_generator: ^2.6.0

The @injectable Annotation

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.

import 'package:injectable/injectable.dart';

@injectable
class LoginBloc {
  final AuthRepository repository;
  LoginBloc(this.repository); // injected automatically
}

@Injectable(as: AuthRepository)
class AuthRepositoryImpl implements AuthRepository {
  final AuthRemoteSource remote;
  AuthRepositoryImpl(this.remote);
  // ...
}

Singletons and Lazy Singletons

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.

@lazySingleton
class AuthRemoteSource {
  final Dio dio;
  AuthRemoteSource(this.dio);
}

@singleton
class AppConfig {
  final String environment;
  AppConfig() : environment = const String.fromEnvironment('ENV');
}

Third-Party Types with @module

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.

import 'package:injectable/injectable.dart';
import 'package:dio/dio.dart';
import 'package:shared_preferences/shared_preferences.dart';

@module
abstract class RegisterModule {
  @lazySingleton
  Dio get dio => Dio(BaseOptions(baseUrl: 'https://api.example.com'));

  @preResolve
  Future<SharedPreferences> get prefs => SharedPreferences.getInstance();
}

Generating and Wiring configureDependencies

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.

import 'package:get_it/get_it.dart';
import 'package:injectable/injectable.dart';
import 'injection.config.dart'; // generated

final getIt = GetIt.instance;

@InjectableInit(
  initializerName: 'init',
  preferRelativeImports: true,
  asExtension: true,
)
Future<void> configureDependencies() => getIt.init();

Future<void> main() async {
  WidgetsFlutterBinding.ensureInitialized();
  await configureDependencies();
  runApp(const MyApp());
}

Environments and Test Overrides

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.

abstract class Clock {
  DateTime now();
}

class SystemClock implements Clock {
  @override
  DateTime now() => DateTime.now();
}

class FixedClock implements Clock {
  final DateTime fixed;
  FixedClock(this.fixed);
  @override
  DateTime now() => fixed;
}

void main() {
  final registry = <Type, Object>{};
  void register<T>(T impl) => registry[T] = impl as Object;
  T resolve<T>() => registry[T] as T;

  register<Clock>(SystemClock());
  // Override for a deterministic test:
  register<Clock>(FixedClock(DateTime.utc(2030, 1, 1)));

  print('Test clock now: ${resolve<Clock>().now()}');
}

Quick Check

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?

Recap

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.

Preguntas frecuentes

¿La lección «Inyección de dependencias con get_it e injectable» es gratis?

Sí — el texto completo de «Inyección de dependencias con get_it e injectable» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Flutter Mobile Development, actualiza a CoddyKit PRO. El curso de Flutter Mobile Development incluye 4 lecciones en total.

¿Qué aprenderé en «Inyección de dependencias con get_it e injectable»?

Registre y resuelva dependencias mediante los localizadores de servicios de get_it y la generación de código de injectable. Practicas Flutter Mobile Development con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Flutter Mobile Development?

No se requiere experiencia previa. Flutter Mobile Development en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Inyección de dependencias con get_it e injectable»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Flutter Mobile Development?

Sí. Cada lección de Flutter Mobile Development incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Límites entre las capas de dominio, datos y presentación
  2. Inyección de dependencias con get_it e injectable
  3. Estructura de carpetas por funcionalidad y monorepositorios Melos
  4. Either, tipos de fallo y gestión funcional de errores
← Volver a Flutter Mobile Development