What Is Spring Boot?
Spring Boot is an opinionated layer built on top of the core Spring Framework that lets you create standalone, production-ready applications with minimal setup. Instead of wiring dependencies and configuration by hand, you annotate a single class with @SpringBootApplication and Spring Boot auto-configures sensible defaults, embeds a web server, and gives you a runnable application from public static void main.
Cricket analogy: Like a franchise handing an IPL debutant a pre-set batting order and fielding plan instead of making them decide from scratch, Spring Boot hands you working defaults so you can start playing straight away.
Why Spring Boot Exists
Before Spring Boot, building a Spring application meant hand-writing XML files like web.xml and applicationContext.xml, manually registering a DispatcherServlet, and packaging a WAR file to deploy into an external servlet container such as Tomcat. Spring Boot removes this ceremony through convention-over-configuration and auto-configuration, and it embeds the server inside the JAR so you run the app with a single java -jar app.jar command.
Cricket analogy: It's like the shift from teams carrying their own stumps, boundary ropes, and scoreboard to grounds that come fully equipped — Spring Boot removes the equivalent of assembling your own pitch (web.xml) before every match.
Core Features
Spring Boot's headline features are standalone executable JARs with embedded Tomcat, Jetty, or Undertow; starter dependencies that pull in coherent sets of libraries with compatible versions; auto-configuration that inspects the classpath and configures beans accordingly; externalized configuration through application.properties or application.yml with profile support (dev, test, prod); and Spring Boot Actuator, which exposes production-readiness endpoints like /actuator/health and /actuator/metrics.
Cricket analogy: Like a modern stadium's Hawk-Eye, Snickometer, and Decision Review System bundled together to give umpires everything they need, Actuator bundles health, metrics, and info endpoints so operators get everything at once.
Spring Boot vs Traditional Spring
Traditional Spring required you to manually declare a DispatcherServlet, define bean wiring in XML or verbose Java configuration classes, and choose an external servlet container for deployment. Spring Boot's @SpringBootApplication annotation is itself a composition of three annotations — @SpringBootConfiguration (a specialized @Configuration), @EnableAutoConfiguration, and @ComponentScan — collapsing what used to be dozens of lines of setup into one annotated class.
Cricket analogy: It's like comparing a team that must manually mark the pitch, set the boundary, and check the ball before every match to a franchise where the ground staff has already done it — @SpringBootApplication is that ground staff bundled into one annotation.
package com.example.demo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
@RestController
class HelloController {
@GetMapping("/hello")
public String hello() {
return "Hello from Spring Boot!";
}
}Spring Boot is not a replacement for the Spring Framework — it is a layer built on top of it. Every Spring Boot application is still a full Spring application underneath; you still use @Autowired, @Service, @Repository, and the ApplicationContext. Spring Boot just removes the manual assembly required to get that context running.
- Spring Boot is an opinionated, auto-configuring layer on top of the core Spring Framework, not a separate framework.
- @SpringBootApplication combines @SpringBootConfiguration, @EnableAutoConfiguration, and @ComponentScan into one annotation.
- Applications are packaged as standalone executable JARs with an embedded server (Tomcat, Jetty, or Undertow) rather than deployed as WARs to an external container.
- Auto-configuration inspects the classpath and configures beans automatically based on what dependencies are present.
- Spring Boot Actuator exposes production-readiness endpoints such as /actuator/health and /actuator/metrics.
- Externalized configuration via application.properties or application.yml, with profile support, lets the same JAR run differently across dev, test, and prod.
- Spring Boot dramatically reduces the XML and boilerplate configuration that traditional Spring applications required.
Practice what you learned
1. What does the @SpringBootApplication annotation combine?
2. How does a typical Spring Boot application run in production?
3. Which statement about Spring Boot's relationship to the Spring Framework is correct?
4. What does Spring Boot Actuator provide?
5. Before Spring Boot, how was a typical Spring web application configured?
Was this page helpful?
You May Also Like
Spring Boot Project Structure
How a typical Spring Boot project is organized on disk, from Maven/Gradle build files to source packages and resources.
Spring Boot Starters
How starter dependencies bundle coherent, version-compatible sets of libraries so you can add capabilities like web or data access with one line.
Spring Boot Auto-Configuration
How Spring Boot inspects the classpath and existing beans to automatically configure sensible defaults, and how to customize or override them.
Related Reading
Related Study Notes in Web Development
Browse all study notesWebSockets Study Notes
Web Development · 30 topics
Web DevelopmentWebAssembly Study Notes
WebAssembly · 30 topics
Web DevelopmentgRPC Study Notes
Protocol Buffers · 30 topics
Web DevelopmentFlask Study Notes
Python · 30 topics
Web DevelopmentDjango Study Notes
Python · 30 topics
Web DevelopmentNext.js Study Notes
JavaScript · 30 topics