square/daggerArchived
Dagger
Dagger is a compile-time dependency injection framework for Java and Android that automates object creation and lifecycle management. It functions as a static dependency injector and graph validator, resolving object requirements during the build process to avoid runtime reflection and prevent crashes caused by missing bindings.
The framework distinguishes itself by using static analysis and code generation to produce factory classes at build time. It employs qualifier-based type differentiation to manage multiple implementations of the same type and provides scope-based lifecycle management to control object longevity, such as shared singletons or lazy initialization.
The system covers a broad range of capabilities including automated dependency provisioning through annotated constructors, component binding management via modules, and the ability to override bindings with mocks for isolated unit testing. It further supports static field injection and the mapping of types to specific implementations.
Features
- Static Injection Frameworks - Implements a Java-based dependency injection framework that uses compile-time code generation instead of reflection.
- Dependency Injection - Automates the creation and delivery of object dependencies through a compile-time dependency injection framework.
- Static Dependency Resolution - A framework that resolves object dependencies during the build process to avoid expensive runtime reflection.
- Static Dependency Resolution - Determines object requirements by analyzing source code at build time instead of searching memory at runtime.
- Android Dependency Management - Automates the creation and delivery of object dependencies specifically within Android applications.
- Dependency Mapping - Maps dependencies by scanning Java annotations to determine the required implementation types at compile time.
- Dependency Injection - Instantiates and delivers required objects to classes by resolving complex dependency graphs.
- Automated Object Delivery - Reduces manual boilerplate by automating the creation and delivery of object dependencies throughout the application.
- Factory Generators - Generates Java factory classes at build time to instantiate objects without using runtime reflection.
- Object Lifecycle Management - Controls whether dependencies are created as singletons, initialized lazily, or instantiated fresh for every request.
- Graph Validation - Analyzes the dependency graph during compilation to detect missing bindings or circular dependencies.
- Service Lifetime Scopes - Manages object longevity through scope definitions like singletons or activity-level caches.
- Dependency Scopes - Controls object longevity by supporting shared singletons, lazy initialization, or fresh instances for every request.
- Custom Binding Definitions - Provides a mechanism to define dependencies for interfaces or third-party classes using provider methods.
- Dependency Qualifiers - Uses qualifier annotations to distinguish between multiple implementations of the same type.
- Interface-to-Implementation Bindings - Maps abstract interfaces to concrete class implementations and supports contributing multiple values to set bindings.
- Java Application Architecture - Manages complex object graphs and class lifecycles in Java projects to improve modularity and testability.
- Compile-Time Validators - Verifies the integrity of the dependency graph during the build process to ensure all bindings are satisfied.
- Binding Replacements - Enables replacing production implementations with substitute objects or mocks for isolated unit testing.
- Unit Testing - Supports isolating components during testing by replacing production implementations with mocks.
- Dependency Injection - Fast, compile-time dependency injection for Java and Android.
- Developer Utilities - Dependency injection framework for Java and Android.
- ProGuard Configurations - Provides dependency injection configuration rules.
