Guice Dependency Injection: Concepts, Usage, and Best Practices

Guice is a Google‑open‑source dependency injection library that is smaller and faster than Spring IoC, widely used in projects like Elasticsearch. It reduces the need for factory methods and new calls, making code easier to test and reuse.

Learning objectives include an overview of Guice, a quick start example, core concepts (binding, scope, injection), and official best practices.

Quick start shows a BillingService interface and a RealBillingService implementation. The example demonstrates how to replace manual new creation with Guice‑managed instances.

Modules and bindings are defined by extending AbstractModule and overriding configure() . Example binding code:

bind(TransactionLog.class).to(DatabaseTransactionLog.class);
bind(CreditCardProcessor.class).to(PaypalCreditCardProcessor.class);
bind(BillingService.class).to(RealBillingService.class);

Guice supports several binding styles:

Linked binding : maps an interface to an implementation.

Annotated binding : uses custom annotations (e.g., @PayPal ) or the built‑in @Named to differentiate multiple implementations.

Instance binding : binds a concrete value, such as bind(String.class).annotatedWith(Names.named("JDBC URL")).toInstance("jdbc:mysql://localhost/pizza") .

@Provides method binding : a method annotated with @Provides returns the object to bind, allowing custom construction logic.

Provider binding : binds a Provider implementation for complex creation logic.

Constructor binding (Guice 3.0): binds a specific constructor when multiple are present.

Scopes control object lifecycles. By default Guice creates a new instance each injection, but you can declare @Singleton , request, or session scopes, or use .in(Singleton.class) in bindings. Eager singletons can be created with .asEagerSingleton() to surface initialization errors early.

Injection methods include constructor injection (the preferred way), method injection, and field injection. Optional injection can be declared with @Inject(optional = true) to avoid errors when a binding is missing.

Assisted injection solves the problem of parameters that cannot be injected by generating a factory. Example:

public class RealPayment @Inject (CreditService creditService, @Assisted Date startDate, @Assisted Money amount) { ... }

Guice can automatically generate the factory interface using FactoryModuleBuilder :

install(new FactoryModuleBuilder()
    .implement(Payment.class, RealPayment.class)
    .build(PaymentFactory.class));

Best practices recommend using constructor injection for mandatory dependencies, keeping modules focused on configuration, preferring @Provides for complex creation, and leveraging assisted injection for objects that need runtime parameters.

Author: GinoBeFunny – the article also links to a large collection of interview questions and additional technical resources.