Creating and Managing Spring Beans

Welcome to this lesson! So far, you have explored the foundational structure of a Spring Boot project. In this lesson, you'll delve into a crucial aspect of Spring Boot — Spring Beans. You'll learn how to create, manage, and utilize Spring Beans. Together, we'll understand dependencies, manual dependency management, Inversion of Control (IoC), and Dependency Injection (DI). We'll explore annotations like @Component and @Bean and see how they simplify dependency management using Spring Context. By the end of this lesson, you'll be equipped to leverage Spring's capabilities for effective bean management.

Before diving into Spring Beans, let's clarify what a dependency is. Imagine you're building an application to prepare a sandwich. You can create a few classes like Bread, Lettuce, Tomato, and Cheese. Obviously, you'll also need a Grill class. Lastly, you'll need a skilled person to put all these ingredients together — the sandwich maker. The sandwich maker requires all the ingredients and a grill to prepare the sandwich, so all these objects are dependencies of the sandwich maker.

Now, let's understand the complication of manually managing object dependencies. Imagine you need to grill a sandwich and you manually create all ingredients and the grill. Here’s a simplified code snippet to demonstrate this:

class Bread {}
class Lettuce {}
class Tomato {}
class Cheese {}
class Sandwich {}
class Grill {}

public class SandwichMaker {
    private Grill grill;

    private Bread bread;
    private Lettuce lettuce;
    private Tomato tomato;
    private Cheese cheese;

    public SandwichMaker(Grill grill, Bread bread, Lettuce lettuce, Tomato tomato, Cheese cheese) {
        this.grill = grill;

        this.bread = bread;
        this.lettuce = lettuce;
        this.tomato = tomato;
        this.cheese = cheese;
    }

    public Sandwich prepareSandwich() {
        System.out.println("Sandwich is ready!");
        return new Sandwich();
    }
    
    public static void main(String[] args) {
        Grill grill = new Grill();

        Bread bread = new Bread();
        Lettuce lettuce = new Lettuce();
        Tomato tomato = new Tomato();
        Cheese cheese = new Cheese();

        SandwichMaker sandwichMaker = new SandwichMaker(grill, bread, lettuce, tomato, cheese);
        sandwichMaker.prepareSandwich();
    }
}

In this example, you manually handle all dependencies. While it looks simple, you need to ensure that you create all objects without dependencies first (bread, lettuce, tomato, and cheese) before constructing the more complex sandwichMaker object that requires these dependencies. Now, imagine you're working on an application for car manufacturing, where you try to assemble a car with thousands of components. As the number of dependencies grows, managing them manually becomes increasingly cumbersome.