Dependency Injection in Flutter with GetIt

As your Flutter app grows, managing dependencies manually can get messy and hard to scale. That’s where dependency injection (DI) comes in—and in Flutter, GetIt is one of the most popular and powerful packages for implementing it.

In this post, you’ll learn what dependency injection is, why it matters, and how to use GetIt in your Flutter projects to make your code more modular, testable, and maintainable. Flutter dependency injection ensures your app remains structured and clean.

What is Dependency Injection?

Dependency Injection is a design pattern where you provide an object’s dependencies from the outside rather than creating them inside the object.

For example, instead of your UI widget creating a service class directly, DI allows the service to be passed in. This keeps your code clean, decoupled, and easier to test. This method is particularly powerful in Flutter when adopting dependency injection.

Why Use GetIt?

GetIt is a simple service locator for Dart and Flutter that allows you to register classes and retrieve them from anywhere in your app without tight coupling.

Benefits of GetIt:

Global access to registered services
Cleaner code and better separation of concerns
No need to pass objects down widget trees
Easily testable and scalable architecture, ideal when dealing with Flutter and dependency injection methods.

Step 1: Add GetIt to Your Project

Add the package to your pubspec.yaml:

dependencies:
  get_it: ^7.6.4

Then run:

flutter pub get

Step 2: Create and Register a Service

Let’s say you have a simple UserService:

class UserService {
  String getUser() => 'John Doe';
}

Now create a file service_locator.dart

import 'package:get_it/get_it.dart';
import 'user_service.dart';

final getIt = GetIt.instance;

void setupLocator() {
  getIt.registerLazySingleton(() => UserService());
}

Step 3: Initialize GetIt

Call setupLocator() in your main.dart before the app runs:

void main() {
  setupLocator();
  runApp(MyApp());
}

Step 4: Access Services Anywhere

In any widget or class, you can now retrieve your service:

final userService = getIt();

Text(userService.getUser());

This works anywhere—no need to pass the service through constructors or widget trees.

Optional: Register Factories

Use a factory if you want a new instance every time:

getIt.registerFactory(() => SomeService());

This is useful for short-lived objects like controllers or screens. Such flexibility in Flutter dependency injection scenarios is a key advantage.

Bonus: Combine with State Management

GetIt works great with Riverpod, BLoC, Provider, and others. Use it to inject services into your ViewModels, Cubits, or Providers without boilerplate.

Example with a Cubit:

class CounterCubit extends Cubit {
  final AnalyticsService analytics;

  CounterCubit(this.analytics) : super(0);
}

getIt.registerLazySingleton(() => AnalyticsService());
getIt.registerFactory(() => CounterCubit(getIt()));

When to Use GetIt

Use GetIt when:

Your app uses multiple services or repositories
You want loose coupling between layers
You need to test components in isolation, particularly useful with Flutter dependency injection.
You want better architecture with clean dependency flow

Conclusion

Using GetIt for dependency injection in Flutter helps you write cleaner, scalable, and more maintainable code. Whether you’re working on a small app or a large project, this tool simplifies how you manage services and dependencies.

Try integrating GetIt in your next Flutter project—you’ll feel the difference right away. Mastering Flutter dependency injection can take your development to the next level.