Devops Monk

You want to build a Java web application or REST API. You’ve heard everyone uses Spring Boot. But what is it exactly, and why does it exist?

This article answers that — clearly — before writing a single line of code.

What Is Spring Boot?

Spring Boot is an opinionated framework for building Spring-based Java applications with minimal configuration.

Break that down:

• Spring-based — it sits on top of the Spring Framework, which has been the dominant Java application framework since 2003
• Minimal configuration — you describe what you want (a web app, a database connection), and Spring Boot figures out how to set it up
• Opinionated — it makes sensible default choices so you don’t have to make every decision yourself

The one-line version: Spring Boot lets you go from a blank project to a running application in minutes, with production-ready defaults built in.

The Problem It Solves

Before Spring Boot (pre-2014), building a Spring web application required:

1. Manually managing dozens of dependencies — you needed Spring MVC, Spring Core, Spring Context, Hibernate, a connection pool, a logging framework, a servlet container — and you had to find compatible versions yourself
2. Writing hundreds of lines of XML configuration — beans, data sources, transaction managers, view resolvers, all wired together in XML files
3. Deploying a WAR file to an external server — Tomcat had to be installed separately; the app was deployed into it

A typical Spring project from 2012 would have a applicationContext.xml that looked like this:

<!-- 200+ lines of this -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="secret"/>
</bean>

<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
    <property name="dataSource" ref="dataSource"/>
    <property name="packagesToScan" value="com.example.entities"/>
    <!-- ... 20 more properties -->
</bean>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
    <property name="entityManagerFactory" ref="entityManagerFactory"/>
</bean>

This was the norm. Teams spent days on infrastructure configuration before writing any business code.

Spring Boot was created in 2014 to eliminate this. Phil Webb and Dave Syer at Pivotal (now VMware/Broadcom) saw that 80% of Spring apps were configured the same way, and decided to codify those patterns into sensible defaults.

Spring Framework vs. Spring Boot

This distinction trips up beginners. They are not the same thing.

Spring Framework
└── Spring Boot  (builds on top of Spring Framework)

Spring Boot doesn’t replace Spring Framework — it packages and configures it for you. Everything Spring Framework provides (dependency injection, Spring MVC, Spring Data, Spring Security) is still there. Spring Boot just removes the setup ceremony.

How Spring Boot Works (The Three Key Ideas)

1. Starter Dependencies

Instead of manually listing 10 compatible dependencies for a web app, you add one starter:

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

This single starter pulls in Spring MVC, embedded Tomcat, Jackson (JSON), validation, and logging — all at compatible versions. The full list of starters covers every common use case: web, data JPA, security, Redis, Kafka, and more.

2. Auto-Configuration

When Spring Boot starts, it scans the classpath and automatically configures beans based on what it finds. If spring-boot-starter-web is present, it auto-configures an embedded Tomcat server, a Spring MVC DispatcherServlet, and Jackson for JSON serialization — without you writing any configuration code.

You can always override any auto-configuration by defining your own beans. Auto-configuration is intentionally non-invasive: if you define a DataSource bean yourself, Spring Boot backs off and uses yours.

This is covered in depth in Part 4: How Auto-Configuration Works.

3. Embedded Server

Spring Boot applications package an embedded Tomcat (or Jetty) server inside the JAR. You run the application with:

java -jar myapp.jar

That’s it. No separate server installation. No WAR deployment. The server is part of the application.

Traditional Spring (WAR)          Spring Boot (JAR)
─────────────────────────         ──────────────────────────
Tomcat server (installed)         myapp.jar
└── webapps/                      └── embedded Tomcat
    └── myapp.war                 └── your application code
        └── your code             └── all dependencies

This change had a large impact on how Java apps are deployed — especially in containers. A Docker container running a Spring Boot JAR is a self-contained unit. No server installation step needed.

The Spring Ecosystem

Spring Boot sits within a large ecosystem. You’ll encounter these as you build more complex applications:

Spring Framework (core)
├── Spring MVC          — HTTP request handling, REST APIs
├── Spring Data         — Simplified database access (JPA, MongoDB, Redis, ...)
├── Spring Security     — Authentication and authorization
├── Spring Batch        — Batch processing
└── Spring Integration  — Enterprise integration patterns

Spring Boot (auto-configuration layer)
├── spring-boot-starter-web        — Spring MVC + embedded Tomcat
├── spring-boot-starter-data-jpa   — Spring Data JPA + Hibernate
├── spring-boot-starter-security   — Spring Security
└── ...50+ more starters

Spring Cloud (distributed systems)
├── Spring Cloud Gateway    — API gateway
├── Spring Cloud Config     — Centralized configuration
├── Spring Cloud Netflix    — Service discovery (Eureka)
└── ...

Spring AI                          — LLM / AI integration (new in 2025)

For this tutorial series, you’ll use Spring Boot throughout, and progressively add Spring Data, Spring Security, and Spring Cloud as the complexity increases.

Spring Boot 4.0 (What We Use in This Series)

This tutorial series uses Spring Boot 4.0, released November 20, 2025. It’s the biggest Spring release in a decade.

Key changes relevant to this series:

Don’t worry about these details yet — they’ll be covered when relevant. The important thing: every code example in this series works with Spring Boot 4.0.

What You’ll Build in This Series

Throughout the tutorials, we’ll build an Order Service — a REST API for managing orders in an e-commerce system. It starts simple and grows in complexity:

• Part 1–7: A working Spring Boot app with basic configuration
• Part 8–14: A full REST API with validation and error handling
• Part 15–22: JPA data persistence with PostgreSQL
• Part 23–28: Spring Security with JWT authentication
• Part 29–33: A fully tested codebase
• Part 34+: Production features, performance, microservices

Every article builds on the previous one. By the end, you’ll have a production-grade Spring Boot application.

Prerequisites

This series assumes you know:

• Java basics — OOP, classes, interfaces, generics, exceptions
• Java 8+ features — lambdas, streams, Optional
• Maven basics — what a pom.xml is, how dependencies work
• HTTP basics — GET/POST/PUT/DELETE, status codes, JSON

You do not need to know:

• Spring Framework (we start from scratch)
• Hibernate or JPA
• Docker or Kubernetes (covered later)

Quick Summary

• Spring Boot is an opinionated layer on top of Spring Framework that provides auto-configuration, starter dependencies, and embedded servers
• It exists to eliminate the configuration ceremony that made Spring apps slow to start
• It doesn’t replace Spring Framework — it packages and configures it for you
• This series uses Spring Boot 4.0 with JDK 21+

Next: Your First Spring Boot Application →