What Is Spring Boot?

Analogy categoryAnalogies

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.

java

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?

Spring Boot Project Structure

Related Study Notes in Web Development

Browse all study notes

Web Development

WebSockets Study Notes

Web Development · 30 topics

Web Development

WebAssembly Study Notes

WebAssembly · 30 topics

Web Development

gRPC Study Notes

Protocol Buffers · 30 topics

Web Development

Flask Study Notes

Python · 30 topics

Web Development

Django Study Notes

Python · 30 topics

Web Development

Next.js Study Notes

JavaScript · 30 topics

Topics covered

#Java#SpringBootStudyNotes#WebDevelopment#WhatIsSpringBoot#Spring#Boot#Exists#Core#StudyNotes#SkillVeris

What Is Spring Boot?