The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Dependency Injection in Spring Boot

Next ►
►

Introduction

Dependency Injection (DI) is a fundamental concept in Spring Boot that allows for the decoupling of object creation and their dependencies. This makes your code more modular, testable, and maintainable. In this section, we will cover the basics of DI, how it works in Spring Boot, and provide practical examples to help you understand and implement it in your applications.

Key Concepts

What is Dependency Injection?

  • Definition: Dependency Injection is a design pattern that allows an object to receive its dependencies from an external source rather than creating them itself.
  • Types of DI:
    • Constructor Injection: Dependencies are provided through a class constructor.
    • Setter Injection: Dependencies are provided through setter methods.
    • Field Injection: Dependencies are injected directly into fields.

Benefits of Dependency Injection

  • Decoupling: Reduces the tight coupling between classes.
  • Testability: Makes unit testing easier by allowing mock dependencies.
  • Maintainability: Simplifies the management of dependencies and their lifecycle.

How Dependency Injection Works in Spring Boot

Spring Boot Annotations for DI

  • @Autowired: Marks a constructor, field, or setter method to be autowired by Spring's dependency injection facilities.
  • @Component: Indicates that a class is a Spring-managed component.
  • @Service: A specialized @Component annotation for service layer classes.
  • @Repository: A specialized @Component annotation for data access layer classes.
  • @Controller: A specialized @Component annotation for web controllers.

Example: Constructor Injection

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private Engine engine;

    @Autowired
    public Car(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.run();
    }
}

@Component
public class Engine {
    public void run() {
        System.out.println("Engine is running...");
    }
}

Example: Setter Injection

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    private Engine engine;

    @Autowired
    public void setEngine(Engine engine) {
        this.engine = engine;
    }

    public void start() {
        engine.run();
    }
}

@Component
public class Engine {
    public void run() {
        System.out.println("Engine is running...");
    }
}

Example: Field Injection

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Car {
    @Autowired
    private Engine engine;

    public void start() {
        engine.run();
    }
}

@Component
public class Engine {
    public void run() {
        System.out.println("Engine is running...");
    }
}

Practical Exercises

Exercise 1: Implementing Constructor Injection

Task: Create a Library class that depends on a Book class. Use constructor injection to inject the Book dependency.

Solution:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Library {
    private Book book;

    @Autowired
    public Library(Book book) {
        this.book = book;
    }

    public void displayBook() {
        book.read();
    }
}

@Component
public class Book {
    public void read() {
        System.out.println("Reading a book...");
    }
}

Exercise 2: Implementing Setter Injection

Task: Modify the Library class to use setter injection instead of constructor injection.

Solution:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Library {
    private Book book;

    @Autowired
    public void setBook(Book book) {
        this.book = book;
    }

    public void displayBook() {
        book.read();
    }
}

@Component
public class Book {
    public void read() {
        System.out.println("Reading a book...");
    }
}

Exercise 3: Implementing Field Injection

Task: Modify the Library class to use field injection instead of setter injection.

Solution:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class Library {
    @Autowired
    private Book book;

    public void displayBook() {
        book.read();
    }
}

@Component
public class Book {
    public void read() {
        System.out.println("Reading a book...");
    }
}

Common Mistakes and Tips

Common Mistakes

  • Circular Dependencies: Ensure that your dependencies do not form a circular reference, which can cause runtime errors.
  • Overusing Field Injection: While convenient, field injection can make your code harder to test and less clear. Prefer constructor or setter injection.

Tips

  • Use @RequiredArgsConstructor: If using Lombok, the @RequiredArgsConstructor annotation can simplify constructor injection.
  • Profile-Specific Beans: Use @Profile to create beans that are only available in certain environments.

Conclusion

In this section, we covered the basics of Dependency Injection in Spring Boot, including its benefits, how it works, and practical examples of constructor, setter, and field injection. By understanding and implementing DI, you can create more modular, testable, and maintainable Spring Boot applications. In the next section, we will delve into Spring Boot Configuration to further enhance your application's capabilities.

◄ Previous
◄
Next ►
►

Spring Boot Course

Module 1: Introduction to Spring Boot

Module 2: Spring Boot Basics

Module 3: Building RESTful Web Services

Module 4: Data Access with Spring Boot

Module 5: Spring Boot Security

Module 6: Testing in Spring Boot

Module 7: Advanced Spring Boot Features

Module 8: Deploying Spring Boot Applications

Module 9: Performance and Monitoring

Module 10: Best Practices and Tips

The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved