Core Architecture

From Java Objects to Spring Beans

In standard Java, you control the lifecycle of your objects. You decide when to create an object using the new keyword and what dependencies to pass to its constructor. This direct control works, but it can lead to tightly coupled code where components are difficult to test or replace.

Spring introduces a different approach called (IoC). With IoC, you delegate the responsibility of creating and managing objects to the Spring container. Instead of your code calling the framework, the framework calls your code. The objects managed by this container are called "Spring Beans."

This shift is fundamental. You no longer write new MyService(). Instead, you declare that your class needs an instance of MyService, and Spring provides it. This process is known as Dependency Injection (DI), the primary way to implement IoC. You define the dependencies, and Spring injects them when it creates the bean.

The Magic of Auto-Configuration

One of Spring Boot's most powerful features is its ability to automatically configure your application based on the dependencies you've added. This eliminates the mountain of XML or Java-based configuration that was common in older Spring applications.

This magic starts with Starter POMs. These are convenient dependency descriptors that you can include in your project. For example, if you want to build a web application, you don't need to manually hunt down all the necessary libraries for handling HTTP requests, JSON conversion, and running a server. You just add one dependency.

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

When Spring Boot sees spring-boot-starter-web on the classpath, it knows you intend to build a web application. This starter transitively pulls in other libraries like spring-webmvc and an embedded server like Tomcat. Spring Boot's auto-configuration logic then kicks in. It makes educated guesses and configures the necessary beans for a web application, such as a DispatcherServlet to handle incoming requests and message converters to handle JSON.

If you were to add spring-boot-starter-data-jpa, Spring Boot would notice a JPA implementation like Hibernate on the classpath and automatically configure a DataSource and an EntityManagerFactory for you, assuming you've provided database connection details.

Your Application's Front Door

Every Spring Boot application begins with a main class annotated with @SpringBootApplication. This single annotation is not just a marker; it's a powerful combination of three other annotations that drive the entire auto-configuration process.

Here's the breakdown:

@EnableAutoConfiguration: This is the annotation that enables Spring Boot's auto-configuration mechanism, which we just discussed.
: This tells Spring to look for other components, configurations, and services in the package where the main application class resides, and all of its sub-packages. Any class you annotate with @Component, @Service, @Repository, or @Controller will be detected and registered as a Spring Bean.
@Configuration: This allows you to register extra beans in the container or customize existing ones by using @Bean-annotated methods. It marks the class as a source of bean definitions.

Injecting Dependencies

Once Spring identifies all the beans, it needs to wire them together. If a WebController needs a ProductService to function, Spring must inject an instance of ProductService into WebController. There are two primary ways to do this: setter injection and constructor injection.

Setter Injection uses a setter method to provide the dependency. It looks like this:

@Component
public class ProductController {

    private ProductService productService;

    @Autowired
    public void setProductService(ProductService productService) {
        this.productService = productService;
    }
}

This method is flexible, as it allows for optional dependencies and can avoid circular dependency issues. However, it can leave your objects in an incomplete state and makes the class harder to test.

Constructor Injection provides dependencies through the class constructor. This is the modern, recommended approach.

@Component
public class ProductController {

    private final ProductService productService; // Declared as final

    // @Autowired is optional on constructors since Spring 4.3
    public ProductController(ProductService productService) {
        this.productService = productService;
    }
}

Constructor injection is preferred for several key reasons. It ensures that an object is created in a complete and valid state with all its mandatory dependencies. By declaring the dependency fields as final, you guarantee they are immutable once assigned, which is safer in multi-threaded environments. This design also leads to cleaner, more testable code, as you can easily instantiate the class with mock dependencies in your unit tests without needing a Spring context.

Quiz Questions 1/4

What is the core principle of Inversion of Control (IoC) as implemented by the Spring container?

Quiz Questions 2/4

If you add the spring-boot-starter-data-jpa dependency to your project, what does Spring Boot's auto-configuration typically do?

Spring Boot Application Development