Forem: Zer

Spring Boot REST Basics : How to validate your request body

Zer — Sat, 23 Sep 2023 23:57:14 +0000

Overview

In software development, it is important to do some validation for security purposes and also lessen the unexpected errors, but it takes a lot of hours just to implement specific validation methods. In this post, I will share the easiest way on how to validate your request body in Spring Boot.

Let's get started

Add dependency

Add the spring boot starter validation to your project. You can do this by adding the code below to your pom.xml.

<dependency>             
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Update your controller

Let's say you have a login API that authenticates the user. All you need to do is add the @Valid annotation to your request body. For this example I added the @Valid annotation to my userLoginRequestModel. This signals Spring Boot to do some validation of the model.

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    IUserService userService;

    @PostMapping("/login")
    public UserLoginResponseModel login(@Valid @RequestBody UserLoginRequestModel userLoginRequestModel) {
        return userService.login(userLoginRequestModel);
    }
}

Update your model

In your model, all you need to add is the specific validation annotation that we want to implement. For this example, I used the @NotEmpty annotation to make sure the username and password is required. I also added the message parameter.

public class UserLoginRequestModel {
    @NotEmpty(message = "Username is required.")
    private String username;

    @NotEmpty(message = "Password is required.")
    private String password;

    //...
}

There are a lot of validations you can use, such as @Min and @Max, make sure to check the documentation.

Update your exception handler

To display the validation results, It is better to handle the error in your exception handler method.

@ResponseStatus(HttpStatus.BAD_REQUEST)
@ExceptionHandler(MethodArgumentNotValidException.class)
public Map<String, String> handleValidationExceptions(
  MethodArgumentNotValidException ex) {
    Map<String, String> errors = new HashMap<>();
    ex.getBindingResult().getAllErrors().forEach((error) -> {
        String fieldName = ((FieldError) error).getField();
        String errorMessage = error.getDefaultMessage();
        errors.put(fieldName, errorMessage);
    });
    return errors;
}

Test

Now, try to test the validation in your API. The result should return something like this.

{
  "Username is required.",
  "Password is required."
}

Conclusion

Spring Boot makes it way easier to do validation just by using the @Validannotation. No need to implement validation methods that sometimes may not work. So make sure to try this out.

Spring Boot REST Basics : Create Custom Exceptions with @ControllerAdvice annotation

Zer — Wed, 20 Sep 2023 14:03:34 +0000

Overview

In this post, I will share my experience in creating custom exceptions with @ControllerAdvice annotation.

Prerequisites

Basic Spring boot knowledge
Basic REST API / Web Dev knowledge

Custom Exceptions

In Java, we can create our own type of exception that is tailored to our business logic. Custom exceptions give us the flexibility to add more information to our exceptions and to handle errors in a different way.

ControllerAdvice annotation

The @ControllerAdvice is an annotation that allows us to handle exceptions globally in one file. So we can just create one class and define the actions or methods that will be triggered every time an exception is thrown.

Let's get started

In this example, I want to create a custom exception that will handle login errors and return a 401 Unauthorized Error HTTP response to the client.

1. Create your own custom exception

In creating your own custom exception, you have to make sure that your custom exception class is a child of Exception class (checked) or RuntimeException class (unchecked).

I created my own custom exception called CustomInvalidLoginException.java and extend the RuntimeException class.

public class CustomInvalidLoginException extends RuntimeException {
    public CustomInvalidLoginException() {
        super("INVALID LOGIN");
    }

    public CustomInvalidLoginException(String message) {
        super(message);
    }
}

2. Create your own global exception handler

In my project, I created a class called GlobalExceptionHandler.java and annotate it with @ControllerAdvice to let Spring boot know this is a global exception handler class.

Inside the class, I created a method that will handle the invalid login exception and annotate it with @ExceptionHandler(CustomInvalidLoginException.class).

@ControllerAdvice
public class GlobalExceptionHandler {
    @ExceptionHandler(CustomInvalidLoginException.class)
    public ResponseEntity<Object> handleInvalidLogin() {
        return new ResponseEntity<>("INVALID LOGIN", new HttpHeaders(), HttpStatus.UNAUTHORIZED);
    }
}

For this exception, I will just return 401 HTTP status to the user.

3. Test

Lastly, all you need to do is throw the custom error in your business logic.

...
else {
     throw new CustomInvalidLoginException();
}
...

Conclusion

Spring boot makes it easier for us to manage exceptions just by using these annotations: @ControllerAdvice and @ExceptionHandler. In my opinion, this improves the readability and maintainability of your application because you can handle your exceptions in just one file!