Open In App

JSON using Jackson in REST API Implementation with Spring Boot

Last Updated : 05 Sep, 2025
Comments
Improve
Suggest changes
1 Likes
Like
Report

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

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), "[email protected]"));
    }

    @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

M

mail2praveensunks
Improve
Article Tags :

Explore

Lightbox