■ Dependency Injection in Spring Boot – Complete
Guide
■ What Is Dependency Injection (DI)?
Dependency Injection (DI) is a design pattern used to reduce tight coupling between software
components. It means that instead of creating objects directly using the 'new' keyword, we receive
these objects (dependencies) from an external source like the Spring Framework. DI allows for
cleaner, more modular, and testable code.
■ Real-Life Analogy: Coffee Shop Example
Imagine you own a restaurant that needs a CoffeeMachine to serve coffee.
■ Without DI: The restaurant builds and manages its own coffee machine. It's tightly coupled and
hard to replace.
■ With DI: A supplier delivers the CoffeeMachine. The restaurant just uses it. It's modular and easy
to manage.
■ Code Example – Without and With DI
■ Without Dependency Injection:
public class Restaurant { private CoffeeMachine coffeeMachine; public Restaurant() {
coffeeMachine = new CoffeeMachine(); // tightly coupled } }
■ With Dependency Injection:
public class Restaurant { private final CoffeeMachine coffeeMachine; public
Restaurant(CoffeeMachine coffeeMachine) { [Link] = coffeeMachine; //
injected from outside } }
■ How Spring Boot Handles DI
Spring Boot automatically scans and creates objects (beans), manages their lifecycle via
ApplicationContext, and injects them wherever needed using annotations like @Autowired.
Example:
@Component public class CoffeeMachine { public void brew() {
[Link]("Brewing coffee..."); } } @Service public class Restaurant {
private final CoffeeMachine coffeeMachine; @Autowired public
Restaurant(CoffeeMachine coffeeMachine) { [Link] = coffeeMachine; }
public void serveCustomer() { [Link](); } }
■ Key Benefits of Dependency Injection
Loose Coupling: Change dependencies without modifying the main class Testability: Easily inject
mock dependencies for testing Clean Code: No need to manage object creation Scalability: Better
architecture for growing applications
■ Related Concepts
IoC (Inversion of Control): Shifts control of object creation from developer to framework Bean: A
Spring-managed object ApplicationContext: The Spring container that manages bean lifecycles
BeanFactory: A lightweight container, predecessor of ApplicationContext Autowired: Annotation
to enable DI automatically Bean Scopes: Singleton, Prototype, etc., define bean lifecycles
Lifecycle Callbacks: @PostConstruct, @PreDestroy hooks for bean init/destroy logic
■ Summary Table
TermMeaning DependencyExternal object a class needs InjectionProviding that object from outside
IoCFramework manages object creation BeanSpring-managed object @AutowiredAnnotation to
inject beans ApplicationContextMain Spring container
■ Interview Questions
What is Dependency Injection and why is it important? What are the different types of Dependency
Injection in Spring? How is ApplicationContext different from BeanFactory? What is the role of
@Component, @Service, and @Repository? What are the advantages of constructor injection over
field injection? What is the difference between Singleton and Prototype scope in Spring? Explain
the Inversion of Control principle with an example. What is the lifecycle of a Spring Bean? How
does Spring manage dependency injection internally? How can you test a Spring Bean that has
dependencies?