13:34
#6 Dependency Injection using Spring Boot
Telusko
Overview
This video demonstrates how to implement Dependency Injection (DI) in Spring Boot by creating a simple project without web dependencies. It explains the concept of the Spring IoC container, which manages the creation and lifecycle of objects (beans). The tutorial walks through manually creating objects versus letting Spring manage them using the `@Component` annotation, illustrating how Spring injects dependencies to avoid manual object instantiation and management, thereby simplifying application development.
How was this?
Save this permanently with flashcards, quizzes, and AI chat
Chapters
- Create a new Spring Boot project using Spring Initializr, selecting Maven and Java, but no initial dependencies (like 'web').
- The default `pom.xml` will include the `spring-boot-starter`.
- The main application class, when run with `SpringApplication.run()`, initializes the Spring IoC container.
A minimal project setup is crucial for focusing on core concepts like dependency injection without unnecessary complexities.
Generating a project from start.spring.io with Maven, Java, and no dependencies, then opening it in an IDE like IntelliJ.
- The Spring IoC (Inversion of Control) container is a core component within the JVM that manages application objects (beans).
- Instead of developers manually creating objects (`new Class()`), the container is responsible for instantiating, configuring, and assembling them.
- The `SpringApplication.run()` method in the main application class is responsible for creating and starting this IoC container.
Understanding the IoC container is fundamental to grasping how Spring manages object lifecycles and dependencies, which is the essence of DI.
Visualizing the IoC container as a 'green box' inside the JVM where Spring places and manages objects, initiated by `SpringApplication.run()`.
- Traditionally, developers create objects manually using the `new` keyword (e.g., `Dev obj = new Dev();`).
- This manual creation means the developer is responsible for the object's entire lifecycle.
- Spring's philosophy is to invert this control, where the container manages object creation and provides them when needed.
Recognizing the limitations of manual object creation highlights the benefits and necessity of using a framework like Spring for managing dependencies.
Writing `Dev obj = new Dev();` and then calling `obj.build();` versus aiming to have Spring provide the `Dev` object.
- To get objects managed by Spring, you need a reference to the `ApplicationContext` (the IoC container).
- The `SpringApplication.run()` method returns an object of type `ConfigurableApplicationContext`, which extends `ApplicationContext`.
- The `ApplicationContext` provides a `getBean()` method to retrieve instances of managed objects (beans) by their class type.
Learning how to interact with the `ApplicationContext` is key to accessing the objects that Spring has created and manages for your application.
Assigning the result of `SpringApplication.run(MyAppApplication.class).get()` to a `context` variable and then calling `context.getBean(Dev.class)`.
- By default, Spring does not automatically create objects for every class in the project to avoid unnecessary resource usage.
- To tell Spring to manage a class's lifecycle and create an object for it, annotate the class with `@Component`.
- This annotation signals to Spring that the class is a 'managed bean' and should be registered within the IoC container.
The `@Component` annotation is the primary mechanism for declaring classes that Spring should manage, enabling dependency injection.
Adding `@Component` above the `Dev` class definition, allowing `context.getBean(Dev.class)` to successfully retrieve an instance.
Key takeaways
- Dependency Injection (DI) is a design pattern where an object receives other objects it depends on, rather than creating them itself.
- Spring Boot's IoC container automates the creation and management of application objects (beans).
- The `SpringApplication.run()` method initializes the Spring IoC container.
- Developers should avoid manual object instantiation (`new`) in favor of letting Spring inject dependencies.
- The `@Component` annotation is used to mark classes that Spring should manage as beans.
- The `ApplicationContext` interface provides methods like `getBean()` to retrieve managed objects.
- By using DI and the IoC container, developers can build more modular, testable, and maintainable applications.
Key terms
Dependency Injection (DI)Spring BootIoC ContainerApplicationContextBeanSpring InitializrMaven@Component AnnotationManual Instantiation
Test your understanding
- What is the primary role of the Spring IoC container in an application?
- How does the `@Component` annotation enable dependency injection in Spring Boot?
- Why is it generally discouraged to manually create objects using `new` within a Spring Boot application?
- What is the purpose of the `ApplicationContext` interface, and how is it typically obtained in a Spring Boot application?
- Explain the difference between manual object creation and dependency injection managed by the Spring container.