Bean Validation

import javax.validation.constraints.NotNull;
...
class AClass {
    @NotNull
    private String aValue;
    ...

import javax.validation.Valid;
import org.springframework.validation.annotation.Validated;
...
@Component
@Validated (3)
public class AService {
    @NotNull (2)
    public String aMethod(@NotNull @Valid AClass aParameter) { (1)
        return ...;
    }

import javax.validation.Validation;
...
ValidatorFactory myValidatorFactory = Validation.byDefaultProvider()
    .configure()
        //configuration commands
    .buildValidatorFactory(); (1)
//ValidatorFactory myValidatorFactory = Validation.buildDefaultValidatorFactory();
Validator myValidator = myValidatorFactory.getValidator(); (1)

@Autowired
private Validator validator;

@Bean (1)
public Validator validator() {
    return Validation.byDefaultProvider()
            .configure()
                //configuration commands
            .buildValidatorFactory()
            .getValidator();
}

@Getter
public class AClass {
    @NotNull
    private String aValue;
    ...

//given - @NotNull aProperty set to null by ctor
AClass invalidAClass = new AClass();
//when - checking constraints
Set<ConstraintViolation<AClass>> violations = myValidator.validate(invalidAClass);(1)
violations.stream().forEach(v-> log.info("field name={}, value={}, violated={}",
        v.getPropertyPath(), v.getInvalidValue(), v.getMessage()));
//then - there will be at least one violation
then(violations).isNotEmpty(); (2)

field name=aValue, value=null, violated=must not be null

public class AService {
    @NotNull
    public String aMethod(@NotNull @Valid AClass aParameter) {  (1) (2)
        return ...
    }

//given
AService myService = new AService(); (1)
AClass myValue = new AClass();
//when
String result = myService.aMethod(myValue);

Object[] methodParams = new Object[]{ myValue };
Class<?>[] methodParamTypes = new Class<?>[]{ AClass.class };
Method methodToCall = AService.class.getMethod("aMethod", methodParamTypes);

 (AService)myService).aMethod((AClass)myValue);

//when
Set<ConstraintViolation<AService>> violations = validator
    .forExecutables() (1)
    .validateParameters(myService, methodToCall, methodParams);

//then
then(violations).hasSize(1);
ConstraintViolation<?> violation = violations.iterator().next();
then(violation.getPropertyPath().toString()).isEqualTo("aMethod.arg0.aValue");
then(violation.getMessage()).isEqualTo("must not be null");
then(violation.getInvalidValue()).isEqualTo(null);
then(violation.getInvalidValue()).isEqualTo(myValue.getAValue());

//given
String nullResult = null;
//when
violations = validator.forExecutables()
        .validateReturnValue(myService, methodToCall, nullResult);

//then
then(violations).hasSize(1);
violation = violations.iterator().next();
then(violation.getPropertyPath().toString()).isEqualTo("aMethod.<return value>");
then(violation.getMessage()).isEqualTo("must not be null");
then(violation.getInvalidValue()).isEqualTo(nullResult);

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <parameters>true</parameters>
    </configuration>
</plugin>

ValidatorFactory myValidatorFactory = Validation.byDefaultProvider()
    .configure()
        .parameterNameProvider(new MyParameterNameProvider()) (1)
    .buildValidatorFactory();

import javax.validation.ParameterNameProvider;
import java.lang.reflect.Constructor;
import java.lang.reflect.Executable;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
...
public class MyParameterNameProvider implements ParameterNameProvider {
    @Override
    public List<String> getParameterNames(Constructor<?> ctor) {
        return getParameterNames((Executable) ctor);
    }
    @Override
    public List<String> getParameterNames(Method method) {
        return getParameterNames((Executable) method);
    }
    protected List<String> getParameterNames(Executable method) {
        List<String> argNames = new ArrayList<>(method.getParameterCount());
        for (Parameter p: method.getParameters()) {
            //do something to determine Parameter p's desired name
            String argName=p.getName(); (1)
            argNames.add(argName);
        }
        return argNames; (2)
    }
}

import javax.inject.Named;
...
private static class AService {
    @NotNull
    public String aMethod(@NotNull @Valid @Named("aParameter") AClass aParameter) {(1)
        return ...
    }

Named named = p.getAnnotation(Named.class);
String argName=named!=null && StringUtils.isNotBlank(named.value()) ?
        argName=named.value() : //@Named.property
        p.getName();            //default reflection name
argNames.add(argName);

original: aMethod.arg0.aValue
assisted: aMethod.aParameter.aValue

//given
Object nonTraversing = new NonTraversingParent(); (1)
//when
Set<ConstraintViolation<Object>> violations = validator.validate(nonTraversing); (2)
//then
then(violations).isEmpty(); (3)

import javax.validation.Valid;
...
//given
Object traversing = new TraversingParent(); (1)
//when
Set<ConstraintViolation<Object>> violations = validator.validate(traversing); (2)
//then
String errorMsgs = violations.stream()
        .map(v->v.getPropertyPath().toString()+":"+v.getMessage())
        .collect(Collectors.joining("\n"));
then(errorMsgs).contains("child.cannotBeNull:must not be null"); (3)
then(violations).hasSize(1);

import javax.validation.groups.Default;
...
public interface PocValidationGroups { (3)
    public interface Create{}; (1)
    public interface CreatePlusDefault extends Create, Default{}; (2)
    public interface UpdatePlusDefault extends Default{};

public class PersonPocDTO {
    @Null(groups = PocValidationGroups.Create.class, (1)
        message = "cannot be specified for create")
    private String id;
    private String firstName;
    private String lastName;
    @Past(groups = Default.class) (2)
    private LocalDate dob;
    @Size(min=1, message = "must have at least one contact point") (3)
    private List<@NotNull @Valid ContactPointDTO> contactPoints;

//given
ContactPointDTO invalidForCreate = contactDTOFactory.make(ContactDTOFactory.oneUpId); (1)
//when
Set<ConstraintViolation<ContactPointDTO>> violations = validator.validate(invalidForCreate); (2)
//then
then(violations).hasSize(0);

//given
...
String expectedError="id:cannot be specified for create";
//when
violations = validator.validate(invalidForCreate, CreatePlusDefault.class); (1)
//then
then(violations).hasSize(1); (2)
then(errors(violations)).contains(expectedError); (3)

public class ContactPointDTO {
    @Null (groups = {Create.class},
            message = "cannot be specified for create")
    private String id;
    @NotNull
    private String name;
    @Size(min=7, max=40, groups= SimplePlusDefault.class) (1)
    @Email(groups = DetailedOnly.class) (2)
    private String email;

public interface Create{};
public interface SimplePlusDefault extends Default {}
public interface DetailedOnly {}

String nameErr="name:must not be null"; //Default Group
String sizeErr="email:size must be between 7 and 40"; //Simple Group
String formatErr="email:must be a well-formed email address"; //DetailedOnly Group
//when - validating against all groups
Set<ConstraintViolation<ContactPointDTO>> violations = validator.validate(
        invalidContact,
        SimplePlusDefault.class, DetailedOnly.class);
//then - all groups will have their violations reported
then(errors(violations)).contains(nameErr, sizeErr, formatErr).hasSize(3); (1) (2) (3)

@GroupSequence({ SimplePlusDefault.class, DetailedOnly.class }) (1)
public interface DetailOrder {};

//when - validating using a @GroupSequence
violations = validator.validate(invalidContact, DetailOrder.class);
//then - validation stops once a group produces a violation
then(errors(violations)).contains(nameErr, sizeErr).hasSize(2); (1)

@Component (1)
public class ValidatedComponentImpl implements ValidatedComponent {
   @Override
   public void aCall(int mustBeGE5) {
   }
}

@Autowired
private ValidatedComponent component;

import javax.validation.ConstraintViolationException;
...
//when
ConstraintViolationException ex = catchThrowableOfType(
        () -> component.aCall(1), (1)
        ConstraintViolationException.class);
//then
Set<ConstraintViolation<?>> violations = ex.getConstraintViolations();
String errorMsgs = violations.stream()
        .map(v->v.getPropertyPath().toString() +":" + v.getMessage())
        .collect(Collectors.joining("\n"));
then(errorMsgs).isEqualTo("aCall.mustBeGE5:must be greater than or equal to 5");

assertThatNoException().isThrownBy(
        ()->component.aCall(10) (1)
    );

@Component
public class ValidatedComponentImpl implements ValidatedComponent {
@Override
    public void aCall(@Positive int mustBeGE5) {} //invalid (1)
}

javax.validation.ConstraintDeclarationException: HV000151: A method overriding another method must not redefine the parameter constraint configuration, but method ValidatedComponentImpl#aCall(int) redefines the configuration of ValidatedComponent#aCall(int).

return Validation.byDefaultProvider() (1)
    .configure()
        .addProperty("hibernate.validator.allow_parameter_constraint_override",
                                                Boolean.TRUE.toString()) (2)
        .parameterNameProvider(new MyParameterNameProvider())
    .buildValidatorFactory()
    .getValidator();

return Validation.byProvider(HibernateValidator.class) (1)
    .configure()
        .allowOverridingMethodAlterParameterConstraint(true) (2)
        .parameterNameProvider(new MyParameterNameProvider())
    .buildValidatorFactory()
    .getValidator();

//@Validated (1)
public interface PocService {
    @NotNull
    @Validated(CreatePlusDefault.class) (2)
    public PersonPocDTO createPOC(
            @NotNull (3)
            @Valid PersonPocDTO personDTO); (4)

public class PersonPocDTO {
    @Null(groups = Create.class, message = "cannot be specified for create")
    private String id; (1)

PersonPocDTO pocWithId = pocFactory.make(oneUpId); (3)
assertThatThrownBy(() -> pocService.createPOC(pocWithId)) (1)
        .isInstanceOf(ConstraintViolationException.class)
        .hasMessageContaining("createPOC.person.id: cannot be specified for create"); (2)

@Documented
@Target({ ElementType.METHOD, FIELD, ANNOTATION_TYPE, PARAMETER, TYPE_USE })
@Retention( RetentionPolicy.RUNTIME )
@Repeatable(value= MinAge.List.class)
@Constraint(validatedBy = {
        MinAgeLocalDateValidator.class,
        MinAgeDateValidator.class
})
public @interface MinAge {
    String message() default "age below minimum({age}) age";
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};

    int age() default 0;
    int tzOffsetHours() default 0;

    @Documented
    @Retention(RUNTIME)
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, PARAMETER, TYPE_PARAMETER })
    public @interface List {
        MinAge[] value();
    }
}

/**
 * Defines a minimum age based upon a LocalDate, the current
 * LocalDate, and a specified timezone.
 */

@Documented //include this in Javadoc for elements that it is defined

@Retention(
    //SOURCE - annotation discarded by compiler
    //CLASS - annotation available in class file but not loaded at runtime - default
    RetentionPolicy.RUNTIME //annotation available thru reflection at runtime
)

@Repeatable(value= MinAge.List.class)
public @interface MinAge {
...
    @Retention(RUNTIME)
    @Target({ METHOD, FIELD, ANNOTATION_TYPE, PARAMETER, TYPE_USE })
    public @interface List {
        MinAge[] value();
    }
}

@MinAge(age=18, groups = {VotingGroup.class})
@MinAge(age=65, groups = {RetiringGroup.class})
public LocalDate getConditionalDOB() {
    return dob;
}

@Constraint(validatedBy = {
        MinAgeLocalDateValidator.class, (1)
        MinAgeDateValidator.class (2)
})
public @interface MinAge {

@MinAge(age=18, groups = {VotingGroup.class})
@MinAge(age=65, groups = {RetiringGroup.class})
public LocalDate getConditionalDOB() { (1)
    return dob;
}

@MinAge(age=16, message="found java.util.Date age({age}) violation")
public Date getDobAsDate() { (2)
    return Date.from(dob.atStartOfDay().toInstant(ZoneOffset.UTC));
}

public @interface MinAge {
...
    int age() default 0;
    int tzOffsetHours() default 0;
...

@Constraint(validatedBy = {
        MinAgeLocalDateValidator.class,
        MinAgeDateValidator.class
})
public @interface MinAge {

public class MinAgeLocalDateValidator implements ConstraintValidator<MinAge, LocalDate> {
    ...
    @Override
    public void initialize(MinAge annotation) { ... }
    @Override
    public boolean isValid(LocalDate dob, ConstraintValidatorContext context) { ... }

public class MinAgeDateValidator implements ConstraintValidator<MinAge, Date> {
    ...
    @Override
    public void initialize(MinAge annotation) { ... }
    @Override
    public boolean isValid(Date dob, ConstraintValidatorContext context) { ... }

public class MinAgeLocalDateValidator implements ConstraintValidator<MinAge, LocalDate> {
  private int minAge;
  private ZoneOffset zoneOffset;

  @Override
  public void initialize(MinAge annotation) {
    if (annotation.age() < 0) {
        throw new IllegalArgumentException("age constraint cannot be negative");
    }
    this.minAge = annotation.age();

    if (annotation.tzOffsetHours() > 23 || annotation.tzOffsetHours() < -23) {
        throw new IllegalArgumentException("tzOffsetHours must be between -23 and +23");
    }
    zoneOffset = ZoneOffset.ofHours(annotation.tzOffsetHours());
  }

    @Override
    public boolean isValid(LocalDate dob, ConstraintValidatorContext context) {
        if (dob!=null) { //assume null is valid and use @NotNull if it should not be
            final LocalDate now = LocalDate.now(zoneOffset);
            final int currentAge = Period.between(dob, now).getYears();
            return currentAge >= minAge;
        }
        return true;
    }
}

context.buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate())
        .addParameterNode(1)
        .addConstraintViolation()
        .buildConstraintViolationWithTemplate(context.getDefaultConstraintMessageTemplate())
        .addParameterNode(2)
        .addConstraintViolation();
//the following removes default-generated message
//context.disableDefaultConstraintViolation(); (1)

@ConsistentNameParameters(message = "name1 and/or name2 must be supplied") (1)
public NamedThing(String id, String name1, String name2, LocalDate dob) {

NamedThing.name1:name1 and/or name2 must be supplied (1)
NamedThing.name2:name1 and/or name2 must be supplied (1)
NamedThing.<cross-parameter>:name1 and/or name2 must be supplied (2)

@Documented
@Constraint(validatedBy = ConsistentNameParameters.ConsistentNameParametersValidator.class )
@Target({ElementType.METHOD, ElementType.CONSTRUCTOR})
@Retention(RetentionPolicy.RUNTIME)
public @interface ConsistentNameParameters {

@SupportedValidationTarget(ValidationTarget.PARAMETERS) (1)
public class ConsistentNameParametersValidator
        implements ConstraintValidator<ConsistentNameParameters, Object[]> { (2)

@Override
public boolean isValid(Object[] values, ConstraintValidatorContext context) { (1)
    if (values.length != 4) { (2)
        throw new IllegalArgumentException(
            String.format("Unexpected method signature, 4 params expected, %d supplied", values.length));
    }
    for (int i=1; i<3; i++) { //look at positions 1 and 2 (3)
        if (values[i]!=null && !(values[i] instanceof String)) {
            throw new IllegalArgumentException(
                String.format("Illegal method signature, param[%d], String expected, %s supplied", i, values[i].getClass()));
        }
    }
    ...

@Override
public boolean isValid(Object[] values, ConstraintValidatorContext context) { (1)
    ...
    String name1= (String) values[1];
    String name2= (String) values[2];
    return (StringUtils.isNotBlank(name1) || StringUtils.isNotBlank(name2));
}

@Validated (1)
public class ContactsController {
    ...
    @RequestMapping(path=CONTACTS_PATH,
        method= RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
    @Validated(PocValidationGroups.CreatePlusDefault.class) (2)
    public ResponseEntity<PersonPocDTO> createPOC(
        @RequestBody
        @Valid (3)
        PersonPocDTO personDTO) {
...

> POST http://localhost:64153/api/contacts

{"id":"1","firstName":"Douglass","lastName":"Effertz","dob":[2011,6,14],"contactPoints":[{"id":null,"name":"Cell","email":"penni.kautzer@hotmail.com","phone":"(876) 285-7887 x1055","address":{"street":"69166 Angelo Landing","city":"Jaredshire","state":"IA","zip":"81764-6850"}}]}

< 500 INTERNAL_SERVER_ERROR Internal Server Error (1)

{ "url" : "http://localhost:53298/api/contacts",
  "statusCode" : 500,
  "statusName" : "INTERNAL_SERVER_ERROR",
  "message" : "Unexpected Error",
  "description" : "unexpected error executing request: javax.validation.ConstraintViolationException: createPOC.person.id: cannot be specified for create",
  "timestamp" : "2021-07-01T14:58:48.777269Z" }

import info.ejava.examples.common.web.BaseExceptionAdvice;
...
@RestControllerAdvice (1)
public class ExceptionAdvice extends BaseExceptionAdvice { (2)

    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<MessageDTO> handle(ConstraintViolationException ex) {
        String description = ex.getConstraintViolations().stream()
                .map(v->v.getPropertyPath().toString() + ":" + v.getMessage())
                .collect(Collectors.joining("\n"));
        HttpStatus status = HttpStatus.BAD_REQUEST; (3)
        return buildResponse(status, "Validation Error", description, (Instant)null);
    }

{ "url" : "http://localhost:53408/api/contacts",
  "statusCode" : 400,
  "statusName" : "BAD_REQUEST",
  "message" : "Validation Error",
  "description" : "createPOC.person.id: cannot be specified for create",
  "timestamp" : "2021-07-01T15:10:59.037162Z" }

@RequestMapping(path=CONTACTS_PATH,
        method= RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
//@Validated(PocValidationGroups.CreatePlusDefault.class) -- no longer needed (1)
public ResponseEntity<PersonPocDTO> createPOC(
        @RequestBody
        //@Valid -- replaced by @Validated (1)
        @Validated(PocValidationGroups.CreatePlusDefault.class) (2)
        PersonPocDTO personDTO) {

< 400 BAD_REQUEST Bad Request
{"timestamp":"2021-07-01T15:24:44.464+00:00",
 "status":400,
 "error":"Bad Request",
 "message":"",
 "path":"/api/contacts"}

@RestControllerAdvice
public class ExceptionAdvice extends BaseExceptionAdvice {
    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<MessageDTO> handle(ConstraintViolationException ex) { ... }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<MessageDTO> handle(MethodArgumentNotValidException ex) { (1)

        List<String> fieldMsgs = ex.getFieldErrors().stream() (2)
            .map(e -> e.getObjectName()+"."+e.getField()+": "+e.getDefaultMessage())
            .toList();
        List<String> globalMsgs = ex.getGlobalErrors().stream() (3)
            .map(e -> e.getObjectName() +": "+ e.getDefaultMessage())
            .toList();
        String description = Stream.concat(fieldMsgs.stream(), globalMsgs.stream())
            .collect(Collectors.joining("\n"));
        return buildResponse(HttpStatus.UNPROCESSABLE_ENTITY, "Validation Error",
            description, (Instant)null);
    }

@RequestMapping(path= CONTACT_PATH,
        method=RequestMethod.GET,
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<PersonPocDTO> getPOC(
        @PathVariable(name="id")
        @Pattern(regexp = "[0-9]+", message = "must be a number") (1)
                String id) {

> HTTP GET http://localhost:53918/api/contacts/1...34, headers={masked}
< BAD_REQUEST/400
{ "url" : "http://localhost:53918/api/contacts/1...34",
  "statusCode" : 400,
  "statusName" : "BAD_REQUEST",
  "message" : "Validation Error",
  "description" : "getPOC.id: must be a number",
  "timestamp" : "2021-07-01T15:51:34.724036Z" }

< 500 INTERNAL_SERVER_ERROR Internal Server Error
{"timestamp":"2021-07-01T19:21:31.345+00:00","status":500,"error":"Internal Server Error","message":"","path":"/api/contacts/1...34"}

@RequestMapping(path= EXAMPLE_CONTACTS_PATH,
        method=RequestMethod.POST,
        consumes={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE},
        produces={MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<PersonsPageDTO> findPocsByExample(
        @RequestParam(value = "pageNumber", defaultValue = "0", required = false)
        @PositiveOrZero
        Integer pageNumber,

        @RequestParam(value = "pageSize", required = false)
        @Positive
        Integer pageSize,

        @RequestParam(value = "sort", required = false) String sortString,
        @RequestBody PersonPocDTO probe) {

> POST http://localhost:53996/api/contacts/example?pageNumber=-1&pageSize=0
{ ... }
> BAD_REQUEST/400
{ "url" : "http://localhost:53996/api/contacts/example?pageNumber=-1&pageSize=0",(1) (2)
  "statusCode" : 400,
  "statusName" : "BAD_REQUEST",
  "message" : "Validation Error",
  "description" : "findPocsByExample.pageNumber: must be greater than or equal to 0\nfindPocsByExample.pageSize: must be greater than 0",
  "timestamp" : "2021-07-01T15:55:44.089734Z" }

@RequestMapping(path = POSITIVE_OR_ZERO_PATH,
method=RequestMethod.GET,
    produces = {MediaType.APPLICATION_JSON_VALUE, MediaType.APPLICATION_XML_VALUE})
public ResponseEntity<?> positive(
        @PositiveOrZero (1)
        @RequestParam(name = "value") int value) {
    PersonPocDTO resultDTO = contactsService.positiveOrZero(value); (2)

public class PocServiceImpl implements PocService {
    ...
    public PersonPocDTO positiveOrZero(int value) {
        //obviously an error!!
        internalComponent.negativeOrZero(value);
        ...

@Component
@Validated
public class InternalComponent {
    public void negativeOrZero(@NegativeOrZero int value) {

> GET http://localhost:54298/api/contacts/positiveOrZero?value=1

< 400 BAD_REQUEST Bad Request
{ "url":"http://localhost:54298/api/contacts/positiveOrZero?value=1",
  "statusCode":400,
  "statusName":"BAD_REQUEST",
  "message":"Validation Error",
  "description":"negativeOrZero.value: must be less than or equal to 0",
  "timestamp":"2021-07-01T16:23:27.666154Z"}

@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<MessageDTO> handle(ConstraintViolationException ex) {
    String description = ...

    boolean isFromAPI = ex.getConstraintViolations().stream() (1)
            .map(v -> v.getRootBean().getClass().getAnnotation(RestController.class))
            .filter(a->a!=null)
            .findFirst()
            .orElse(null)!=null;

    HttpStatus status = isFromAPI ?
            HttpStatus.BAD_REQUEST : HttpStatus.INTERNAL_SERVER_ERROR;
    return buildResponse(status, "Validation Error", description, (Instant)null);
}

{ "url" : "http://localhost:54434/api/contacts/positiveOrZero?value=1",
  "statusCode" : 500,
  "statusName" : "INTERNAL_SERVER_ERROR",
  "message" : "Validation Error",
  "description" : "negativeOrZero.value: must be less than or equal to 0",
  "timestamp" : "2021-07-01T16:45:50.235724Z" }

public interface PocService {
    @NotNull
    @Validated(PocValidationGroups.CreatePlusDefault.class)
    public PersonPocDTO createPOC(
        @NotNull
        @Valid PersonPocDTO personDTO);

< 400 BAD_REQUEST Bad Request
{ "url" : "http://localhost:55168/api/contacts",
  "statusCode" : 400,
  "statusName" : "BAD_REQUEST",
  "message" : "Validation Error",
  "description" : "createPOC.person.id: cannot be specified for create",
  "timestamp" : "2021-07-01T17:40:12.221497Z" }

public @interface Xxx {
        String message() default "...";
        Class<?>[] groups() default { };
        Class<? extends Payload>[] payload() default { }; (1)

public interface InternalError extends Payload {}

@Component
@Validated
public class InternalComponent {
    public void negativeOrZero(@NegativeOrZero(payload = InternalError.class) int value) {

@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<MessageDTO> handle(ConstraintViolationException ex) {
    String description = ...;
    boolean isFromAPI = ...;

    boolean isInternalError = isFromAPI ? false : (1)
        ex.getConstraintViolations().stream()
            .map(v -> v.getConstraintDescriptor().getPayload())
            .filter(p-> p.contains(InternalError.class))
            .findFirst()
            .orElse(null)!=null;

    HttpStatus status = isFromAPI || !isInternalError ?
            HttpStatus.BAD_REQUEST : HttpStatus.INTERNAL_SERVER_ERROR;

    return buildResponse(status, "Validation Error", description, (Instant)null);
}

> POST http://localhost:55288/api/contacts
< 400/BAD_REQUEST
  "url" : "http://localhost:55288/api/contacts",
  "statusCode" : 400,
  "statusName" : "BAD_REQUEST",
  "message" : "Validation Error",
  "description" : "createPOC.person.id: cannot be specified for create",
  "timestamp" : "2021-07-01T17:56:23.080884Z"
}

> GET http://localhost:57547/api/contacts/positiveOrZero?value=1
< INTERNAL_SERVER_ERROR/500
{ "url" : "http://localhost:57547/api/contacts/positiveOrZero?value=1",
  "statusCode" : 500,
  "statusName" : "INTERNAL_SERVER_ERROR",
  "message" : "Validation Error",
  "description" : "negativeOrZero.value: must be less than or equal to 0",
  "timestamp" : "2021-07-01T20:25:05.188126Z" }

@Document(collection = "pocs")
public class PersonPOC {
    ...
    @NotNull
    private LocalDate dob;
    ...
}

//given
PersonPOC noDobPOC = mapper.map(pocDTOFactory.make().withDob(null));
//when
assertThatThrownBy(() -> contactsRepository.save(noDobPOC))
        .isInstanceOf(ConstraintViolationException.class)
        .hasMessageContaining("dob: must not be null");

package org.springframework.data.mongodb.core.mapping.event;
...
public class ValidatingMongoEventListener extends AbstractMongoEventListener<Object> {
    ...
        private final Validator validator;
          @Override
        public void onBeforeSave(BeforeSaveEvent<Object> event) {
              ...
        }
}

@Override
public void onBeforeSave(BeforeSaveEvent<Object> event) {
    Set violations = validator.validate(event.getSource());

    if (!violations.isEmpty()) {
        throw new ConstraintViolationException(violations);
    }
}