JSON using Jackson in REST API Implementation with Spring Boot

Last Updated : 05 Sep, 2025

When building REST APIs in Spring Boot, JSON is the most common format used for data exchange between client and server. By default, Spring Boot uses Jackson (a popular JSON library for Java) to convert Java objects to JSON and vice versa. This process is called serialization and deserialization

Serialization means converting a Java object into JSON so it can be sent to the client.
Deserialization means converting JSON back into a Java object so the server can understand it.

What is Jackson

Jackson is a Java library that helps Java applications automatically convert data between Java objects and JSON. Spring Boot automatically configures Jackson as the default JSON processor via spring-boot-starter-web.

When sending data to the client, it changes Java objects into JSON with the help of the ObjectMapper class.
When receiving data from the client, it changes JSON into Java objects.

Common Jackson Annotations

Jackson provides several annotations for customizing JSON output:

Annotation	Description
@JsonProperty	Rename a field in JSON
@JsonIgnore	Ignore a field during serialization/deserialization
@JsonInclude	Include/exclude fields based on conditions
@JsonFormat	Define format for date/time fields
@JsonIgnoreProperties	Ignore multiple fields

Example: REST API with JSON using Jackson

Step 1: Create a Spring Boot Project

Use Spring Initializr or your IDE to create a Maven Spring Boot project with:

Project: Maven
Language: Java
Spring Boot: (choose a recent stable 3.x)
Dependencies: Spring Web

Project Structure:

Step 2. Create model class (Jackson annotations demo)

Now, let’s create a User model class and use Jackson annotations to customize JSON output (ignore fields, rename properties, format dates, etc.).

User.java

Java

package com.example.demo.model;

import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.annotation.JsonInclude;

import java.time.LocalDate;

@JsonInclude(JsonInclude.Include.NON_NULL)
public class User {

    private Integer id;

    @JsonProperty("full_name")
    private String name;

    @JsonIgnore
    private String password;

    @JsonFormat(pattern = "yyyy-MM-dd")
    private LocalDate dob;

    private String email;

    public User() {}

    public User(Integer id, String name, String password, LocalDate dob, String email) {
        this.id = id;
        this.name = name;
        this.password = password;
        this.dob = dob;
        this.email = email;
    }

    public Integer getId() { return id; }
    public void setId(Integer id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String getPassword() { return password; }
    public void setPassword(String password) { this.password = password; }

    public LocalDate getDob() { return dob; }
    public void setDob(LocalDate dob) { this.dob = dob; }

    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
}

Step 3. Create Controller

Create a REST controller that exposes API endpoints for CRUD operations on User.

UserController.java:

Java

package com.example.demo.controller;

import com.example.demo.model.User;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.time.LocalDate;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.atomic.AtomicInteger;

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

    private final List<User> users = new CopyOnWriteArrayList<>();
    private final AtomicInteger idCounter = new AtomicInteger(2);

    public UserController() {
        users.add(new User(1, "Vishnu Chauhan", "secret123",
                LocalDate.of(1998,5,20), "vishnu@example.com"));
    }

    @GetMapping
    public List<User> getAllUsers() {
        return users;
    }

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable int id) {
        return users.stream()
                .filter(u -> u.getId() == id)
                .findFirst()
                .map(ResponseEntity::ok)
                .orElse(ResponseEntity.notFound().build());
    }

    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        user.setId(idCounter.getAndIncrement());
        users.add(user);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
}

Note:

In this example, we are storing users in memory. In real projects, you would connect to a database using Spring Data JPA

Step 4. Run Application open

Now, run the main application class to start your Spring Boot application.

Java

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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