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