Dependency Injection (DI) is a design pattern where objects receive dependencies externally, promoting loose coupling and easier testing through constructor, setter, or field injection. 2. Spring Framework uses annotations like @Component, @Service, and @Autowired with Java-based configuration via @Configuration and @Bean, supports component scanning, and emphasizes constructor injection, profiles, and modular configuration for enterprise applications. 3. Google Guice relies on modules extending AbstractModule to define bindings, uses Injector for object creation, supports constructor injection with @Inject, and offers provider bindings, scopes, assisted injection, and just-in-time resolution for lightweight, high-performance applications. 4. Choose Spring for full-stack enterprise development with extensive integrations and ecosystem support, or Guice for minimal overhead, explicit configuration, and fast startup in microservices or CLI tools. 5. Best practices include favoring interfaces, avoiding circular dependencies using @Lazy or Provider, writing unit tests with mocked dependencies, understanding bean scopes, and organizing configurations into logical modules to enhance maintainability, scalability, and testability in Java applications.

Dependency Injection (DI) is a core concept in modern Java development, enabling cleaner, more modular, and testable code. Two of the most popular frameworks that implement DI are Spring and Google Guice. While they serve similar purposes, their approaches, configurations, and ecosystems differ. Let’s explore how to master dependency injection using both, highlighting key patterns, best practices, and practical examples.

1. Understanding Dependency Injection Basics

Before diving into frameworks, it's important to understand what DI is:

• Dependency Injection is a design pattern where objects receive their dependencies from an external source rather than creating them internally.
• It promotes loose coupling, reusability, and easier testing.
• The three main types are:
  • Constructor Injection
  • Setter Injection
  • Field Injection (not recommended for production)

Example without DI:

public class OrderService {
    private PaymentGateway gateway = new StripePaymentGateway(); // tight coupling
}

With DI:

public class OrderService {
    private final PaymentGateway gateway;

    public OrderService(PaymentGateway gateway) {
        this.gateway = gateway; // injected
    }
}

Now, let’s see how Spring and Guice handle this.

2. Mastering DI with Spring Framework

Spring is the most widely used Java framework for enterprise applications. Its DI container is part of the Spring Core module.

Key Concepts in Spring DI

• Beans: Objects managed by the Spring IoC container.
• @Component, @Service, @Repository: Stereotype annotations to mark classes as beans.
• @Autowired: Injects dependencies automatically (can be used on constructors, setters, or fields).
• @Configuration and @Bean: Java-based configuration alternative to XML.

Example: Spring DI with Annotations

@Component
public class EmailService implements NotificationService {
    public void send(String message) {
        System.out.println("Email sent: "   message);
    }
}

@Service
public class UserService {
    private final NotificationService notificationService;

    // Constructor injection (recommended)
    public UserService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void register(String email) {
        // business logic
        notificationService.send("Welcome!");
    }
}

Enable component scanning in configuration:

@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
}

Bootstrapping (main method):

public class Main {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
        userService.register("user@example.com");
    }
}

Best Practices in Spring

• Prefer constructor injection over field injection.
• Use @Primary or @Qualifier when multiple beans of the same type exist.
• Leverage profiles (@Profile) for environment-specific beans.
• Keep configuration clean with modular @Configuration classes.

3. Mastering DI with Google Guice

Guice is a lightweight, fast DI framework from Google. It uses Java code (no XML) and emphasizes simplicity and performance.

Key Concepts in Guice

• Module: A class extending AbstractModule where bindings are defined.
• Injector: Creates and injects dependencies.
• Binding: Defines which implementation should be used for an interface.

Example: Guice DI Setup

Define an interface and implementation:

public interface NotificationService {
    void send(String message);
}

public class SmsService implements NotificationService {
    public void send(String message) {
        System.out.println("SMS sent: "   message);
    }
}

Create a module to bind dependencies:

public class AppModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(NotificationService.class).to(SmsService.class);
    }
}

Inject and use:

public class UserService {
    private final NotificationService notificationService;

    @Inject
    public UserService(NotificationService notificationService) {
        this.notificationService = notificationService;
    }

    public void register(String phone) {
        notificationService.send("Welcome!");
    }
}

Main method with Guice injector:

public class Main {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new AppModule());
        UserService userService = injector.getInstance(UserService.class);
        userService.register(" 123456789");
    }
}

Advanced Guice Features

• Provider bindings: For lazy or complex instantiation.
• Scopes: @Singleton, custom scopes.
• Assisted Injection: For objects needing runtime parameters.
• Just-In-Time Bindings: Guice can auto-resolve bindings if unambiguous.

4. Spring vs Guice: When to Use Which?

Use Spring if:

• You're building a full web application (Spring Boot).
• You need integration with databases, security, messaging, etc.
• Your team is already familiar with Spring.

Use Guice if:

• You want minimal overhead (e.g., microservices, CLI tools).
• You prefer clean, explicit configuration.
• You value fast startup and low runtime cost.

Final Tips for Mastering DI

• Favor interfaces over concrete classes – makes swapping implementations easy.
• Avoid circular dependencies – refactor or use @Lazy (Spring) or Provider<t></t> (both).
• Write unit tests – DI makes mocking dependencies straightforward.
• Understand scopes: singleton vs prototype vs request-scoped beans.
• Keep modules/configurations organized – group related bindings.

DI is not just a framework feature — it's a mindset. Whether you choose Spring for its power or Guice for its simplicity, mastering dependency injection will make your Java applications more maintainable, scalable, and testable.

Basically, start small, inject responsibly, and let the container do the wiring.

The above is the detailed content of Mastering Dependency Injection in Java with Spring and Guice. For more information, please follow other related articles on the PHP Chinese website!