Dependency Injection in Java

Imagine you are developing a user service in a typical web application. This service requires access to a database to retrieve, update, and delete user information. Traditionally, such a service might directly instantiate its database access classes, leading to a tightly coupled system. This coupling makes it difficult to switch out the database layer for a different implementation or to mock this layer for unit testing, as the user service is directly dependent on a specific implementation of the database layer.

This complexity becomes especially pronounced in the development of large-scale applications, where classes often rely on various services and modules to function. Without a systematic approach to managing these dependencies, developers can find themselves entangled in a web of tightly coupled components, making the system hard to understand, maintain, and test.

This is where Dependency Injection comes in handy.

Let’s discuss

Dependency Injection

Dependency Injection (DI) is a design pattern that allows a class’s dependencies to be injected into it from the outside, rather than having the class create them internally. This pattern facilitates loose coupling between components, enhancing the modularity, scalability, and testability of the application.

Features

• Loose Coupling: DI reduces the coupling between classes, making the system more flexible and adaptable to changes.
• Ease of Testing: By injecting dependencies, especially interfaces or abstract classes, it becomes easier to replace real dependencies with mock objects for testing.
• Improved Code Maintenance: DI encourages modular architecture, making the system more organized and easier to manage.
• Enhanced Scalability: With dependencies being managed externally, it’s easier to add new functionalities without affecting existing code.

Types of Dependency Injection

Constructor Injection:

Dependencies are provided through the client’s constructor.

public class ClientService {
    private final Dependency dependency;

    public ClientService(Dependency dependency) {
        this.dependency = dependency;
    }
}

This approach ensures that the ClientService class always has the Dependency it needs to function, as it must be provided at the time of creation. This method is the most common form of DI, as it creates an inherently immutable and thread-safe object once constructed. It clearly communicates dependencies and ensures they are resolved at the time of instantiation, making it less prone to runtime errors.

Setter Injection:

Setter injection involves providing the dependency through a public setter method rather than through the constructor.

public class ClientService {
    private Dependency dependency;

    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

This method allows for the possibility of changing the dependency of a class at runtime. However, it also means that there’s a period where the class exists without its dependency, potentially leading to a null pointer exception if the class is used before its dependency is set.

Interface Injection:

Interface injection requires the dependent class to implement an interface that includes a setter method for the dependency.

public interface DependencyInjector {
    void injectDependency(Dependency dependency);
}

public class ClientService implements DependencyInjector {
    private Dependency dependency;

    @Override
    public void injectDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

This method forces the implementation of a method to set the dependency, ensuring that the class is ready to manage the dependency’s injection but is less commonly used than the other two methods.

For most use cases, Constructor Injection is recommended due to its simplicity, clarity, and immutability it offers, making it a safe default choice. However, the ultimate decision should be based on the specific needs of the application and the dependencies being injected.

Implementing User Service

Let’s consider a simple example of a REST service where a controller depends on a service class, which in turn depends on a repository class.

Step 1: Define the Dependencies

In this setup, the UserService does not need to know the specifics of the UserRepository implementation. It could be interacting with a SQL database, a NoSQL database, or even a mock repository for testing purposes.

// Define an interface for our database access layer. 
public interface UserRepository {
    User findUserById(String userId);
}

public class UserRepositoryImpl implements UserRepository {
    @Override
    public User findUserById(String userId) {
        // Implementation to fetch user from the database
    }
}

// Implement the user service, injecting the 
// UserRepository dependency through the constructor.
public class UserService {
    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public User getUserById(String userId) {
        return userRepository.findUserById(userId);
    }
}

Step 2: Inject Dependencies

public class UserController {
    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    // Method to handle HTTP request
    public User getUser(String userId) {
        return userService.getUserById(userId);
    }
}

Step 3: Configure and Use the Injector

In a real-world application, a Dependency Injection framework (like Spring Framework for Java) would be used to wire up the dependencies. Here’s a simplistic way to manually inject dependencies:

public class Application {
    public static void main(String[] args) {
        UserRepository userRepository = new UserRepositoryImpl();
        UserService userService = new UserService(userRepository);
        UserController userController = new UserController(userService);

        // Use the userController to handle requests
    }
}

Future Use Case

Dependency Injection is not limited to managing database dependencies. It can be used across the application to manage configurations, services, and even complex middleware. As applications grow, DI plays a crucial role in maintaining a clean architecture, promoting scalability and flexibility.

Dependency Injection Frameworks

Several frameworks provide support for Dependency Injection, simplifying the process of wiring up dependencies. Some popular DI frameworks include:

• Spring Framework (Java): Offers comprehensive DI functionality along with a wide range of enterprise features.
• Google Guice (Java): A lightweight framework that provides an API for DI.
• Microsoft .NET Core / .NET Framework: Has built-in support for DI in ASP.NET Core applications.
• Dagger 2 (Java, Android): A compile-time DI framework for Java and Android.

Conclusion

Dependency Injection is a powerful pattern for managing dependencies in software applications. By decoupling classes and their dependencies, DI facilitates easier maintenance, testing, and evolution of software systems. While it may introduce complexity in terms of setup and configuration, especially in large projects, the benefits in terms of flexibility, testability, and scalability are significant. Whether manually implemented or using a framework, DI is a key technique in modern software development practices.

That’s all about “Dependency Injection”. Send us your feedback using the message button below. Your feedback helps us create better content for you and others. Thanks for reading!

If you like the article please click the 👏🏻 button below a few times. To show your support!

Follow us on Twitter and LinkedIn