What is interface injection?

Interface injection is a dependency injection technique that is a design pattern widely used in object-oriented programming that promotes loose component coupling in a software system. Interface injection emphasizes injecting dependency through interfaces instead of concrete implementation, with which we can achieve flexibility and maintainability in software designs.

This Answer will delve deep into the fundamentals of interface injection, its benefits, and practical coding examples to better understand its usage.

Interface injection

Interface injection focuses on using interfaces as contracts between different components. An interface contains a set of method definitions a class must implement. Classes can work with any function implementation that complies with the defined contracts by interface injection, which enables components to be swapped out without changing the existing codebase.

Implementing interface injection

Here’s an example in TypeScript to illustrate interface injection, which supports interfaces:

interface Shape {
    area(): number;
}
// Class that depends on the Shape interface (Interface Injection)
class CreateShape {
    private shape: Shape;
    constructor(shape: Shape) {
        this.shape = shape;
    }
    calculateArea() {
        return this.shape.area();
    }
}
class Circle implements Shape {
    private radius: number;
    constructor(radius: number) {
        this.radius = radius;
    }
    area() {
        return Math.PI * this.radius * this.radius;
    }
}
class Square implements Shape {
    private side: number;
    constructor(side: number) {
        this.side = side;
    }
    area() {
        return this.side * this.side;
    }
}
const circle = new Circle(5);
const square = new Square(4);
const circleShape = new CreateShape(circle);
const squareShape = new CreateShape(square);
console.log("Circle Area:", circleShape.calculateArea()); // Output: Circle Area: 78.53981633974483
console.log("Square Area:", squareShape.calculateArea()); // Output: Square Area: 16

Lines 1–3: We define an interface named Shape. An interface defines a contract for the classes to follow. In this case, any class implementing the Shape interface must have a method area that returns a number.
Lines 5–17: The CreateShape class takes a dependency on the Shape interface through its constructor. This means it can hold any object that implements the Shape interface. This is where interface injection occurs; an external object that adheres to the Shape interface is injected into the CreateShape class.
- Line 7: We declare a shape private property of the Shape type. This property will hold an object that implements the Shape interface.
- Line 11: The constructor assigns the argument of Shape type to the shape property of the CreateShape class.
- Lines 14–16: The calculateArea method calls the area method of the object stored in the shape property without knowing the specific implementation details.
Lines 20–30: The Circle class implements the Shape interface and its area function is implementing the method required by the Shapejwhich calculates the area of the circle with the given radius.
Lines 32–42: The Square class implements the Shape interface. Its area function implements the method required by the Shape interface, which calculates the area of the square with the given dimension.
Lines 44–45: We create the instances of the Circle and Square classes respectively.
Line 47: Here, we create the class instance of CreateShape and inject the circle object into its contructor. Now, the circleShape calculates the area of the circle.
Line 49: We create the class instance of CreateShape and inject the square object in its constructor, which ultimately calculates the area of the square.
Lines 51–52: We call the instances of CreateShape, which in turn calls the area method of the injected objects further logged to the console.

Benefits of interface injection

Here are a few benefits of using interface injection:

Flexibility and extensibility: It promotes flexibility by allowing easy substitution of implementations. Extensibility and scalability are ensured by adding new implementations without modifying existing code.
Testability: Interfaces make testing a simple and easy process by allowing us to use mock objects. Full unit testing can be done by injecting interfaces using mock implementations without involving their concrete implementations.
Reduced coupling: By using interfaces, coupling between components can be reduced, and using such components results in a more modular and maintainable codebase because these components rely on abstractions (interfaces) instead of their concrete implementations.

Wrap up

Interface injection is a potent technique in the realm of dependency injection. Using interfaces between components as contracts promotes flexibility, testability, and reduced coupling in object-oriented systems. We can create more maintainable, modular, and testable applications by incorporating interface injection into our software design practices. It also ensures the robustness of the codebase in case of changing requirements and future expansions.

Free Resources