google/guice
Guice
Guice is a Java dependency injection framework and component container. It automates object wiring by mapping interfaces to implementations via a central injector, removing the need for manual factory patterns and constructor calls.
The framework provides specialized support for aspect-oriented programming, allowing for the interception and modification of method execution to implement shared cross-cutting concerns. It also functions as a persistence manager to coordinate transaction boundaries and manage the lifecycle of entity managers within a dependency-injected environment.
Its core capabilities include a type-safe binding registry, support for named and multi-instance dependencies, and hybrid instantiation strategies that combine automatic injection with manual factory arguments. It further handles external framework coordination to share resources across different environment specifications.
Features
- Dependency Injection - Automates the creation and wiring of object dependencies in Java applications using a central injector.
- Dependency Injection Containers - Resolves object dependencies automatically to replace manual factory patterns and constructor calls.
- Java Component Containers - Functions as a component container that handles the lifecycle and provisioning of application objects.
- Dependency Mapping - Maps interfaces to concrete implementations by scanning for specific Java annotations during configuration.
- Static Injection Frameworks - Provides a Java-based dependency injection framework for automating object wiring.
- Constructor Injection - Resolves object graphs by recursively instantiating dependencies and passing them into class constructors at runtime.
- Automatic Constructor Injection - Provides required objects to a class constructor automatically based on provided annotations.
- Dependency Injection - Wires application components by injecting required dependencies into objects during runtime.
- Interface-to-Implementation Bindings - Defines bindings between interfaces and concrete classes to decouple components and improve modularity.
- Object Management Systems - Returns fully initialized instances of bound classes from a centralized injector.
- Decoupled Architectures - Maps interfaces to concrete implementations to decouple business logic from technical details.
- Type-Safe Binding Registries - Stores associations between requested types and their providers in a centralized map for consistent instance retrieval.
- Persistence Unit Managers - Provisions entity managers and handles transactional units of work including rollbacks.
- Java Persistence Toolkits - Manages entity managers and coordinates transaction boundaries within a dependency-injected environment.
- Persistence Layers - Integrates the persistence layer by managing the lifecycle of database entity managers and transactional units of work.
- Aspect-Oriented Programming - Provides specialized support for aspect-oriented programming to implement cross-cutting concerns like logging or security.
- Aspect-Oriented Programming Frameworks - Intercepts and modifies method execution behavior to implement shared concerns without changing core business logic.
- Dependency Qualifiers - Associates dependencies with string identifiers to distinguish between multiple implementations of the same type.
- Hybrid Instantiation Strategies - Creates object instances by merging manual factory arguments with automatically injected dependencies.
- Lazy Instance Provisioning - Creates and configures objects only when they are requested by the injector to optimize startup time.
- Multi-Instance Bindings - Groups related objects into a single collection for injection into a dependent component.
- Provider Patterns - Wraps object creation in provider classes to allow for lazy initialization and controlled lifecycle management.
- Assisted Injection Interfaces - Uses factory interfaces and injection to create objects requiring both dependencies and runtime arguments.
- Runtime Proxy Interceptors - Uses Java dynamic proxies to wrap objects and execute cross-cutting logic before or after method calls.
- Dependency Injection - Lightweight dependency injection framework for Java.
- Developer Productivity - Dependency injection framework for managing object lifecycles and wiring.
