# How to Use Java Jackson for JSON Serialization and Deserialization in Spring Boot

> Learn to use Java Jackson with Spring Boot for JSON serialization and deserialization. Add the spring-boot-starter-json dependency for automatic configuration and seamless JSON handling.

- Repository: [Spring/spring-boot](https://github.com/spring-projects/spring-boot)
- Tags: how-to-guide
- Published: 2026-02-16

---

**Add the `spring-boot-starter-json` dependency to your build file; it transitively includes `jackson-databind` and automatically configures the `ObjectMapper` bean and HTTP message converters for seamless JSON handling.**

To enable **java jackson for JSON serialization and deserialization** in a Spring Boot application, you only need a single starter dependency. The `spring-projects/spring-boot` repository provides a curated set of Jackson libraries through the `spring-boot-starter-json` module, eliminating the need to manage individual Jackson versions or compatibility manually.

## The Essential Dependency: spring-boot-starter-json

The `spring-boot-starter-json` artifact is the only dependency you need to add for full Jackson support. According to the source code in [`starter/spring-boot-starter-json/build.gradle`](https://github.com/spring-projects/spring-boot/blob/main/starter/spring-boot-starter-json/build.gradle), this starter pulls in the `spring-boot-jackson` module, which acts as the bridge to the actual Jackson libraries.

The `spring-boot-jackson` module, defined in [`module/spring-boot-jackson/build.gradle`](https://github.com/spring-projects/spring-boot/blob/main/module/spring-boot-jackson/build.gradle), declares the core `jackson-databind` library along with optional format modules such as `jackson-dataformat-xml` and `jackson-dataformat-cbor`. This means you get `com.fasterxml.jackson.core:jackson-databind` on your classpath without explicitly declaring it.

## Maven and Gradle Configuration

You can declare the dependency in your build file using the coordinates below. Note that if you already use **`spring-boot-starter-web`** or **`spring-boot-starter-webflux`**, the JSON starter is included automatically, as shown in [`starter/spring-boot-starter-web/build.gradle`](https://github.com/spring-projects/spring-boot/blob/main/starter/spring-boot-starter-web/build.gradle).

### Maven Coordinates

```xml
<!-- Minimal Jackson support -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
</dependency>

<!-- Already covered by spring-boot-starter-web (includes the above) -->
<!--
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
-->

```

### Gradle Configuration

```groovy
// Minimal Jackson support
implementation 'org.springframework.boot:spring-boot-starter-json'

// If you use Spring MVC or WebFlux you already have it via the web starter
// implementation 'org.springframework.boot:spring-boot-starter-web'
// implementation 'org.springframework.boot:spring-boot-starter-webflux'

```

The versions for all Jackson libraries are managed by the Spring Boot dependency management BOM defined in [`platform/spring-boot-dependencies/build.gradle`](https://github.com/spring-projects/spring-boot/blob/main/platform/spring-boot-dependencies/build.gradle), ensuring compatibility across your project.

## How Spring Boot Auto-Configures Jackson

When `spring-boot-starter-json` is present on the classpath, Spring Boot automatically registers two critical components:

1.  **`ObjectMapper` bean**: The core Jackson class for serialization and deserialization is configured as a Spring bean with sensible defaults (e.g., `WRITE_DATES_AS_TIMESTAMPS` disabled).
2.  **`MappingJackson2HttpMessageConverter`**: This HTTP message converter is registered to handle `application/json` content types, automatically converting request bodies to Java objects and responses to JSON.

This auto-configuration happens through the `JacksonAutoConfiguration` class, which is triggered by the presence of the Jackson libraries on the classpath provided by the starter.

## Practical Code Examples

### Basic POJO and REST Controller

The following example demonstrates automatic JSON handling in a Spring Boot application. Create a simple POJO and a REST controller:

```java
// src/main/java/com/example/demo/User.java
package com.example.demo;

public class User {
    private String name;
    private int age;

    // getters & setters
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
}

```

```java
// src/main/java/com/example/demo/UserController.java
package com.example.demo;

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

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

    @PostMapping
    public User echo(@RequestBody User user) {
        // Jackson deserialises JSON → User, then serialises User → JSON
        return user;
    }
}

```

Test the endpoint with `curl`:

```bash
curl -X POST http://localhost:8080/users \
  -H "Content-Type: application/json" \
  -d '{"name":"Alice","age":30}'

```

The response will be `{"name":"Alice","age":30}`, confirming that Jackson is handling both deserialization (request body to `User` object) and serialization (`User` object to response body).

### Direct ObjectMapper Usage

For manual JSON processing outside of HTTP endpoints, inject the pre-configured `ObjectMapper` bean:

```java
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Component;

@Component
public class JsonUtil {
    private final ObjectMapper mapper;

    public JsonUtil(ObjectMapper mapper) {
        this.mapper = mapper;   // Spring injects the configured mapper
    }

    public String toJson(Object obj) throws Exception {
        return mapper.writeValueAsString(obj);
    }

    public <T> T fromJson(String json, Class<T> type) throws Exception {
        return mapper.readValue(json, type);
    }
}

```

Because the `ObjectMapper` is supplied by `spring-boot-starter-json`, it inherits all Spring Boot’s default configurations (such as date formatting and property naming strategies).

## Summary

- **Use `spring-boot-starter-json`** as the single dependency to enable **java jackson for JSON serialization and deserialization** in Spring Boot projects.
- The starter transitively includes `jackson-databind` and optional format modules, with versions managed by the Spring Boot BOM in `platform/spring-boot-dependencies/build.gradle`.
- If you use `spring-boot-starter-web` or `spring-boot-starter-webflux`, the JSON starter is already included and requires no additional declaration.
- Spring Boot auto-configures an `ObjectMapper` bean and registers `MappingJackson2HttpMessageConverter` to handle JSON conversion automatically for REST endpoints.

## Frequently Asked Questions

### Do I need to add Jackson dependencies manually if I use spring-boot-starter-web?

No. The `spring-boot-starter-web` dependency transitively includes `spring-boot-starter-json`, as defined in `starter/spring-boot-starter-web/build.gradle`. This means Jackson is already available on your classpath for JSON serialization and deserialization without any additional configuration.

### What is the difference between spring-boot-starter-json and jackson-databind?

`spring-boot-starter-json` is a Spring Boot-specific starter that aggregates `spring-boot-jackson`, which in turn declares `jackson-databind` (the core Jackson library) along with optional modules for XML and CBOR formats. While you could declare `jackson-databind` directly, using the starter ensures version compatibility with Spring Boot’s dependency management and enables auto-configuration of the `ObjectMapper` bean.

### How do I customize the ObjectMapper configuration in Spring Boot?

You can customize the auto-configured `ObjectMapper` by defining a `Jackson2ObjectMapperBuilderCustomizer` bean or by setting properties in your `application.properties` or [`application.yml`](https://github.com/spring-projects/spring-boot/blob/main/application.yml) file (such as `spring.jackson.date-format` or `spring.jackson.property-naming-strategy`). Alternatively, you can create your own `ObjectMapper` bean marked with `@Primary` to replace the auto-configured instance entirely.

### Where are the Jackson dependency versions defined in the Spring Boot repository?

Jackson library versions are managed centrally in `platform/spring-boot-dependencies/build.gradle`, which imports the Jackson BOM (Bill of Materials). This ensures that all Jackson modules (core, databind, annotations, and dataformat extensions) use compatible versions without requiring you to specify version numbers in your build file.