Dependency Injection

What Is Dependency Injection?

Dependency Injection (DI) is a design pattern where objects receive their dependencies from external sources rather than creating them internally. This makes your code more testable , maintainable , and flexible .

💡 Key Concept

Instead of a class creating its own dependencies (tight coupling), dependencies are injected from the outside. This follows the Dependency Inversion Principle — high-level modules should not depend on low-level modules, both should depend on abstractions.

❌ Without DI (Tight Coupling)

Class creates its own dependencies
Hard to test (can't mock)
Difficult to change implementations
Violates Single Responsibility
Hidden dependencies

✅ With DI (Loose Coupling)

Dependencies are passed from outside
Easy to test (mock dependencies)
Swap implementations easily
Clear, explicit dependencies
Follows SOLID principles

Without Dependency Injection


        
         class
        
        
         WeatherService
        
        {
        
         // Creates its own dependency - tight coupling!
        
        
         final
        
        ApiClient apiClient =
        
         ApiClient
        
        ();
        
         Future
        
        <Weather>
        
         getWeather
        
        () async {
        
         return
        
        
         await
        
        apiClient.
        
         fetchWeather
        
        ();
    }
  }

With Dependency Injection


        
         class
        
        
         WeatherService
        
        {
        
         // Dependency is injected - loose coupling!
        
        
         final
        
        ApiClient apiClient;
        
         WeatherService
        
        (
        
         this
        
        .apiClient);
        
         Future
        
        <Weather>
        
         getWeather
        
        () async {
        
         return
        
        
         await
        
        apiClient.
        
         fetchWeather
        
        ();
    }
  }

Service Locator vs Dependency Injection

While Dependency Injection and Service Locator are often used together, they serve different purposes:

Dependencies are passed via constructor
Dependencies are explicit and visible
Better for testability
Follows Inversion of Control
Dependencies are known at compile time

Service Locator (GetIt)

Dependencies are requested from a central registry
Dependencies can be resolved at runtime
Convenient for Flutter apps
No BuildContext required
O(1) lookups

✅ The Flutter Approach

In Flutter, we often use GetIt (service locator) together with constructor injection . Services are registered with GetIt and then injected into classes that need them. This gives us the best of both worlds.

GetIt Package

GetIt is a simple, type-safe service locator for Dart and Flutter that makes dependency management simple. It gives you O(1) access to your objects from anywhere in your app — no BuildContext required, no code generation.

⚡

Blazing Fast

O(1) lookups using Dart's native Maps

🎯

Type Safe

Full compile-time type checking with generics

🧪

Test Friendly

Easily swap real implementations for mocks

🌳

No BuildContext

Access objects from anywhere

📦

Framework Agnostic

Works in Flutter, Dart, server-side, CLI

🔧

Zero Boilerplate

No code generation, no build_runner

pubspec.yaml – Add GetIt


        dependencies:
    flutter:
      sdk: flutter
    get_it: ^8.0.2

Registration Types

GetIt provides three main registration types to control the lifetime of your dependencies:

🔒

Singleton

Create once, share everywhere

Perfect for services that maintain state

⏳

Lazy Singleton

Create on first access

Delays initialization until needed

🏭

Factory

New instance every time

Stateless services or short-lived objects

lib/di/service_locator.dart – Register Dependencies


        
         import
        
        
         'package:get_it/get_it.dart'
        
        ;
        
         import
        
        
         '../data/datasources/weather_remote_datasource.dart'
        
        ;
        
         import
        
        
         '../data/datasources/weather_local_datasource.dart'
        
        ;
        
         import
        
        
         '../data/repositories_impl/weather_repository_impl.dart'
        
        ;
        
         import
        
        
         '../domain/repositories/weather_repository.dart'
        
        ;
        
         import
        
        
         '../domain/usecases/get_weather_usecase.dart'
        
        ;
        
         final
        
        getIt = GetIt.instance;
        
         void
        
        
         setupServiceLocator
        
        () {
        
         // ========== SINGLETONS ==========
        
        
         // Create once, share everywhere
        
        getIt.
        
         registerSingleton
        
        <WeatherRemoteDataSource>(
      WeatherRemoteDataSource(
        client: http.Client(),
        baseUrl:
        
         'https://api.openweathermap.org/data/2.5'
        
        ,
        apiKey:
        
         'your-api-key'
        
        ,
      ),
    );

    getIt.
        
         registerSingleton
        
        <WeatherLocalDataSource>(
      WeatherLocalDataSource(),
    );
        
         // ========== LAZY SINGLETONS ==========
        
        
         // Created only when first accessed
        
        getIt.
        
         registerLazySingleton
        
        <WeatherRepository>(
        
         ()
        
        {
        
         return
        
        WeatherRepositoryImpl(
        remoteDataSource: getIt<WeatherRemoteDataSource>(),
        localDataSource: getIt<WeatherLocalDataSource>(),
      );
    });
        
         // ========== FACTORIES ==========
        
        
         // New instance each time
        
        getIt.
        
         registerFactory
        
        <GetWeatherUseCase>(
        
         ()
        
        {
        
         return
        
        GetWeatherUseCase(getIt<WeatherRepository>());
    });
        
         // ========== ASYNC INITIALIZATION ==========
        
        
         // For dependencies that need async setup
        
        getIt.
        
         registerSingletonAsync
        
        <Database>(
        
         ()
        
        async {
        
         final
        
        db =
        
         await
        
        
         Database
        
        .open();
        
         return
        
        db;
    });
  }

💡 Which Registration Type to Use?

Singleton – Services that maintain state (e.g., ApiClient, Database)
Lazy Singleton – Services that are expensive to create and may not always be used
Factory – Stateless services or objects with short lifetimes
Async – Dependencies that require async initialization (e.g., opening a database)

Accessing Dependencies

Once registered, dependencies can be accessed from anywhere in your app:

Accessing Dependencies from Anywhere


        
         import
        
        
         'package:get_it/get_it.dart'
        
        ;
        
         // Simple access
        
        
         final
        
        repository = GetIt.instance<WeatherRepository>();
        
         // Or using the global getIt instance
        
        
         final
        
        useCase = getIt<GetWeatherUseCase>();
        
         // Access in a ViewModel
        
        
         class
        
        
         WeatherViewModel
        
        
         extends
        
        StateNotifier<WeatherState> {
        
         final
        
        GetWeatherUseCase getWeatherUseCase;
        
         WeatherViewModel
        
        ()
        : getWeatherUseCase = getIt<GetWeatherUseCase>(),
        
         super
        
        (WeatherState.
        
         initial
        
        ());
        
         // Or with constructor injection (recommended)
        
        
         // WeatherViewModel(this.getWeatherUseCase) : super(WeatherState.initial());
        
        }

Using with Riverpod


        
         import
        
        
         'package:riverpod/riverpod.dart'
        
        ;
        
         import
        
        
         '../di/service_locator.dart'
        
        ;
        
         // Provider that uses GetIt
        
        
         final
        
        weatherRepositoryProvider = Provider<WeatherRepository>((ref) {
        
         return
        
        getIt<WeatherRepository>();
  });
        
         final
        
        getWeatherUseCaseProvider = Provider<GetWeatherUseCase>((ref) {
        
         return
        
        getIt<GetWeatherUseCase>();
  });
        
         // ViewModel with dependencies from GetIt
        
        
         final
        
        weatherViewModelProvider = StateNotifierProvider<WeatherViewModel, WeatherState>((ref) {
        
         return
        
        WeatherViewModel(getIt<GetWeatherUseCase>());
  });

Testing with GetIt

One of the biggest advantages of dependency injection is testability . GetIt makes it easy to swap real implementations with mocks in tests.

test/weather_test.dart – Using GetIt in Tests


        
         import
        
        
         'package:test/test.dart'
        
        ;
        
         import
        
        
         'package:get_it/get_it.dart'
        
        ;
        
         import
        
        
         'package:mockito/mockito.dart'
        
        ;
        
         class
        
        
         MockWeatherRepository
        
        
         extends
        
        Mock
        
         implements
        
        WeatherRepository {}
        
         void
        
        
         main
        
        () {
        
         late
        
        MockWeatherRepository mockRepository;
        
         late
        
        GetWeatherUseCase useCase;
        
         setUp
        
        (() {
        
         // Reset GetIt before each test
        
        
         await
        
        GetIt.instance.
        
         reset
        
        ();
        
         // Register mock
        
        mockRepository = MockWeatherRepository();
      GetIt.instance.
        
         registerSingleton
        
        <WeatherRepository>(mockRepository);
        
         // Get use case with mock injected
        
        useCase = GetIt.instance<GetWeatherUseCase>();
    });
        
         test
        
        (
        
         'returns weather data from repository'
        
        , () async {
        
         // Arrange
        
        
         final
        
        expectedWeather = Weather(
        
         'London'
        
        ,
        
         20.0
        
        );
      when(mockRepository.
        
         getWeather
        
        (
        
         'London'
        
        ))
          .thenAnswer((_) async => expectedWeather);
        
         // Act
        
        
         final
        
        result =
        
         await
        
        useCase.
        
         execute
        
        (
        
         'London'
        
        );
        
         // Assert
        
        expect(result, expectedWeather);
      verify(mockRepository.
        
         getWeather
        
        (
        
         'London'
        
        )).
        
         called
        
        (
        
         1
        
        );
    });
  }

✅ Testing Benefits

Easy mocking – Replace real implementations with mocks
Test isolation – reset() clears all registrations between tests
Constructor injection – Use optional constructor parameters to inject mocks
No BuildContext – Test business logic without UI setup

Async Initialization

GetIt supports async initialization for dependencies that need to be set up asynchronously (e.g., opening a database, initializing a client).

lib/di/service_locator.dart – Async Registration


        
         final
        
        getIt = GetIt.instance;
        
         void
        
        
         setupServiceLocator
        
        () async {
        
         // Register async dependencies
        
        getIt.
        
         registerSingletonAsync
        
        <Database>(
        
         ()
        
        async {
        
         final
        
        db =
        
         await
        
        Database.
        
         open
        
        ();
        
         return
        
        db;
    });
        
         // Register dependencies that depend on async ones
        
        getIt.
        
         registerSingletonAsync
        
        <UserRepository>(
        
         ()
        
        async {
        
         final
        
        db =
        
         await
        
        getIt.
        
         getAsync
        
        <Database>();
        
         return
        
        UserRepository(db);
    }, dependsOn: [Database]);
        
         // Wait for all async registrations to complete
        
        
         await
        
        getIt.
        
         allReady
        
        ();
  }
        
         // In main.dart
        
        
         void
        
        
         main
        
        () async {
    WidgetsFlutterBinding.ensureInitialized();
        
         await
        
        
         setupServiceLocator
        
        ();
    runApp(MyApp());
  }

Step-by-Step Implementation

Follow these steps to implement dependency injection in your Flutter app:

1.

Add GetIt dependency – Add


          get_it: ^8.0.2

to


          pubspec.yaml

2.

Create service locator file – Create


          lib/di/service_locator.dart

3.

Register dependencies – Register all your services, repositories, and use cases

4.

Initialize in main – Call


          setupServiceLocator()

before


          runApp()

5.

Use in classes – Access dependencies with


          getIt<MyService>()

6.

Test – Use


          reset()

and mock dependencies in tests

Common Mistakes

❌ Mistake 1: Using service_role key in client-side code

The service_role key bypasses all security policies. Never expose it in your Flutter app.

✅ Correct: Use anon key for client-side

Always use the anon key in your Flutter app. It's safe and respects Row Level Security policies.

❌ Mistake 2: Not handling error responses properly

Failing to check for error responses or parse error messages correctly leads to confusing user experiences.

✅ Correct: Parse and handle errors

Always check the response status code and parse error messages from the API response body.

❌ Mistake 3: Hardcoding API URLs

Hardcoding API URLs makes it difficult to switch between development, staging, and production environments.

✅ Correct: Use environment configuration

Use environment variables or configuration files to manage different API endpoints for different environments.

Dependency Injection

💡 Key Concept

❌ Without DI (Tight Coupling)

✅ With DI (Loose Coupling)

Dependency Injection

Service Locator (GetIt)

✅ The Flutter Approach

💡 Which Registration Type to Use?

✅ Testing Benefits

🎯 Key Takeaway