evant/kotlin-inject
Kotlin Inject
Kotlin-inject is a dependency injection framework for Kotlin that utilizes compile-time code generation to construct type-safe object graphs. By processing declarative annotations during the build process, the library eliminates the need for runtime reflection, ensuring that dependency resolution and validation occur before the application executes.
The framework distinguishes itself through its native support for Kotlin Multiplatform, enabling consistent dependency management across shared and platform-specific codebases. It provides specialized mechanisms for assisted injection, allowing developers to combine injected services with runtime parameters, and supports hierarchical component composition to manage object lifecycles and state across different architectural layers.
The library covers a broad range of configuration and lifecycle management capabilities, including lazy initialization, circular dependency resolution, and the ability to substitute production implementations with mocks during testing. It also integrates directly with user interface frameworks to supply state and services, while allowing for variant-specific configurations to adapt to different build environments.
Features
- Compile-Time Dependency Injection Frameworks - Provides a compile-time dependency injection framework for Kotlin that constructs type-safe object graphs without runtime reflection.
- Compile-Time Dependency Resolution - Constructs type-safe object graphs during compilation to eliminate runtime overhead.
- Kotlin Multiplatform DI - Enables consistent dependency management across shared and platform-specific codebases in Kotlin Multiplatform projects.
- Compile-Time Code Generation - Validates dependency graphs and generates factory logic during the build process to eliminate runtime initialization overhead.
- Dependency Resolution - Provides type-safe dependency resolution by processing declarative annotations at compile time.
- Multiplatform Libraries - Supports shared code across Android, iOS, and desktop targets through platform-specific code generation.
- Dependency Qualifiers - Uses qualifiers or type aliases to distinguish between multiple instances of the same type.
- Lazy Providers - Wraps dependencies in functional providers to defer object construction until access.
- Lazy Initialization - Delays the creation of heavy objects until required to reduce startup time and memory usage.
- Hierarchical State Composition - Enables hierarchical component composition to manage object lifecycles across different application layers.
- Application Component Lifecycles - Controls object creation and destruction by scoping lifetimes to specific components or states.
- Dependency Injection Libraries - Automates the creation of platform-specific factory functions across shared and target source sets to bridge common and platform-specific code.
- Multiplatform Factory Generators - Produces platform-specific factory code from shared definitions to maintain consistent dependency management.
- Dependency Injection Hierarchies - Enables modular architecture by nesting component hierarchies to share dependencies.
- Dependency Injection Providers - Resolves dependencies directly into user interface components by providing state and services.
- Object Lifecycle Management - Groups dependencies within specific lifecycles or named scopes to control object sharing and automatic resource cleanup.
- Annotation-Based Injection - Uses declarative annotations to define component hierarchies, scoped lifetimes, and assisted injection factories.
- Assisted Injection Systems - Supports factory interfaces for classes requiring both injected services and runtime parameters.
- Dependency Graph Construction - Provides mechanisms to declare abstract components that automatically generate dependency injection logic.
- UI Component Injection - Supplies state and services directly into user interface components to simplify data flow.
- Assisted Injection Interfaces - Supports assisted injection interfaces to combine injected services with runtime parameters.
- Testability Optimizations - Facilitates testable software design by allowing production implementations to be substituted with mocks during the testing lifecycle.
- Dependency Mocking - Replaces production implementations with test-specific mocks by injecting custom configurations during the test lifecycle.
