Learn the difference between Spring and Spring Boot with practical Java 21 examples, setup guides, REST APIs, benefits, and best practices for beginners.

What is the Difference Between Spring and Spring Boot?

Introduction

Imagine you're building a new house.

With traditional construction, you buy the bricks, cement, wiring, plumbing, and every other component separately. You then assemble everything yourself.

Now imagine purchasing a modern prefabricated house where most things are already configured and ready to use. You can move in much faster.

This analogy perfectly explains the difference between Spring and Spring Boot.

The Spring Framework provides all the tools needed to build enterprise Java applications. However, developers must manually configure many components before getting started.

Spring Boot sits on top of Spring and removes much of this setup work by providing sensible defaults, auto-configuration, and embedded servers.

If you're learning Java programming or planning to build REST APIs, understanding the difference between Spring and Spring Boot is essential because it directly impacts development speed, maintainability, and productivity.

In this article, you'll learn:

• What Spring is


• What Spring Boot is


• Key differences between Spring and Spring Boot


• When to use each


• Complete Java 21 examples


• Best practices for modern application development

Core Concepts

What is Spring?

The Spring Framework is an open-source Java framework used for building enterprise applications.

It provides features such as:

• Dependency Injection (DI)


• Inversion of Control (IoC)


• Aspect-Oriented Programming (AOP)


• Transaction Management


• Security


• Web Development


• Data Access

Spring helps developers write loosely coupled and testable applications.

Typical Spring Workflow

With Spring, developers usually need to:

• Configure beans manually


• Configure web servers


• Manage dependencies


• Create XML or Java-based configurations


• Set up deployment environments

While powerful, this can become time-consuming.

What is Spring Boot?

Spring Boot is an extension of the Spring Framework that simplifies application development.

Spring Boot provides:

• Auto Configuration


• Embedded Tomcat Server


• Starter Dependencies


• Production-ready Features


• Minimal Configuration

The goal of Spring Boot is simple:

Help developers build Spring applications faster with less configuration.

Spring vs Spring Boot: Quick Comparison

Real-World Analogy

Think of Spring as a kitchen filled with ingredients.

You have:

• Vegetables


• Spices


• Utensils


• Cooking equipment

You can cook anything, but you must prepare everything yourself.

Spring Boot is like a meal kit.

The ingredients are pre-packaged and organized.

You still cook the meal, but preparation time is drastically reduced.

When Should You Use Spring?

Choose Spring when:

• You need complete control over configuration.


• You're working with legacy enterprise applications.


• You require highly customized environments.

When Should You Use Spring Boot?

Choose Spring Boot when:

• Building REST APIs.


• Developing microservices.


• Creating cloud-native applications.


• Starting new projects.


• Rapid prototyping.

Most modern Java projects use Spring Boot.

Code Example 1: Traditional Spring Configuration

This example demonstrates how Spring applications typically require manual bean configuration.

Maven Dependency

<dependency>

    <groupId>org.springframework</groupId>

    <artifactId>spring-context</artifactId>

    <version>6.2.0</version>

</dependency>

MessageService.java

package com.example.spring;



public class MessageService {



    public String getMessage() {

        return "Hello from Spring Framework!";

    }

}

AppConfig.java

package com.example.spring;



import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;



@Configuration

public class AppConfig {



    @Bean

    public MessageService messageService() {

        return new MessageService();

    }

}

Main.java

package com.example.spring;



import org.springframework.context.ApplicationContext;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;



public class Main {



    public static void main(String[] args) {



        ApplicationContext context =

                new AnnotationConfigApplicationContext(AppConfig.class);



        MessageService service =

                context.getBean(MessageService.class);



        System.out.println(service.getMessage());

    }

}

Output

Hello from Spring Framework!

Observation

Notice that we had to:

• Create a configuration class


• Define beans manually


• Configure the application context

This is manageable for small projects but becomes cumbersome as applications grow.

Code Example 2: Spring Boot REST API

Let's build the same functionality using Spring Boot.

Project Structure

src/main/java

|

+-- controller

|   +-- MessageController.java

|

+-- SpringBootApplication.java

pom.xml Dependency

<dependency>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-web</artifactId>

</dependency>

SpringBootApplication.java

package com.example.springboot;



import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;



@SpringBootApplication

public class SpringBootDemoApplication {



    public static void main(String[] args) {

        SpringApplication.run(

                SpringBootDemoApplication.class,

                args

        );

    }

}

MessageController.java

package com.example.springboot.controller;



import org.springframework.web.bind.annotation.GetMapping;

import org.springframework.web.bind.annotation.RestController;



@RestController

public class MessageController {



    @GetMapping("/api/message")

    public String getMessage() {

        return "Hello from Spring Boot!";

    }

}

Run Application

mvn spring-boot:run

Spring Boot automatically:

• Starts Tomcat


• Creates application context


• Registers REST endpoints


• Applies auto-configuration

Request

curl -X GET http://localhost:8080/api/message

Response

Hello from Spring Boot!

What Happened Behind the Scenes?

Spring Boot automatically:

1. Started an embedded Tomcat server.


2. Created Spring beans.


3. Configured the web layer.


4. Exposed the REST endpoint.

All without manual configuration.

That's the biggest advantage of Spring Boot.

Spring Boot Features That Save Time

Auto Configuration

Automatically configures components based on dependencies.

Example:

If Spring Boot detects:

spring-boot-starter-web

it automatically configures:

• DispatcherServlet


• Jackson JSON Mapper


• Embedded Tomcat

Starter Dependencies

Instead of adding many libraries manually:

spring-boot-starter-web

provides:

• Spring MVC


• Tomcat


• Jackson


• Validation APIs

and more.

Embedded Server

No need to deploy a WAR file to external servers.

Simply run:

java -jar application.jar

and the application starts immediately.

Production Ready Features

Spring Boot Actuator provides:

• Health Checks


• Metrics


• Monitoring


• Application Info

with minimal configuration.

Benefits of Spring Boot Over Spring

Faster Development

Less configuration means more coding.

Easier Learning Curve

Beginners can focus on business logic.

Better Microservices Support

Widely used in cloud-native architectures.

Simplified Deployment

Embedded servers reduce deployment complexity.

Modern Development Experience

Ideal for APIs, microservices, and distributed systems.

Best Practices

1. Use Spring Boot for New Projects

For modern applications, Spring Boot is almost always the preferred choice.

2. Prefer Starter Dependencies

Use:

spring-boot-starter-web

instead of manually managing multiple dependencies.

3. Avoid Excessive Custom Configuration

Let auto-configuration do its job unless customization is necessary.

4. Keep Controllers Lightweight

Business logic should reside in service classes, not controllers.

Bad:

@GetMapping

public String processOrder() {

    // huge business logic

}

Good:

@GetMapping

public String processOrder() {

    return orderService.process();

}

5. Follow Layered Architecture

Organize code into:

• Controller Layer


• Service Layer


• Repository Layer

This improves maintainability and scalability.

Common Mistakes to Avoid

Using Spring Boot but Disabling Auto Configuration Everywhere

This defeats one of Spring Boot's main benefits.

Putting Business Logic in Controllers

Makes code difficult to maintain.

Ignoring Profiles

Use separate configurations for:

• Development


• Testing


• Production

Overusing Static Utility Classes

Prefer Dependency Injection whenever possible.

Mixing Configuration Styles

Stick to modern annotation-based configuration.

Conclusion

The difference between Spring and Spring Boot comes down to one key idea:

Spring provides the foundation, while Spring Boot simplifies the setup.

Spring offers powerful enterprise development capabilities, but it often requires significant configuration effort.

Spring Boot builds on top of Spring and removes much of this complexity through:

• Auto Configuration


• Starter Dependencies


• Embedded Servers


• Production-Ready Features

For most modern Java programming projects, especially REST APIs and microservices, Spring Boot is the recommended choice.

If you're starting your journey to learn Java and Spring ecosystem technologies, begin with Spring Boot. You'll become productive much faster while still benefiting from all the power of the Spring Framework.

Call to Action

Have you worked with Spring or Spring Boot before?

Which one do you prefer and why?

Share your thoughts, questions, or experiences in the comments below. If you're learning Java programming and Spring Boot, feel free to ask questions—I’d be happy to help!