Use annotation to define constraints on Spring REST API request payloads to return error message if any of the constraints is violated.

<web-app>
    <display-name>Spring Web Service with validation</display-name>
    <servlet>
        <servlet-name>SpringWebServiceValidation</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/myApplicationContext.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>SpringWebServiceValidation</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>
</web-app>
        

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="
	http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context.xsd
    http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd">
    <context:component-scan base-package="controller,exception"/>
    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"/>
        </mvc:message-converters>
    </mvc:annotation-driven>
</beans>
        

package controller;

import model.Customer;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import jakarta.validation.Valid;

@RestController
@RequestMapping("/myapp")
public class MyController {

    @PostMapping("/customer")
    public void postCustomer(@Valid @RequestBody Customer customer) {

        System.out.println("Customer name: " + customer.getFirstName());
    }
}
        

package model;

import lombok.Data;
import validator.NoDuplication;

import jakarta.validation.constraints.Email;
import jakarta.validation.constraints.Max;
import jakarta.validation.constraints.NotNull;
import jakarta.validation.constraints.Positive;
import java.util.List;

@Data
public class Customer {

    @NotNull(message = "Please provide a lastName")
    private String lastName;

    private String firstName;

    @Email(message = "email is not in correct format")
    private String email;

    @Positive(message = "age must be positive")
    private Integer age;

    @Max(value = 5, message = "Maximum number of reference is 5")
    private Integer reference;

    @NoDuplication(message = "Duplicated hobbies are found")
    private List<String> hobbies;
}
        

package model;

import lombok.Data;

@Data
public class ErrorResponse {

    private int errorCode;
    private String errorMessage;
}
        

package validator;

import jakarta.validation.Constraint;
import jakarta.validation.Payload;
import java.lang.annotation.Retention;
import java.lang.annotation.Target;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

@Target(FIELD)
@Retention(RUNTIME)
@Constraint(validatedBy = NoDuplicationValidator.class)
public @interface NoDuplication {

    String message() default "Duplications are found";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}
        

package validator;

import jakarta.validation.ConstraintValidator;
import jakarta.validation.ConstraintValidatorContext;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class NoDuplicationValidator implements ConstraintValidator<NoDuplication, List<String>> {

    @Override
    public void initialize(NoDuplication constraintAnnotation) {

    }

    @Override
    public boolean isValid(List<String> list, ConstraintValidatorContext constraintValidatorContext) {

        boolean valid = true;

        if (list != null) {
            Set<String> set = new HashSet<>(list);

            if (set.size() != list.size()) {
                valid = false;
            }
        }

        return valid;
    }
}
        

package exception;

import model.ErrorResponse;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestControllerAdvice;

@RestControllerAdvice
public class MyExceptionHandler {

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity handleMethodArgumentNotValidException(MethodArgumentNotValidException methodArgumentNotValidException)   {

        ErrorResponse errorResponse = new ErrorResponse();
        errorResponse.setErrorCode(HttpStatus.BAD_REQUEST.value());
        errorResponse.setErrorMessage(methodArgumentNotValidException.getBindingResult().getFieldError().getDefaultMessage());

        ResponseEntity<ErrorResponse> responseEntity = new ResponseEntity<>(errorResponse, HttpStatus.BAD_REQUEST);

        return responseEntity;
    }
}