Dependency Injection in Java: Why and How?

Table of Contents

1. What is Dependency Injection?
2. Why Use Dependency Injection?
   • Loose Coupling
   • Testability
   • Flexibility and Maintainability
3. How to Implement Dependency Injection in Java
   • Constructor Injection
   • Setter Injection
   • Interface Injection
4. Common Practices
   • Using Dependency Injection Containers
   • Singleton and Prototype Scopes
5. Best Practices
   • Keep Dependencies Explicit
   • Avoid Over - Injection
6. Conclusion
7. References

What is Dependency Injection?

Dependency Injection is a principle that allows us to remove hard - coded dependencies and make our code more modular. Instead of an object creating its own dependencies, it receives them from an external source. For example, consider a Car class that depends on an Engine class. Without DI, the Car class would create its own Engine object. With DI, the Engine object is passed to the Car class from outside.

Why Use Dependency Injection?

Loose Coupling

When objects are tightly coupled, a change in one object’s implementation can have a cascading effect on other objects. Dependency Injection promotes loose coupling by separating the creation and use of dependencies. For instance, if we change the implementation of the Engine class, the Car class doesn’t need to be modified as long as the interface remains the same.

Testability

Testing becomes much easier with Dependency Injection. We can easily substitute real dependencies with mock objects during unit testing. For example, if a class depends on a database connection, we can pass a mock database connection during testing to isolate the class being tested.

Flexibility and Maintainability

DI makes the code more flexible as we can easily swap out different implementations of dependencies. It also improves maintainability because the code is more modular and easier to understand.

How to Implement Dependency Injection in Java

Constructor Injection

Constructor injection is the most common form of dependency injection. In this approach, dependencies are passed through the class’s constructor.

// Dependency class
class Engine {
    public void start() {
        System.out.println("Engine started");
    }
}

// Class that depends on Engine
class Car {
    private final Engine engine;

    public Car(Engine engine) {
        this.engine = engine;
    }

    public void startCar() {
        engine.start();
    }
}

// Usage
public class ConstructorInjectionExample {
    public static void main(String[] args) {
        Engine engine = new Engine();
        Car car = new Car(engine);
        car.startCar();
    }
}

Setter Injection

Setter injection allows dependencies to be set after the object is created.

// Dependency class
class Wheel {
    public void rotate() {
        System.out.println("Wheel rotating");
    }
}

// Class that depends on Wheel
class Bicycle {
    private Wheel wheel;

    public void setWheel(Wheel wheel) {
        this.wheel = wheel;
    }

    public void move() {
        if (wheel != null) {
            wheel.rotate();
        }
    }
}

// Usage
public class SetterInjectionExample {
    public static void main(String[] args) {
        Wheel wheel = new Wheel();
        Bicycle bicycle = new Bicycle();
        bicycle.setWheel(wheel);
        bicycle.move();
    }
}

Interface Injection

Interface injection requires the dependent class to implement an interface that defines a method to inject the dependency.

// Dependency interface
interface Fuel {
    void supply();
}

// Dependency implementation
class Gasoline implements Fuel {
    @Override
    public void supply() {
        System.out.println("Gasoline supplied");
    }
}

// Interface for injection
interface FuelInjectable {
    void injectFuel(Fuel fuel);
}

// Class that depends on Fuel
class Generator implements FuelInjectable {
    private Fuel fuel;

    @Override
    public void injectFuel(Fuel fuel) {
        this.fuel = fuel;
    }

    public void run() {
        if (fuel != null) {
            fuel.supply();
        }
    }
}

// Usage
public class InterfaceInjectionExample {
    public static void main(String[] args) {
        Fuel gasoline = new Gasoline();
        Generator generator = new Generator();
        generator.injectFuel(gasoline);
        generator.run();
    }
}

Common Practices

Using Dependency Injection Containers

Dependency injection containers like Spring and Guice can manage the creation and injection of dependencies automatically. They use configuration files or annotations to define the dependencies and their relationships.

Singleton and Prototype Scopes

In a dependency injection container, we can define the scope of a dependency. A singleton scope means that only one instance of the dependency is created and shared across the application. A prototype scope means that a new instance is created every time the dependency is requested.

Best Practices

Keep Dependencies Explicit

Make sure that dependencies are clearly defined and passed in a way that is easy to understand. Avoid hiding dependencies in static methods or global variables.

Avoid Over - Injection

Don’t inject more dependencies than a class actually needs. This can make the class more complex and harder to test.

Conclusion

Dependency Injection is a powerful design pattern in Java that offers numerous benefits such as loose coupling, improved testability, and better maintainability. By understanding the different ways to implement DI and following common and best practices, developers can write more modular and robust code. Whether using manual injection or a dependency injection container, DI is an essential tool in the Java developer’s toolkit.

References

• “Effective Java” by Joshua Bloch
• Spring Framework Documentation: https://spring.io/docs
• Guice Documentation: https://github.com/google/guice/wiki