JSON using Jackson in REST API Implementation with Spring Boot

Last Updated : 27 Apr, 2026

JSON (JavaScript Object Notation) is the most commonly used format for exchanging data between clients and servers in REST APIs. Spring Boot simplifies working with JSON by automatically converting Java objects to JSON (serialization) and JSON to Java objects (deserialization) using the Jackson library.

  • Serialization: Converting Java objects into JSON to send to clients.
  • Deserialization: Converting JSON from clients into Java objects.

What is Jackson

Jackson is a popular Java library for JSON processing. Spring Boot automatically configures Jackson via the spring-boot-starter-web dependency. This means you don’t need to manually add Jackson unless you need additional modules (e.g., for date/time formatting with jackson-datatype-jsr310).

json_file
jackson

Common Jackson Annotations

Jackson provides several annotations for customizing JSON output:

AnnotationDescription
@JsonPropertyRename a field in JSON
@JsonIgnoreIgnore a field during serialization/deserialization
@JsonIncludeInclude/exclude fields based on conditions
@JsonFormatDefine format for date/time fields
@JsonIgnorePropertiesIgnore 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
Structure
structure

Project Structure:

application_programs
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; }
}

Explanation: @JsonProperty renames fields, @JsonIgnore hides the password, @JsonFormat formats dates, and @JsonInclude skips null values.

Step 3: Create REST 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);
  }
}

Step 5: Test endpoints

Finally, test the API endpoints using Postman, cURL or browser.

  • GET all users:

GET http://localhost:8080/api/users

Output:

out
output
Comment

Explore