Chapter 2: Understanding Dependency Injection

In this chapter, we will learn what Dependency Injection (DI) is and how we can use it with the Spring Boot framework. The Spring Boot framework provides DI; therefore, it is good to understand the basics. DI reduces component dependencies and makes your code easier to test and maintain.

In this chapter, we will look into the following:

• Introducing DI
• Using DI with Spring Boot

Technical requirements

Java SDK version 8 or higher is necessary to use Eclipse IDE. In this book, we are using Windows, but all the tools are available for Linux and macOS as well.

All of the code for this chapter can be found at the following GitHub link: https://github.com/PacktPublishing/Full-Stack-Development-with-Spring-Boot-and-React/tree/main/Chapter02.

Introducing DI

DI is a software development technique where we can create objects that depend on other objects. DI helps with interaction between classes but at the same time keeps the classes independent.

There are three types of classes in DI:

• A service is a class that can be used (this is the dependency).
• The client is a class that uses the dependency.
• The injector passes the dependency (the service) to the dependent class (the client).

The three types of classes in DI are shown in the following diagram:

Figure 2.1 – DI

DI makes classes loosely coupled. This means that the creation of client dependencies is separated from the client's behavior, which makes unit testing easier.

Let's take a look at a simplified example of DI using Java code. In the following code, we don't have DI, because the client Car class is creating an object of the service class:

public class Car { 
  private Owner owner...

Using DI in Spring Boot

Spring Boot scans your application classes and registers classes with certain annotations (@Service, @Repository, and @Controller) as Spring beans. These beans can then be injected using an @Autowired annotation:

public class Car {
  @Autowired
  private Owner owner;
  ...
}

A fairly common situation is where we need database access for some operations, and, in Spring Boot, we use repository classes for that. In this situation, we can inject the repository class and start to use its methods:

public class Car {
  @Autowired
  private CarRepository carRepository;
  // Fetch all cars from db carRepositoty.findAll();
  ...
}

Java (javax.annotation) also provides an @Resource annotation that can be used to inject resources. You can define the name or type of the injected bean when using the @Resource annotation. For example, the following code shows some use cases. Imagine that we have...

Summary

In this chapter, we learned what DI is. We also learned how to use DI in the Spring Boot framework, which we are using in our backend.

In the next chapter, we will look at how we can use the Java Persistent API (JPA) with Spring Boot and how to set up a MariaDB database. We will also learn about the creation of CRUD repositories and the one-to-many connection between database tables.

Questions

1. What is DI?
2. How does the @Autowired annotation work in Spring Boot?
3. How do you inject resources in Spring Boot?

Further reading

Packt has other great resources for learning about Spring Boot:

• Learning Spring Boot 2.0 (Second Edition) by Greg L. Turnquist (https://www.packtpub.com/product/learning-spring-boot-2-0-second-edition/9781786463784)
• Spring 5.0 Projects by Nilang Patel (https://www.packtpub.com/product/spring-5-0-projects/9781788390415)