Embedded Servers in Spring Boot

Spring Boot’s Embedded Servers are one of its most powerful features that make Java web development fast, easy, and modern.

Instead of manually installing and configuring an external web server like Tomcat or Jetty, Spring Boot includes a server inside your application, allowing you to run your project as a standalone Java application.

What Are Embedded Servers?

An embedded server is a server packaged inside your application. It provides all the necessary infrastructure to run web applications without relying on an external server.

Key Points:

• No need to install Tomcat, Jetty, or Undertow manually.
• The server starts automatically when your Spring Boot application runs.
• Handles HTTP requests, servlets, static resources, and REST endpoints.
• Works perfectly with microservices and cloud-native applications.

In short: Your app comes with its own server — plug and play!

How Embedded Servers Work in Spring Boot

Spring Boot automatically detects the web dependencies you add (like spring-boot-starter-web) and starts an embedded server:

1. Dependency Detection → Spring Boot sees spring-boot-starter-web.
2. Server Selection → By default, Tomcat is used. You can switch to Jetty or Undertow.
3. Auto-Configuration → Spring Boot sets up server settings like port, context path, error pages, and servlet handling.
4. Application Start → Run java -jar app.jar → Embedded server starts automatically → Your app is live.

Example:

@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!";
    }
}

Popular Embedded Servers in Spring Boot

1. Tomcat – Default Server

Why Tomcat?

Tomcat is the default embedded server because it’s stable, mature, and widely adopted. Most tutorials and enterprise apps rely on Tomcat.

Key Features:

• Servlet and JSP support
• Thread pooling for handling concurrent requests
• Easy configuration via application.properties (e.g., server port, context path)

Example:

Change the default port in Spring Boot:

server.port=9090

2. Jetty – Lightweight and Fast

Why Jetty?

Jetty is lightweight, making it ideal for microservices, Docker containers, or embedded use cases.

Key Features:

• Small footprint, fast startup
• High concurrency handling
• Supports HTTP/2 and WebSockets
• Switching from Tomcat to Jetty:

Add Jetty starter in pom.xml and exclude Tomcat:

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

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

3. Undertow – High-Performance Server

Why Undertow?

Undertow is designed for high-performance applications with low memory usage. It’s non-blocking and supports reactive programming, making it perfect for modern microservices.

Key Features:

• Lightweight and fast
• Non-blocking I/O for high concurrency
• Low memory usage → better scalability for microservices
• Switching from Tomcat to Undertow:

Add Undertow starter in pom.xml and exclude Tomcat:

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

Key Takeaways for Embedded Servers

Switching Servers:

You can replace Tomcat with Jetty or Undertow by adding the respective starter in pom.xml and excluding Tomcat:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jetty</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Benefits of Embedded Servers

1. Faster Development

   No external server setup. Just add dependency, run, and go.

2. Standalone Applications

   Your Spring Boot app is a single JAR with an embedded server → easy to run anywhere.

3. Cloud & Docker Ready

   Perfect for containerized microservices. Each service can run independently with its own server.

4. Simpler Deployment

   No WAR file, no external server configuration. Deployment is as simple as java -jar app.jar.

5. Production-Ready Defaults

   Embedded servers come with sensible default settings (port 8080, error pages, servlet handling).

Why Embedded Servers Matter

Before Spring Boot, developers had to:

• Install and configure Tomcat manually.
• Deploy WAR files.
• Adjust server settings for each environment.

This process was time-consuming and error-prone.

Spring Boot solves this by embedding the server directly, letting developers focus on writing application logic, not configuration.

Real-World Example

Suppose you want to build a REST API for a ToDo app:

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

@RestController
class TodoController {
    @GetMapping("/todos")
    public List<String> getTodos() {
        return List.of("Learn Spring Boot", "Build REST API", "Deploy App");
    }
}

Conclusion

• Embedded Servers in Spring Boot let your application run standalone without external server configuration.
• Works with Tomcat, Jetty, and Undertow.
• Perfect for microservices, REST APIs, cloud deployment, and Docker.
• Saves time, reduces configuration errors, and makes Spring Boot beginner-friendly.

Note : When creating tutorials or learning Spring Boot, always emphasize embedded servers — it’s one of the key reasons why Spring Boot is faster and easier than traditional Spring Framework.