Dependency injection (GetIt) in Flutter - Deep Dive

Overview - Dependency injection (GetIt)

What is it?

Dependency injection is a way to provide parts of your app with the things they need to work, without making them create those things themselves. GetIt is a tool in Flutter that helps manage and share these parts easily across your app. It acts like a central place where you register and find the objects your app needs. This makes your code cleaner and easier to change.

Why it matters

Without dependency injection, your app parts would have to create or find their own dependencies, making the code messy and hard to update. GetIt solves this by letting you register objects once and use them anywhere, saving time and reducing errors. This helps apps grow bigger and stay organized, so developers can add features faster and fix bugs more easily.

Where it fits

Before learning GetIt, you should understand basic Flutter widgets and how to create classes and objects in Dart. After mastering GetIt, you can explore more advanced state management tools like Riverpod or Bloc, which often use dependency injection under the hood.

Mental Model

Core Idea

Dependency injection with GetIt means giving your app parts the things they need from a shared place, instead of making them build those things themselves.

Think of it like...

Imagine a kitchen where every chef needs knives and pots. Instead of each chef buying their own, there is a shared tool rack where they pick what they need. GetIt is like that tool rack for your app's parts.

┌───────────────┐     register     ┌───────────────┐
│   GetIt Hub   │◀───────────────│  Service A    │
│ (Service Locator)│               └───────────────┘
│               │     register     ┌───────────────┐
│               │◀───────────────│  Service B    │
└───────┬───────┘                 └───────────────┘
        │
        │ get
        ▼
┌───────────────┐
│  App Widget   │
│  uses Service │
│  from GetIt   │
└───────────────┘

Build-Up - 7 Steps

1

Foundation

What is Dependency Injection

Concept: Dependency injection means giving objects the things they need instead of making them create those things themselves.

In Flutter, many parts of your app need other objects to work, like a database or a service. Instead of creating these inside each part, dependency injection lets you provide them from outside. This makes your code easier to test and change.

Result

You understand that dependency injection separates object creation from usage, making your app more flexible.

Understanding this separation is key to writing clean, maintainable code that can grow without becoming tangled.

2

Foundation

Introducing GetIt as Service Locator

Concept: GetIt is a package that acts as a central place to register and find objects your app needs.

You add GetIt to your Flutter project and create a single instance called 'GetIt.I'. You register objects like services or repositories with it. Later, anywhere in your app, you ask GetIt for those objects instead of creating them again.

Result

You can share one instance of a service across many widgets without passing it manually.

Knowing that GetIt holds your objects centrally helps you avoid repetitive code and keeps your app organized.

3

Intermediate

Registering and Retrieving Services

🤔Before reading on: do you think you must register services before or after using them? Commit to your answer.

Concept: You must register services with GetIt before you can retrieve them anywhere in your app.

Use GetIt.I.registerSingleton(MyService()) to register a single instance. Then, use GetIt.I() to get that instance wherever needed. This ensures all parts use the same service object.

Result

Your app parts share the same service instance, avoiding duplicate objects and inconsistent data.

Understanding the timing of registration prevents runtime errors and ensures your app parts get the correct shared objects.

4

Intermediate

Lazy vs Eager Service Registration

🤔Before reading on: do you think services are created immediately or only when first used? Commit to your answer.

Concept: GetIt supports eager (immediate) and lazy (on-demand) creation of services when registering them.

registerSingleton creates the service immediately. registerLazySingleton creates it only when first requested. Lazy creation saves resources if the service is not always needed.

Result

Your app can start faster and use memory efficiently by delaying service creation until necessary.

Knowing when services are created helps optimize app startup time and resource use.

5

Intermediate

Using Factories for New Instances

🤔Before reading on: do you think GetIt can create new objects each time or only share single instances? Commit to your answer.

Concept: GetIt can register factories to create a new object every time you ask for it.

Use registerFactory(() => MyClass()) to tell GetIt to make a new MyClass object each time. This is useful when you want fresh objects instead of shared ones.

Result

Your app can get new instances on demand, useful for temporary or stateful objects.

Understanding factory registration expands your control over object lifecycles in your app.

6

Advanced

Managing Dependencies Between Services

🤔Before reading on: do you think services can depend on each other in GetIt? Commit to your answer.

Concept: Services can depend on other services, and GetIt can resolve these dependencies automatically if registered properly.

When registering a service that needs another, you can retrieve the dependency inside the factory or constructor. For example, registerSingleton(ServiceA(GetIt.I())). This way, ServiceA gets ServiceB injected.

Result

Your app builds complex service graphs with dependencies managed cleanly and automatically.

Knowing how to chain dependencies prevents manual wiring and reduces bugs in large apps.

7

Expert

Handling Async Initialization and Disposal

🤔Before reading on: do you think GetIt supports async setup or cleanup of services? Commit to your answer.

Concept: GetIt supports asynchronous service initialization and disposal to handle real-world needs like database connections.

You can register async singletons using registerSingletonAsync and await their setup before app start. Also, you can register dispose functions to clean resources when no longer needed. This ensures services are ready and cleaned properly.

Result

Your app safely manages services that require async setup or cleanup, avoiding crashes or leaks.

Understanding async lifecycle management is crucial for robust production apps using GetIt.

Under the Hood

GetIt works as a singleton registry holding references to objects or factories. When you register a service, GetIt stores a function or instance internally. When you request a service, GetIt either returns the stored instance or calls the factory to create a new one. It uses Dart's generics and type system to match requests to registrations. For async services, it manages futures and ensures initialization completes before use.

Why designed this way?

GetIt was designed to be simple and lightweight, avoiding complex frameworks. It uses a service locator pattern to reduce boilerplate and make dependency management explicit but easy. Alternatives like InheritedWidget or Provider require widget tree changes, while GetIt works anywhere. This design trades some global state risks for simplicity and speed.

┌───────────────┐
│  App Startup  │
└──────┬────────┘
       │ register services
       ▼
┌───────────────┐
│   GetIt Hub   │
│ ┌───────────┐ │
│ │ Service A │ │
│ ├───────────┤ │
│ │ Service B │ │
│ └───────────┘ │
└──────┬────────┘
       │ get service
       ▼
┌───────────────┐
│  App Widgets  │
│  use services │
└───────────────┘

Myth Busters - 3 Common Misconceptions

Quick: Does GetIt automatically update widgets when a service changes? Commit yes or no.

Common Belief: GetIt automatically rebuilds widgets when the services it provides change.

Reality: GetIt only provides access to services; it does not notify widgets about changes. You must use other tools like ValueNotifier or state management to update UI.

Why it matters: Assuming automatic UI updates leads to bugs where the screen does not refresh, confusing users and developers.

Quick: Can you register multiple instances of the same type in GetIt? Commit yes or no.

Common Belief: You can register many different instances of the same class type in GetIt without extra work.

Reality: GetIt registers one instance per type by default. To register multiple, you must use named registrations or other patterns.

Why it matters: Not knowing this causes conflicts or overwriting services, breaking app logic.

Quick: Is GetIt the only way to do dependency injection in Flutter? Commit yes or no.

Common Belief: GetIt is the only or best way to do dependency injection in Flutter apps.

Reality: Flutter supports many DI methods, including Provider, Riverpod, and manual injection. GetIt is one simple option among many.

Why it matters: Believing this limits your ability to choose the best tool for your app's needs.

Expert Zone

1

GetIt’s global singleton nature can cause hidden dependencies if overused, so careful architecture is needed to keep code testable.

2

Using named registrations allows managing multiple instances of the same type, which is essential in complex apps with different configurations.

3

Combining GetIt with reactive state management patterns requires explicit bridging, as GetIt itself does not handle state changes or notifications.

When NOT to use

Avoid GetIt when your app requires fine-grained widget rebuilds based on state changes; use Provider or Riverpod instead. Also, for very small apps, manual injection might be simpler and clearer.

Production Patterns

In production, GetIt is often used to register core services like API clients, databases, and repositories at app start. It is combined with state management solutions to handle UI updates. Async initialization is used for services needing setup before app use, ensuring smooth user experience.

Connections

Service Locator Pattern

GetIt is a concrete implementation of the service locator pattern.

Understanding service locator helps grasp how GetIt centralizes object management, clarifying its benefits and tradeoffs.

Inversion of Control (IoC)

Dependency injection is a form of IoC where control of creating dependencies is inverted from the object to an external source.

Knowing IoC explains why dependency injection improves modularity and testability in software design.

Supply Chain Management

Like GetIt supplies dependencies to app parts, supply chains deliver needed materials to factories just in time.

Seeing dependency injection as supply chain management highlights the importance of timely and organized resource delivery for smooth operation.

Common Pitfalls

#1 Registering services after trying to use them causes runtime errors.

Wrong approach:

void main() {
runApp(MyApp());
GetIt.I.registerSingleton(MyService());
}

Correct approach:

void main() {
GetIt.I.registerSingleton(MyService());
runApp(MyApp());
}

Root cause:

Services must be registered before app parts request them; otherwise, GetIt cannot find them.

#2 Expecting GetIt to rebuild UI automatically when service data changes.

Wrong approach:

final service = GetIt.I();
// Change data inside service
// Expect UI to update without notifying

Correct approach:

Use ValueNotifier or Stream in service and listen in UI to trigger rebuilds.

Root cause:

GetIt only provides instances; it does not manage state or notify listeners.

#3 Registering multiple instances of the same type without names causes overwriting.

Wrong approach:

GetIt.I.registerSingleton(MyService());
GetIt.I.registerSingleton(MyService()); // overwrites previous

Correct approach:

GetIt.I.registerSingleton(MyService(), instanceName: 'first');
GetIt.I.registerSingleton(MyService(), instanceName: 'second');

Root cause:

By default, GetIt keys registrations by type only; names are needed for multiples.

Key Takeaways

Dependency injection separates object creation from usage, making apps easier to maintain and test.

GetIt is a simple service locator in Flutter that lets you register and retrieve shared objects anywhere in your app.

You must register services before using them, and choose between eager, lazy, or factory registration based on your needs.

GetIt does not handle UI updates automatically; combine it with state management tools for reactive apps.

Understanding GetIt's design and limitations helps you build scalable, clean Flutter apps with well-managed dependencies.