REST request argument Validation In Router Function - spring

Question

In Spring controller approach, We could do REST request argument validation using #Valid with Something like this
#PostMapping(REGISTER)
public ResponseEntity<SomeData> registerSomeData(#RequestBody #Valid final SomeData someData) {
...................
}
public class SomeData {
#Size(min = 2, max = 20)
private String firstname;
#Digits(fraction = 0, integer = 10)
private Integer customerID;
#NotNull
private Customer customer;
}
If the request doesn't match these contraints, then Spring framework would throw Bad Request Exception(400).
With Spring5 router functions, I don't understand how we can do this, because we can't give #Valid in router functions.

Answer 1

It's mildly irritating that this useful functionality does not seem to have been carried over into the functional world but it's really not too hard to implement the validation step yourself. Here's how.
Create a bean to perform the validation:
#Component
public class RequestValidator {
#Inject
Validator validator;
public <T> Mono<T> validate(T obj) {
if (obj == null) {
return Mono.error(new IllegalArgumentException());
}
Set<ConstraintViolation<T>> violations = this.validator.validate(obj);
if (violations == null || violations.isEmpty()) {
return Mono.just(obj);
}
return Mono.error(new ConstraintViolationException(violations));
}
}
Now in your handler function include a step that performs the validation. In this example the FindRequest class is a JSON domain model class that contains validation annotations such as #NotEmpty and #NotNull etc. Adapt how you construct the ServerResponse based on this fictitious example that calls a reactive data repository.
#Component
public class MyHandler {
#Inject
RequestValidator validator;
public Mono<ServerResponse> findAllPeople(ServerRequest request) {
return request.bodyToMono(FindRequest.class)
.flatMap(this.validator::validate)
.flatMap(fr -> ServerResponse
.ok()
.body(this.repo.findAllByName(fr.getName()), Person.class));
}
}
The same approach can be used to extend the functionality to handle Flux as well as Mono.

Answer 2

You can't use annotation-based validation with (functional) Spring Webflux. See this answer.
If you absolutely need annotation-based validation, you should know that you can keep using the traditional Spring MVC with Spring 5 (or non-functional Webflux).

Answer 3

I created GeneralValidator class which works javax.validation.Validator
#Component
#RequiredArgsConstructor
public class GeneralValidator {
private final Validator validator;
private <T> void validate(T obj) {
if (obj == null) {
throw new IllegalArgumentException();
}
Set<ConstraintViolation<T>> violations = this.validator.validate(obj);
if (violations != null && !violations.isEmpty()) {
throw new ConstraintViolationException(violations);
}
}
/**
* #param obj object we will validate
* #param next Publisher we will call if don't have any validation hits
*/
public <T> Mono<ServerResponse> validateAndNext(T obj, Mono<ServerResponse> next) {
try {
validate(obj);
return next;
} catch (IllegalArgumentException ex) {
return ServerResponse.badRequest()
.body(new ErrorResponse("Request body is empty or unable to deserialize"), ErrorResponse.class);
} catch (ConstraintViolationException ex) {
return ServerResponse.badRequest()
.body(new ValidationErrorResponse(
"Request body failed validation",
ex.getConstraintViolations()
.stream()
.map(v -> "Field '%s' has value %s but %s"
.formatted(v.getPropertyPath(), v.getInvalidValue(),v.getMessage()))
.collect(Collectors.toList())
), ValidationErrorResponse.class);
}
}
}
How to use it:
...
.POST("/", req -> req.bodyToMono(RequestObject.class)
.flatMap(r -> validator.validateAndNext(r,routeFunction.execute(r)))
)
...
routeFunction.execute:
public #NotNull Mono<ServerResponse> execute(RequestObject request) {
//handling body
}