Dependency Injection with Constructors

In our previous lesson, we explored how refactoring tight coupling with traits can enhance the testability and flexibility of our code. In this lesson, we will explore the concept of dependency injection, specifically focusing on constructor injection. This technique is a powerful tool for replacing hardcoded dependencies, allowing for more flexible and testable code. Reflecting on the previous course, we might notice that we already used dependency injection via constructors, and we'd be right!

Let's explore how constructor injection can transform our codebase into a more maintainable and adaptable system.

Hardcoded dependencies can be a significant obstacle in software development. They create tightly coupled code, making it difficult to test and maintain. When dependencies are hardcoded, any change in the dependency requires changes in the code that uses it, leading to a fragile system. Constructor injection offers a solution by allowing dependencies to be passed in at runtime, decoupling the code and making it more flexible.

Constructor injection provides several benefits, including improved code modularity and easier testing. By injecting dependencies through the constructor, we can easily swap out implementations for testing or future flexibility. This approach enhances the maintainability of our code, as changes to dependencies do not require changes to the code that uses them.

Let's walk through the process of refactoring the OrderProcessor class to use constructor injection. Initially, the class creates its dependency internally:

class OrderProcessor:
  private val emailService = EmailService()
  // ...

By refactoring to use constructor injection, we can pass this dependency in through the constructor:

class OrderProcessor(emailService: EmailService = EmailService()):
  // ...

This change allows us to provide different implementations of EmailService when creating an OrderProcessor instance, enhancing flexibility and testability.