CODEWITHSUNDEEP
javaspringspring-bootspring-validator
alexanoid
alexanoid

Reputation: 25770

Spring Boot 2 and method parameter validation

I created the following service interface:

import javax.validation.constraints.NotBlank;

import org.springframework.lang.NonNull;
import org.springframework.validation.annotation.Validated;

@Validated
public interface UserService {

    User create(@NonNull Long telegramId, @NotBlank String name, @NonNull Boolean isBot);

}

but the following invocation:

userService.create(telegramId, "Mike", null);

passes the @NotNull validation for isBot parameter. How to correctly configure Spring Boot and my service in order to take into account @NonNull annotation and prevent method execution in case of null parameter?

Upvotes: 4

Views: 16270

Answers (3)

walter33
walter33

Reputation: 1019

You need to make sure that @Validated annotation is used on 'class' which method arguments will need to be validated and Spring configuration need to be added

@Configuration
public class MethodValidationConfig {

    @Bean
    public MethodValidationPostProcessor methodValidationPostProcessor() {
        return new MethodValidationPostProcessor();
    }
}

Upvotes: 1

almac777
almac777

Reputation: 569

I played around with this problem for a bit.

Your code looks fine to me: Make sure that the implementation of UserService also has the validation annotations present.

Ensure that you allow Spring to create the Bean; it should work as you expect.

Example

Service Definition

import org.springframework.validation.annotation.Validated;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Validated
public interface GreetingService {
    String greet(@NotNull @NotBlank String greeting);
}

Service Implementation

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Service
public class HelloGreetingService implements GreetingService {

    public String greet(@NotNull @NotBlank String greeting) {
        return "hello " + greeting;
    }
}

Testcase

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;

import javax.validation.ConstraintViolationException;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;

@SpringBootTest
class HelloGreetingServiceTest {

    @Autowired
    private GreetingService helloGreetingService;

    @Test
    void whenGreetWithStringInput_shouldDisplayGreeting() {
        String input = "john doe";
        assertEquals("hello john doe", helloGreetingService.greet(input));
    }

    @Test
    void whenGreetWithNullInput_shouldThrowException() {
        assertThrows(ConstraintViolationException.class, () -> helloGreetingService.greet(null));
    }

    @Test
    void whenGreetWithBlankInput_shouldThrowException() {
        assertThrows(ConstraintViolationException.class, () -> helloGreetingService.greet(""));
    }

}

Testcases are green for me.

Github: https://github.com/almac777/spring-validation-playground

Source: https://www.baeldung.com/javax-validation-method-constraints

HTH!

Upvotes: 7

Pranay
Pranay

Reputation: 69

Use the same thing in Implementation class instead interface. Also can write one global exception like:

@Order(Ordered.HIGHEST_PRECEDENCE)
@RestControllerAdvice
public class GlobalRestException extends ResponseEntityExceptionHandler {
...
...

/**
     * Handle MethodArgumentNotValidException. Triggered when an object fails @Valid
     * validation.
     *
     * @param ex      the MethodArgumentNotValidException that is thrown when @Valid
     *                validation fails
     * @param headers HttpHeaders
     * @param status  HttpStatus
     * @param request WebRequest
     * @return the ApiException object
     */
    @Override
    protected ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException ex,
            HttpHeaders headers, HttpStatus status, WebRequest request) {
        Error apiError = new Error(BAD_REQUEST);
        apiError.setMessage("Validation error");
        apiError.addValidationErrors(ex.getBindingResult().getFieldErrors());
        apiError.addValidationError(ex.getBindingResult().getGlobalErrors());
        return buildResponseEntity(apiError);
    }
}

There are more method that can be override to handle different kind of exception like :

/**
 * Handles javax.validation.ConstraintViolationException. Thrown when @Validated
 * fails.
 *
 * @param ex the ConstraintViolationException
 * @return the ApiException object
 */
@ExceptionHandler(javax.validation.ConstraintViolationException.class)
protected ResponseEntity<Object> handleConstraintViolation(javax.validation.ConstraintViolationException ex) {
    Error apiError = new Error(BAD_REQUEST);
    apiError.setMessage("Validation error");
    apiError.addValidationErrors(ex.getConstraintViolations());
    return buildResponseEntity(apiError);
}

Upvotes: 0

Related Questions