Return different HTTP status code from spring boot custom validators

Current Behaviour

• When an exception (which does not extend ConstraintDeclarationException) is thrown by the validator code instead of returning false, javax.validation wraps the exception in ValidationException. This is validator framework's behaviour and not a spring framework issue.

• When an exception which extends ConstraintDeclarationException is thrown by the validator code instead of returning false, javax.validation framework propagates it.

• If the validator returns false instead of throwing exception, Spring will convert all the validation errors into global errors or field errors and wrap them in MethodArgumentNotValidException and throws it.

Issue

• The second option has field errors and global errors, custom status code can only be returned by inspecting the field name and error code. So this is not feasible as many fields can be added with that annotation.
• In the first option, Custom exceptions which were thrown in the validator are wrapped in ValidationException so exception specific handler is not possible.

Possible Solutions

• Unwrap the specific exception which does not extend ConstraintDeclarationException and map it

    @ExceptionHandler(ValidationException.class)
    public ResponseEntity handle(ValidationException e) {
        Throwable cause = e.getCause();
        if (cause instanceof InvalidIpException) {
            return ResponseEntity
                    .status(HttpStatus.BAD_REQUEST)//may be different code
                    .body(cause.getMessage());
        }
        if (cause instanceof InuseIpException) {
            return ResponseEntity
                    .status(HttpStatus.BAD_REQUEST)//may be different code
                    .body(cause.getMessage());
        }
        return ResponseEntity
                .status(HttpStatus.BAD_REQUEST)
                .body(e.getMessage());
    }

• Make your specific exception to extend ConstraintDeclarationException and then have specific handler for it.

    public class InvalidIpException extends 
                                    ConstraintDeclarationException {

    @ExceptionHandler(InvalidIpException.class)
    public ResponseEntity handle(InvalidIpException e) {
     ...
    }

Reference code

• https://github.com/hibernate/hibernate-validator/blob/master/engine/src/main/java/org/hibernate/validator/internal/engine/constraintvalidation/ConstraintTree.java#L183

create a class for Error under the model package

@NoArgsConstructor
@Geeter
@Setter
public class ErrorMessage
{
    private int errorCode;
    private String errorMsg;
    private String documentation;

     public ErrorMessage(int errorCode,String errorMsg,String documentation)
       {
          this.errorCode=errorCode;
          this.errorMsg=errorMsg;
          this.documentation=documentation;
       }
}

create a Custom Validation Exception class under the exception package

public class CustomValidationException extends RuntimeException
{
          public CustomValidationException(String msg)
         {
              super(msg);
         }
}

create ExceptionHandler class under the same(exception) package

@RestControllerAdvice
public class CustomValidationExceptionHandler
{
   @ExceptionHandler
   public ResponseEntity toResponse(CustomValidationException ex)
   {
        ErrorMessage errorMessage=new 
       ErrorMessage(400,ex.getMessage,"www.stackoverflow.com");
      return new ResponseEntity<ErrorMessage>(errorMessage,HttpStatus.BAD_REQUES);
   }

}

I will state my case here and you can apply my solution for your project I guess.

My annotation:

@Target({ ElementType.PARAMETER, ElementType.FIELD })
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = ResourceIdConstraintValidator.class)
public @interface ResourceId {
    String message() default "Resource doesn't exist with given id.";
    HttpStatus responseStatus() default HttpStatus.NOT_FOUND;
    Class<?>[] groups() default {};
    Class<? extends Payload>[] payload() default {};
}

Keep in mind next line from annotation above, this is the key:

HttpStatus responseStatus() default HttpStatus.NOT_FOUND;

My validator:

@Service
@RequiredArgsConstructor
public class ResourceIdConstraintValidator implements ConstraintValidator<ResourceId, Integer> {

    private final BinaryStorageService storageService;

    @Override
    public boolean isValid(Integer id, ConstraintValidatorContext context) {
        return storageService.isResourceExist(id);
    }
}

My Exception handler from my RestControllerAdvice:

@ExceptionHandler(ConstraintViolationException.class)
public ResponseEntity<ExceptionResponse> handleConstraintViolationException(
        ConstraintViolationException e,
        HttpServletRequest request
) {
    final List<String> messages = e.getConstraintViolations().stream()
            .map(ConstraintViolation::getMessage)
            .toList();

    final HttpStatus httpStatus = e.getConstraintViolations().stream()
            .findFirst().map(violation ->
                    (HttpStatus) violation.getConstraintDescriptor().getAttributes().get("responseStatus")
            ).orElse(HttpStatus.BAD_REQUEST);

    final ExceptionResponse exceptionResponse = ExceptionResponse.builder()
            .timestamp(ZonedDateTime.now())
            .status(httpStatus.value())
            .error(httpStatus.getReasonPhrase())
            .message(messages)
            .path(request.getServletPath())
            .build();

    return ResponseEntity.status(httpStatus)
            .body(exceptionResponse);
}

So, I solved your issue in:

final HttpStatus httpStatus = e.getConstraintViolations().stream()
        .findFirst().map(violation ->
                (HttpStatus) violation.getConstraintDescriptor().getAttributes().get("responseStatus")
        ).orElse(HttpStatus.BAD_REQUEST);

After understanding the question fully, following is what will give you what you need. You can add as many exceptions as you need in the hierarchy as child classes of IpValidationException and keep custom HTTP status code as per your business/technical use cases.

public abstract class IpValidationException extends ValidationException {
    private HttpStatus status;
    private String message;

    public IpValidationException(HttpStatus status, String message) {
        this.status = status;
        this.message = message;
    }

    public HttpStatus getStatus() {
        return status;
    }

    public String getMessage() {
        return message;
    }
}

public class InvalidIpException extends IpValidationException {
    public InvalidIpException(HttpStatus status, String message) {
        super(HttpStatus.BAD_REQUEST, "Invalid IP address");
    }
}

public class InuseIpException extends IpValidationException {
    public InuseIpException(HttpStatus status, String message) {
        super(HttpStatus.CONFLICT, "IP address already in use");
    }
}

public class IpAddressValidator implements ConstraintValidator<IpAddress, String> {

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        Pattern pattern =
                Pattern.compile("^([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})\\.([0-9]{1,3})$");
        Matcher matcher = pattern.matcher(value);
        //step 1
        if (!matcher.matches()) {
            throw new InvalidIpException();
        }
        //Step 2
        if (ipAddress already in DB) {
            throw new InuseIpException(); //conflict with other IP address
        }
        //Add more checks with more exception as you need.

    }
}

// This is how your exception handler should look like
@ExceptionHandler(IpValidationException.class)
public ResponseEntity<ErrorResponse> handle(IpValidationException e) {
    return ResponseEntity
            .status(e.getStatus())
            .body(e.getMessage());
}

Hope this helps!!