Spring vs Spring Boot

When learning Java, two names always come up: Spring Framework and Spring Boot. Both are powerful, but they serve different purposes. Here’s a simple and easy-to-understand comparison.

First, the Basics

Spring Framework (Spring)

A powerful and flexible Java framework used to build all types of applications — web, enterprise, cloud, batch processing, etc.

It provides:

Dependency Injection
Aspect-Oriented Programming
Spring MVC
Spring Security
Spring Data
Transaction management

But it requires manual configuration (XML or Java config), which increases setup time.

Spring Boot

A modern framework built on top of Spring to make development faster and easier.

It provides:

Auto-configuration
Starter dependencies
Embedded servers
Production-ready tools (Actuator)

Spring Boot removes boilerplate and handles setup automatically.

Spring = Buying raw ingredients and cooking everything yourself.

You control everything, but it takes time and effort.

Spring Boot = A ready-made meal kit.

Ingredients are pre-measured, partially prepared, and ready in minutes.

Key Differences

Feature / Aspect	Spring Framework	Spring Boot
Configuration	Requires manual configuration using XML or Java-based config	Auto-configuration with smart defaults; minimal manual setup
Setup Time	Long setup (server config, beans, XML, dependencies)	Very fast setup (starters + embedded server)
Dependency Management	Add and manage each dependency manually	Starter dependencies bundle all required libraries
Server Requirement	Needs external server (Tomcat, Jetty, WebLogic)	Comes with embedded servers (Tomcat, Jetty, Undertow)
Deployment Type	Mostly WAR deployment	Standalone JAR: `java -jar app.jar`
Project Structure	More complex; multiple config files	Simple and consistent structure
Production Features	Configure everything manually	Built-in Actuator (health, metrics, monitoring)
Learning Curve	Steep; requires understanding of multiple configs	Easier due to opinionated defaults
Flexibility	Highly flexible; developer controls everything	Convention-over-configuration; less boilerplate
Bootstrapping	Needs XML/Java config + context initialization	Needs only `@SpringBootApplication`
Performance Tuning	Manual tuning required	Auto-tuned defaults for many components
Use Cases	Enterprise-level apps needing fine control	Microservices, REST APIs, cloud-native apps
Project Size	Suitable for large monolithic systems	Ideal for small to medium microservices
Community Learning Resources	Large, but configuration-heavy	Easier, more beginner-friendly
Build Tools	Works with Maven/Gradle (manual setup)	Maven/Gradle plugins auto-configure builds
Embedded Tools	No built-in tooling	DevTools, Actuator, embedded servers

Example — Building a Simple REST API

(A) Using Spring Framework (Old Way)

Steps:

Configure DispatcherServlet in web.xml
Create XML config for beans
Set up external server (Tomcat)
Create Controller
Deploy WAR

`web.xml`

<web-app>
  <servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>
</web-app>

Controller

@Controller
public class HelloController {
    @RequestMapping("/hello")
    @ResponseBody
    public String sayHello() {
        return "Hello from Spring!";
    }
}

Requires external Tomcat + WAR deployment.

(B) Using Spring Boot (Modern Way)

Steps:

Add spring-boot-starter-web
Write controller
Run the app (embedded server)

Application

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

Controller

@RestController
public class HelloController {
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello from Spring Boot!";
    }
}

Run → Open http://localhost:8080/hello

No XML. No external server. No WAR.

When to Use What?

Use Spring (Framework) when:

You need full control over configuration
You’re working on legacy enterprise systems
You still deploy WAR files
You want modularity over convenience

Use Spring Boot when:

You build REST APIs, microservices
You want rapid development
You deploy to Docker/Kubernetes
You need production-ready features quickly

Conclusion

Spring = Powerful foundation (but configuration-heavy)
Spring Boot = Productivity booster (auto-config, embedded server, ready-to-run)

Spring is the engine.

Spring Boot is the entire car built around that engine.

Differences - Spring vs Spring Boot