Spring Boot JSON: @RequestBody, @ResponseBody, Jackson, and REST APIs

Written and reviewed by the Jsonic editorial team — every guide is verified against the official spec or runtime before publication.

Last updated: May 19, 2026

Spring Boot makes JSON handling nearly effortless: drop in spring-boot-starter-web, annotate your controller with @RestController, and Jackson takes care of serialization and deserialization automatically. But production REST APIs require more — validation, custom naming strategies, error response shapes, field visibility control, and custom type handling. This guide covers the full picture from basic controller setup through advanced Jackson configuration.

@RequestBody and @ResponseBody

@RestController combines @Controller and @ResponseBody, making every method return value serialize directly to the HTTP response body as JSON. Use ResponseEntity<T> when you need full control over the status code and headers — for example, 201 Created on POST or 204 No Content on DELETE.

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

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.findById(id)
            .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
        return ResponseEntity.ok(user);
    }

    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody UserCreateDto dto) {
        User created = userService.create(dto);
        URI location = URI.create("/api/users/" + created.getId());
        return ResponseEntity.created(location).body(created);
    }

    @PutMapping("/{id}")
    public User updateUser(@PathVariable Long id, @RequestBody UserUpdateDto dto) {
        return userService.update(id, dto);  // 200 OK with updated object
    }

    @DeleteMapping("/{id}")
    @ResponseStatus(HttpStatus.NO_CONTENT)
    public void deleteUser(@PathVariable Long id) {
        userService.delete(id);  // 204 No Content, no body
    }
}

Jackson ObjectMapper Configuration

Spring Boot auto-configures a global ObjectMapper from spring.jackson.* properties. Set naming strategy, null inclusion, and date format in application.yml; or define a Jackson2ObjectMapperBuilderCustomizer bean for programmatic control without replacing the auto-configuration.

# application.yml — Jackson global defaults
spring:
  jackson:
    default-property-inclusion: non_null   # omit null fields
    property-naming-strategy: SNAKE_CASE   # camelCase → snake_case
    serialization:
      write-dates-as-timestamps: false     # ISO 8601 dates
    deserialization:
      fail-on-unknown-properties: false    # ignore extra JSON fields

// Or programmatically
@Configuration
public class JacksonConfig {
    @Bean
    public ObjectMapper objectMapper() {
        return JsonMapper.builder()
            .addModule(new JavaTimeModule())
            .disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS)
            .serializationInclusion(JsonInclude.Include.NON_NULL)
            .build();
    }
}

Jackson Annotations on POJOs

Jackson annotations let you control how individual fields and classes are serialized without touching the global ObjectMapper. Use them for renaming, excluding, formatting, and aliasing JSON properties.

public class Product {
    @JsonProperty("product_id")          // rename field in JSON
    private Long id;

    @JsonIgnore                           // never serialize this field
    private String internalCode;

    @JsonFormat(pattern = "yyyy-MM-dd")  // custom date format
    private LocalDate releaseDate;

    @JsonInclude(JsonInclude.Include.NON_NULL)  // omit if null (field-level)
    private String description;

    @JsonAlias({"product_name", "title"})  // accept alternate JSON keys on decode
    private String name;

    // getters, setters, or use @JsonAutoDetect with fields
}

DTOs and Validation

Use DTOs (Data Transfer Objects) to capture the exact shape of incoming JSON independently of the domain model. Annotate DTO fields with Bean Validation constraints and add @Valid to the controller parameter to trigger validation automatically.

public record UserCreateDto(
    @NotBlank(message = "Name is required")
    String name,

    @Email(message = "Must be a valid email")
    String email,

    @Min(value = 18, message = "Must be at least 18")
    int age
) {}

// Controller receives and validates
@PostMapping
public User create(@Valid @RequestBody UserCreateDto dto) { ... }

// Global exception handler for 400 Bad Request
@RestControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    @ResponseStatus(HttpStatus.BAD_REQUEST)
    public Map<String, String> handleValidation(MethodArgumentNotValidException e) {
        return e.getBindingResult().getFieldErrors().stream()
            .collect(Collectors.toMap(
                FieldError::getField,
                FieldError::getDefaultMessage
            ));
    }
}

Custom Serializer/Deserializer

When Jackson's default behavior doesn't fit a type — such as a Money value object or a third-party class you can't annotate — write a custom JsonSerializer or JsonDeserializer and register it on the class or globally.

// Custom serializer for Money type
public class MoneySerializer extends JsonSerializer<Money> {
    @Override
    public void serialize(Money money, JsonGenerator gen, SerializerProvider provider)
            throws IOException {
        gen.writeStartObject();
        gen.writeNumberField("amount", money.getAmount().toPlainString());
        gen.writeStringField("currency", money.getCurrency().getCurrencyCode());
        gen.writeEndObject();
    }
}

// Register on class
@JsonSerialize(using = MoneySerializer.class)
public class Money { ... }

// Or register globally
@Bean
public Jackson2ObjectMapperBuilderCustomizer customizer() {
    return builder -> builder.serializerByType(Money.class, new MoneySerializer());
}

JSON Response Shaping

Use @JsonView to return different subsets of fields depending on the caller's role, without creating multiple DTOs. Spring Projections offer an interface-based alternative for Spring Data repositories.

// @JsonView — return different fields for public vs admin
public class Views {
    public static class Public {}
    public static class Admin extends Public {}
}

public class User {
    @JsonView(Views.Public.class) private String name;
    @JsonView(Views.Admin.class) private String email;   // admin only
    @JsonView(Views.Admin.class) private String role;    // admin only
}

@GetMapping("/{id}")
@JsonView(Views.Public.class)
public User getUser(@PathVariable Long id) { ... }

// Alternatively, use Spring Projections (interface-based)
public interface UserSummary {
    String getName();
    String getEmail();
}

JSON Error Responses

Spring 6 (Boot 3+) ships built-in support for RFC 9457 Problem Details via the ProblemDetail class. Return structured, machine-readable error bodies without building a custom error DTO from scratch.

// Spring 6+ built-in Problem Details (RFC 9457)
@RestControllerAdvice
public class ProblemDetailsHandler extends ResponseEntityExceptionHandler {

    @ExceptionHandler(ResourceNotFoundException.class)
    public ProblemDetail handleNotFound(ResourceNotFoundException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(
            HttpStatus.NOT_FOUND, ex.getMessage()
        );
        problem.setTitle("Resource Not Found");
        problem.setType(URI.create("https://api.example.com/errors/not-found"));
        return problem;
    }
}

// Response JSON:
// {"type":"https://api.example.com/errors/not-found",
//  "title":"Resource Not Found","status":404,
//  "detail":"User 42 not found"}

Key Jackson Annotations Reference

Definitions

ObjectMapper

The central Jackson class that converts Java objects to JSON strings (serialization) and JSON strings to Java objects (deserialization).

@RestController

A Spring MVC stereotype annotation combining @Controller and @ResponseBody; every method return value is serialized to JSON (or XML) response body.

@RequestBody

Marks a method parameter for binding the incoming HTTP request body, deserialized from JSON by Jackson.

HttpMessageConverter

Spring's interface for reading HTTP requests and writing responses; MappingJackson2HttpMessageConverter handles application/json.

DTO (Data Transfer Object)

A plain Java class used to capture request/response shape independently of the domain model; prevents over-posting (mass assignment) and exposes only intended fields.

FAQ