DEV Community: Abhishek Shahi

Boolean Field Becomes null in Spring Boot DTO? Here’s Why (And How to Fix It)

Abhishek Shahi — Fri, 02 Jan 2026 19:57:06 +0000

If you’re building REST APIs using Spring Boot, you may encounter a strange and frustrating issue:
❓ The request JSON clearly sends a boolean value (true / false),
but inside the DTO, the value becomes null.

No exception.
No warning.
No stack trace.

This is not a bug in Spring Boot — it’s a Jackson + Java Bean naming trap that frequently appears in real-world applications.

In this article, you’ll learn:

- Why boolean values become null in Spring Boot DTOs
- How Jackson maps JSON properties to Java fields
- Why @JsonProperty fixes the issue
- The recommended best practice to avoid this forever

The Problem: Boolean Value Is null in DTO

Consider this request payload sent from the frontend:

{
  "isActive": true
}

Now look at the DTO:

public class UserRequest {

    private Boolean isActive;

    public Boolean getIsActive() {
        return isActive;
    }

    public void setIsActive(Boolean isActive) {
        this.isActive = isActive;
    }
}

Controller code:

@PostMapping("/user")
public void createUser(@RequestBody UserRequest request) {
    System.out.println(request.getIsActive());
}

Actual Output

null

❌ JSON is correct
❌ Mapping fails silently
❌ Debugging becomes painful

Why This Happens (Jackson + Java Bean Rules)
Spring Boot uses Jackson to convert JSON into Java objects.

Jackson does not rely only on field names — it follows Java Bean naming conventions, which depend heavily on getter and setter names.

How Jackson Interprets Boolean Fields
For this field:

private Boolean isActive;

Jackson expects one of these method patterns:

public Boolean isActive()

public Boolean getActive()

But what we actually wrote:

public Boolean getIsActive()

The Mismatch

JSON property: isActive
Java property Jackson infers: active
Because of this mismatch, Jackson fails to bind the value — resulting in null.

Solution 1: Use @JsonProperty (Quick Fix)

You can explicitly tell Jackson how to map the JSON property.

Fixed DTO Using @JsonProperty

import com.fasterxml.jackson.annotation.JsonProperty;

public class UserRequest {

    @JsonProperty("isActive")
    private Boolean isActive;

    public Boolean getIsActive() {
        return isActive;
    }

    public void setIsActive(Boolean isActive) {
        this.isActive = isActive;
    }
}

Result

✔ JSON maps correctly
✔ DTO receives true / false
✔ No more null

Solution 2: Best Practice (Highly Recommended)

Instead of fixing the mapping, fix the design.

Avoid starting boolean field names with is.
Preferred DTO Design

public class UserRequest {

    private Boolean active;

    public Boolean getActive() {
        return active;
    }

    public void setActive(Boolean active) {
        this.active = active;
    }
}

Why This Is Better

Fully Java Bean compliant

No Jackson annotations required
Cleaner, more readable DTOs
Fewer bugs in large codebases

boolean vs Boolean in Spring Boot DTOs

Type	Default Value	Nullable
boolean	false	No
Boolean	null	Yes

When to Use What

Use boolean when the field is mandatory
Use Boolean when the field is optional or tri-state

Common Interview Question

Q: Why does Spring Boot map boolean JSON values to null?
Answer:
Because Jackson follows Java Bean naming conventions. Boolean fields prefixed with is can cause property name mismatches unless getters, setters, or @JsonProperty are defined correctly.

Key Takeaways

Boolean fields starting with is can silently break Jackson mapping
Jackson relies on getter/setter naming, not field names
@JsonProperty fixes the issue explicitly
Best practice: avoid is prefix in DTO fields
Always check DTO design before debugging controllers

Final Advice

If your JSON looks correct but your DTO value is null:
👉 Check the getter and setter naming first.
This small detail can save hours of debugging in Spring Boot applications.

How Does a Web Server Work in Spring Boot? (Request–Response Flow Explained)

Abhishek Shahi — Sun, 28 Dec 2025 21:20:44 +0000

A Complete Request–Response Flow Explained

When we build REST APIs using Spring Boot, we often focus on writing controllers and services. But have you ever wondered what actually happens when a client hits an API endpoint like /api/users?

Behind the scenes, Spring Boot performs a series of well-orchestrated steps to handle the HTTP request and send back a response.
In this blog, we’ll explore how a web server works in Spring Boot, starting from application startup to the final response returned to the client.

What Is a Web Server in Spring Boot?

A web server is responsible for:

Listening for incoming HTTP requests
Forwarding them to the application
Sending responses back to the client

Spring Boot simplifies this by providing an embedded web server, meaning you don’t need to install or configure an external server separately.

Common Embedded Servers in Spring Boot

Tomcat (default)
Jetty
Undertow

When you run a Spring Boot application, it automatically starts an embedded web server (usually Tomcat) on port 8080.

What Happens When You Start a Spring Boot Web Application?

Before any HTTP request is handled, Spring Boot prepares the application environment.

Here’s what happens internally:

JVM starts and executes the main() method
SpringApplication.run() is invoked
Spring creates the ApplicationContext
Beans are initialized and dependency injection occurs
Embedded web server (Tomcat) is created and started
Server starts listening on a port (default: 8080)

At this point, your application is ready to receive HTTP requests.

High-Level Request–Response Flow

Let’s look at the overall picture before diving into details:

- Client sends an HTTP request
- Embedded server receives the request
- Spring MVC processes the request
- Controller executes business logic
- Response is returned to the client

Now, let’s break this down step by step.

Step-by-Step: How Spring Boot Handles an HTTP Request

Step 1: Client Sends an HTTP Request

A client (browser, Postman, frontend app) sends a request like:

GET /api/users

This request contains:

HTTP method (GET, POST, etc.)
URL
Headers
Request body (if applicable)

Step 2: Embedded Server Receives the Request

The embedded Tomcat server listens on port 8080
It receives the HTTP request
The request is forwarded to the Spring framework The server itself does not know about your controllers. It simply passes the request to Spring.

Step 3: DispatcherServlet – The Front Controller

Every Spring MVC application has a central component called DispatcherServlet.

It acts as the front controller
All incoming HTTP requests pass through it
It controls the entire request flow

Responsibilities of DispatcherServlet:

Identify the correct controller
Delegate request handling
Manage response generation

This follows the Front Controller Design Pattern.

Step 4: Handler Mapping Finds the Controller

Spring uses **HandlerMapping **to map URLs to controller methods.

Example controller:

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping("/users")
    public List<User> getUsers() {
        return userService.getAllUsers();
    }
}

Spring maps:

/api/users  →  getUsers()

Step 5: Controller, Service, and Repository Layers

Once the controller is identified:

Controller handles HTTP-specific logic
Service contains business logic
Repository interacts with the database

This layered architecture ensures:

Separation of concerns
Better maintainability
Easier testing

Step 6: Response Conversion

After execution, the controller returns:

A Java object
A String
Or a ResponseEntity

Spring then:

Uses HttpMessageConverters
Converts Java objects into JSON (using Jackson)

Example response:

[
  {
    "id": 1,
    "name": "Abhishek"
  }
]

Step 7: Response Is Sent Back to the Client

DispatcherServlet sends the response back to Tomcat
Tomcat sends the HTTP response to the client
The request–response cycle completes

Why DispatcherServlet Is So Important

The **DispatcherServlet **is the backbone of Spring MVC because it:

Centralizes request handling
Enables loose coupling
Makes applications extensible using filters and interceptors

Interview-ready statement:

DispatcherServlet acts as the traffic controller of a Spring Boot web application.

Summary

Spring Boot starts an embedded web server automatically
All HTTP requests are handled through DispatcherServlet
HandlerMapping identifies the correct controller
Business logic executes in service layers
Responses are converted and returned to the client

Conclusion

Understanding how a web server works in Spring Boot gives you deeper insight into:

Debugging production issues
Designing scalable APIs
Answering Spring MVC interview questions confidently

Once you understand this flow, Spring Boot stops feeling like magic—and starts making complete sense.

Spring Boot Application Startup Flow: What Happens Behind the Scene

Abhishek Shahi — Thu, 25 Dec 2025 10:56:14 +0000

When you run a Spring Boot application, a lot of things happen automatically behind the scenes.
From JVM startup to bean creation, auto-configuration, and embedded server initialization, Spring Boot handles everything for you.

Spring Boot Application Startup Flow

In this blog, I’ll explain the complete startup flow of a Spring Boot application, step by step, in a way that finally made sense to me.

1. JVM Starts and Calls the main() Method

Every Spring Boot application starts like any normal Java application.

The JVM starts
It loads the class that contains the main() method
The main() method is executed

example

@SpringBootApplication
public class MyAppApplication {

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

At this point, Spring Boot has not started yet.
We are still in plain Java.

2. SpringApplication.run() Is the Real Entry Point

The real Spring Boot journey begins when:

SpringApplication.run(MyAppApplication.class, args);

is called.

Internally, this method does a lot of work, but conceptually it does three important things:

Creates a SpringApplication object
Prepares the application environment
Creates and refreshes the ApplicationContext

3. SpringApplication Object Is Created

Spring Boot first creates a SpringApplication object.

This object is responsible for:

Determining whether the app is web or non-web
Loading ApplicationContextInitializers
Registering ApplicationListeners
Preparing the Environment (properties, profiles)

Think of it as the bootstrapping brain of Spring Boot.

4. Environment Is Prepared

Before any beans are created, Spring Boot prepares the Environment.

This includes:

application.properties / application.yml
Active profiles (dev, prod, etc.)
JVM arguments
OS environment variables

This step is important because many configurations depend on environment values.

5. ApplicationContext Is Created

Next, Spring Boot creates the ApplicationContext, which is the core container of Spring.

Depending on the application type:

Web app → AnnotationConfigServletWebServerApplicationContext
Non-web app → AnnotationConfigApplicationContext

The ApplicationContext:

Manages beans
Handles dependency injection
Controls the application lifecycle

6. Component Scanning Begins

Now Spring starts component scanning.

It scans packages starting from the class annotated with:

@SpringBootApplication

During scanning, Spring detects:

@Component
@Service
@Repository
@Controller
@RestController

These classes are registered as beans inside the ApplicationContext.

7. Bean Creation and Dependency Injection

Once components are detected:

Beans are created
Dependencies are injected using: Constructor injection Field injection Setter injection

This is where Inversion of Control (IoC) actually happens.

Spring now manages the lifecycle of your objects.

8. Auto-Configuration in Spring Boot

This is the most powerful feature of Spring Boot.

Spring Boot checks:

What dependencies are present on the classpath
What properties are configured
What conditions are satisfied

Based on this, it automatically configures beans.

Examples:

If Spring Web is present → configure DispatcherServlet
If JPA is present → configure EntityManager
If Tomcat is present → configure embedded server All of this happens using conditional annotations.

9. Embedded Server Starts

For web applications:
An embedded server (Tomcat/Jetty/Netty) is started
Server is bound to the configured port (default: 8080)
DispatcherServlet is initialized
Now your application is ready to handle HTTP requests.

10. Application Is Ready🚀

At this point:

All beans are initialized
Auto-configuration is complete
Server is running

Spring Boot publishes an ApplicationReadyEvent, signaling that the app has fully started.

Spring Boot Startup Flow Summary

JVM starts and runs main() method
SpringApplication.run() bootstraps the app
Environment and profiles are prepared
ApplicationContext is created
Components are scanned and beans are created
Auto-configuration configures required beans
Embedded server starts
Application becomes ready to serve requests

Why Understanding This Matters

Understanding the startup flow helps you:
Debug startup errors
Answer interview questions confidently
Customize Spring Boot behavior
Stop treating Spring Boot as a black box This explanation helped me finally understand what Spring Boot is actually doing for us instead of just memorizing annotations.

If you’re also learning Spring Boot, I hope this clears things up for you 🙂