Advanced Dependency Injection with get it and injectable in Flutter

Introduction

Dependency injection is a cornerstone of maintainable, testable Flutter apps. While simple service locators suffice for smaller projects, scaling complex applications demands a more robust approach. Combining the get_it package with injectable’s code generation empowers you to automate wiring, handle scoping, and support multiple environments—all while keeping your code clean. In this advanced tutorial, you’ll learn how to supercharge your Flutter dependency injection using get_it and injectable.

Setting Up get_it and injectable

First, add the core packages to your pubspec.yaml:

dependencies:
  get_it: ^7.2.0
  injectable: ^2.1.0

dev_dependencies:
  build_runner: ^2.3.0
  injectable_generator

Next, create a configuration file for injectable (e.g., injectable_config.yaml) to define your preferred annotations and environments. A minimal setup looks like:

generate_for:
  - lib/**.dart
environment

Then, add a file lib/injection.dart to bootstrap your service locator:

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

final GetIt getIt = GetIt.instance;

/// Call this at app startup.
@InjectableInit()
void configureDependencies(String environment) =>
    $initGetIt(getIt, environment: environment);

Run the code generator with:

flutter pub run build_runner build --delete-conflicting-outputs

This will produce injection.config.dart, wiring your annotated classes into get_it.

Defining and Annotating Services

Now let’s define services using injectable annotations. You have full control over lifecycle and scoping:

import 'package:injectable/injectable.dart';

@lazySingleton
class ApiClient {
  final String baseUrl;
  ApiClient(@Named('baseUrl') this.baseUrl);

  Future<String> fetchData() async {
    // Implementation...
  }
}

@injectable
class UserRepository {
  final ApiClient apiClient;
  UserRepository(this.apiClient);

  Future<User> getUserDetails(String id) => apiClient.fetchData().then((data) => User.fromJson(data));
}

Annotations explained:

• @injectable creates a transient factory.

• @singleton shares one instance.

• @lazySingleton instantiates upon first use.

• @Named or @Environment handle primitive injections (strings, ints).

To inject primitive values, define a module:

@module
abstract class RegisterModule {
  @Named('baseUrl')
  String get baseUrl => 'https://api.myapp.dev';

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

Modules group non-class dependencies—ideal for configuration or async resources.

Managing Environments and Flavors

Advanced Flutter dependency injection often requires environment-specific setups (development vs. production). injectable makes this seamless. In your service or module annotation, specify environments:

@injectable
@Environment('production')
class ProductionAnalyticsService implements AnalyticsService {
  // production implementation
}

@injectable
@Environment('development')
class DevAnalyticsService implements AnalyticsService {
  // dev implementation
}

When initializing:

void main() {
  const env = bool.fromEnvironment('dart.vm.product') ? 'production' : 'development';
  configureDependencies(env);
  runApp(MyApp());
}

By matching the environment string, get_it will register only the desired implementations—achieving flavor-based dependency injection without boilerplate.

Utilizing Generated Code in Flutter

In your Flutter UI code, retrieving a service is simple:

final userRepo = getIt<UserRepository>();

However, for widget testing or state management (e.g., Riverpod, Bloc), you can override dependencies:

testWidgets('ProfilePage shows user name', (tester) async {
  final testRepo = MockUserRepository();
  getIt.allowReassignment = true;
  getIt.registerSingleton<UserRepository>(testRepo);

  await tester.pumpWidget(MyApp());
  // Assertions...
});

This pattern elevates your integration and widget tests, giving fine-grained control over the DI graph.

Vibe Studio

For teams looking to accelerate Flutter development even further, consider Vibe Studio. Vibe Studio, powered by Steve’s advanced AI agents, is a revolutionary no-code, conversational platform that empowers users to quickly and efficiently create full-stack Flutter applications integrated seamlessly with Firebase backend services. Ideal for solo founders, startups, and agile engineering teams, Vibe Studio allows users to visually manage and deploy Flutter apps, greatly accelerating the development process. The intuitive conversational interface simplifies complex development tasks, making app creation accessible even for non-coders.

Conclusion

Mastering dependency injection with get_it and injectable transforms your Flutter codebase from ad-hoc service locators into a scalable, environment-aware architecture. With injectable Flutter dependency injection and the power of Vibe Studio, you’re equipped to build robust, maintainable, and scalable Flutter applications.