#4 IoC and DI in Spring

Main ideas / concepts conveyed

• Purpose of typical applications (server-side context)

  • Most applications are data-driven: users (client) view data, which usually comes from a database or external services.
  • A server-side layer handles requests and communicates with the database (e.g., via Servlets in Java).
  • The video frames a typical architecture as layered, including:
    • A controller-like layer: accepts client requests and handles business-flow logic.
    • A service-like layer: performs business logic.
    • A repository-like layer: connects to the database (data access).

• Problem with manual object creation (tightly coupled design)

  • In plain Java OOP, if one class (e.g., Controller) needs another class (e.g., Service), you normally:
    • create an object inside the dependent class (conceptually using new).
  • This becomes burdensome at scale:
    • With many classes, you end up managing object lifecycle (creation/destruction across many requests).
    • Even if you don’t always need new instances, you may still create them repeatedly per request.

• Inversion of Control (IoC): a principle

  • IoC is described as a philosophy/principle:
    • Instead of the developer controlling object creation, “someone else” handles it.
    • The developer focuses on application logic, not object management.
  • In IoC terms, control over dependencies is inverted from the application code to an external mechanism.

• Dependency Injection (DI): the implementation technique

  • DI is presented as the practical way to implement IoC in Spring/Java.
  • DI is described as a mechanism where:
    • The application asks for dependencies rather than constructing them with new.
    • An external framework (Spring) provides (“injects”) the required objects.

• DI + layered example (Controller → Service)

  • Instead of the controller doing new Service(), the controller can:
    • declare that it needs a Service reference
    • and Spring injects it at runtime.

• Types/techniques of Dependency Injection (detailed list)

  1. Constructor Injection
     • In the dependent class (e.g., Controller), define a constructor that takes the dependency (e.g., Service) as a parameter.
     • Spring injects the dependency by providing the reference through the constructor.
  2. Setter Injection
     • Provide a setter method (e.g., setService(...)) for the dependency.
     • Spring calls the setter to inject the dependency reference.
  3. Field Injection
     • Inject the dependency directly into a field (using Spring injection into a class member).
     • The speaker notes concerns:
       • Can reduce ability to mock test
       • Less favorable for loose coupling practices
     • In the course context:
       • Field injection is used in the course, but the speaker also emphasizes that Constructor and Setter approaches will be covered and are preferred.

• Course note / recommendation

  • The speaker warns not to use field injection as the recommended approach (though the course may still demonstrate it).
  • The likely goal is to build understanding first, then emphasize better practices (Constructor/Setter DI).

Speakers / sources featured

• Speaker: A single presenter, identified only as “z ready” (the video narrator).
• Source/framework mentioned: Spring Framework (and indirectly Java/Servlets as background context).