Spring, IoC, and Why Boot Exists

The Spring portfolio

Inversion of control explained

In a traditional BookStore app you might write:

public class BookController {
    private final BookService bookService = new BookService(
        new JdbcBookRepository(new DataSource(...))
    );
}

Every class constructs its own dependencies. Changing the repository implementation means editing every caller.

Spring inverts this: the container creates objects and injects dependencies. You declare what you need; Spring figures out how to provide it.

@RestController
public class BookController {
    private final BookService bookService;

    public BookController(BookService bookService) {
        this.bookService = bookService;  // injected by Spring
    }
}

The controller never calls new BookService(). The container does at startup.

ApplicationContext: the heart of Spring

The ApplicationContext is a registry of beans — objects Spring manages. At startup it:

For BookStore, a single context holds one BookService, one BookRepository, and one DataSource — shared across all requests.

Why Boot exists

Plain Spring required extensive XML or Java configuration:

@Configuration
public class WebConfig {
    @Bean
    public DispatcherServlet dispatcherServlet() { ... }
    @Bean
    public DataSource dataSource() { ... }
    // dozens more beans
}

Boot's auto-configuration detects classpath contents and configures beans conditionally. Add spring-boot-starter-data-jpa and a DataSource appears when application.yml has a spring.datasource.url.

Spring vs Spring Boot responsibilities

The starter pattern preview

Instead of listing twenty JAR coordinates, Boot offers curated bundles:

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

One dependency brings Tomcat, Jackson, Spring MVC, and validation. The starters module covers this in depth.

Jakarta EE namespace shift

Spring Boot 3.x runs on Jakarta EE 9+ packages (jakarta.servlet, jakarta.persistence). Code using javax.* imports from older tutorials will not compile. When reading Stack Overflow answers, check the Spring Boot version.

Ecosystem versioning

Spring Boot 3.4.x aligns with Spring Framework 6.x and requires Java 17+. The Spring release train publishes compatible versions together. Stick to the BOM — mixing manual version overrides causes subtle runtime failures.

Where BookStore fits

Your learning path builds the BookStore API layer by layer: web foundations → IoC wiring → Boot auto-config → REST endpoints → JPA persistence → cross-cutting concerns → security. Each module adds one Spring project to the same application.

@SpringBootApplication
public class BookStoreApplication {
    public static void main(String[] args) {
        SpringApplication.run(BookStoreApplication.class, args);
    }
}

That single annotation bootstraps the entire ecosystem for your app.