Spring Boot Exception Handling
Question: Why we should use Exception Handling?
Answer:
- We should present error or exception messages in user understandable manner, which will help to resolve these errors easily.
- We should provide proper response status.
- We should not present sensitive information in the response.
org.springframework.web.bind.annotation
Annotation Type ControllerAdvice
@Target(value=TYPE)
@Retention(value=RUNTIME)
@Documented
@Component
public @interface ControllerAdvice
Specialization of @Component for classes that declare @ExceptionHandler, @InitBinder, or @ModelAttribute methods to be shared across multiple @Controller classes.
Classes with @ControllerAdvice can be declared explicitly as Spring beans or auto-detected via classpath scanning. All such beans are sorted via AnnotationAwareOrderComparator, i.e. based on @Order and Ordered, and applied in that order at runtime.
For handling exceptions the first @ExceptionHandler to match the exception is used. For model attributes and InitBinder initialization, @ModelAttribute and @InitBinder methods will also follow @ControllerAdvice order.
By default the methods in an @ControllerAdvice apply globally to all Controllers. Use selectors annotations(), basePackageClasses(), and basePackages() (or its alias value()) to define a more narrow subset of targeted Controllers.
If multiple selectors are declared, OR logic is applied, meaning selected Controllers should match
at least one selector. Note that selector checks are performed at runtime and so adding many selectors may negatively impact performance and add complexity.
Since:
3.2
Spring introduces @ControllerAdvice annotation which allows you to write global exception handling code that can be applied to a all controllers or depending on controllers to a chosen package or even a specific annotation.
We can handle global exception using @ControllerAdvice and @ExceptionHandler.
@ControllerAdvice annotation will be applied to all classes that use the @Controller annotation (which extends to classes using @RestController).
We can use @ControllerAdvice in below formats:
- @ControllerAdvice("com.gaurav.springboot")
- @ControllerAdvice(value = "com.gaurav.springboot")
- @ControllerAdvice(basePackages = "com.gaurav.springboot")
We have another way to define a specific package using basePackageClasses property, which will enable @ControllerAdvice to all controllers inside that package where that class resides.
@ControllerAdvice(basePackageClasses = Application.class)
To apply to specific classes use assignableTypes.
@ControllerAdvice(assignableTypes = UserController.class)
Spring Boot default Exception Handling
Suppose a resource is not available then the response thrown will be look alike below:
when we fire a request which does not exist like: http://localhost:8080/users/test
Then the response presented by Spring boot is like below
{
"timestamp": "2018-09-07T05:54:32.828+0000",
"status": 404,
"error": "Not Found",
"message": "No message available",
"path": "/users/test"
}
Demo example to configure Global Exception Handling in Spring Boot
1. pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.gaurav.springboot</groupId>
<artifactId>GlobalExceptionHandlingInSpringBoot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>Global-Exception-Handling-In-SpringBoot</name>
<description>GlobalExceptionHandlingInSpringBoot - Sample Project</description>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.0.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-hateoas</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<scope>runtime</scope>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.fasterxml.jackson.datatype</groupId>
<artifactId>jackson-datatype-jsr310</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
<repositories>
<repository>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</repository>
<repository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</repository>
</repositories>
<id>spring-snapshots</id>
<name>Spring Snapshots</name>
<url>https://repo.spring.io/snapshot</url>
<snapshots>
<enabled>true</enabled>
</snapshots>
</pluginRepository>
<id>spring-milestones</id>
<name>Spring Milestones</name>
<url>https://repo.spring.io/milestone</url>
<snapshots>
<enabled>false</enabled>
</snapshots>
</pluginRepository>
</pluginRepositories>
</project>
2. User.java
package com.gaurav.springboot.bean;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
@Entity
@Table(name = "user")
public class User {
public User() {
}
public User(int id, String firstName, String lastName, String gender, int age) {
super();
this.id = id;
this.firstName = firstName;
this.lastName = lastName;
this.gender = gender;
this.age = age;
}
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private long id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "gender")
private String gender;
@Column(name = "age")
private int age;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName(String firstName) {
this.firstName = firstName;
}
public String getLastName() {
return lastName;
}
public void setLastName(String lastName) {
this.lastName = lastName;
}
public String getGender() {
return gender;
}
public void setGender(String gender) {
this.gender = gender;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (int) (id ^ (id >>> 32));
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
User other = (User) obj;
if (id != other.id)
return false;
return true;
}
}
3. ErrorDetails.java
package com.gaurav.springboot.exception;
import java.util.Date;
import org.springframework.http.HttpStatus;
import com.fasterxml.jackson.annotation.JsonFormat;
public class ErrorDetails {
@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "dd MMM yyyy hh:mm:ss aaa")
private Date timestamp;
private String message;
private String description;
public Date getTimestamp() {
return timestamp;
}
public String getMessage() {
return message;
}
public String getDescription() {
return description;
}
public ErrorDetails(Date timestamp, String message, String description) {
super();
this.timestamp = timestamp;
this.message = message;
this.description = description;
}
}
4. UserNotFoundException.java
package com.gaurav.springboot.exception;
import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.ResponseStatus;
@ResponseStatus(HttpStatus.NOT_FOUND)
public class UserNotFoundException extends RuntimeException {
/**
*
*/
private static final long serialVersionUID = -8403805750611410023L;
public UserNotFoundException(String exception) {
super(exception);
}
}
5. CustomizedResponseEntityExceptionHandler.java
package com.gaurav.springboot.exception;
import java.util.Date;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;
@ControllerAdvice
@RestController
public class CustomizedResponseEntityExceptionHandler extends ResponseEntityExceptionHandler {
@ExceptionHandler(Exception.class)
public final ResponseEntity<ErrorDetails> handleExceptionsGlobally(Exception ex, WebRequest request) {
ErrorDetails exceptionResponse = new ErrorDetails(new Date(), ex.getMessage(),
request.getDescription(false));
return new ResponseEntity<>(exceptionResponse, HttpStatus.INTERNAL_SERVER_ERROR);
}
@ExceptionHandler(UserNotFoundException.class)
public final ResponseEntity<ErrorDetails> handleUserNotFoundException(UserNotFoundException ex, WebRequest request) {
ErrorDetails exceptionResponse = new ErrorDetails(new Date(), ex.getMessage(),
request.getDescription(false));
return new ResponseEntity<>(exceptionResponse, HttpStatus.NOT_FOUND);
}
}
6. UserRepository.java
package com.gaurav.springboot.repository;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.gaurav.springboot.bean.User;
@Repository
public interface UserRepository extends JpaRepository<User, Long>{
}
7. UserController.java
package com.gaurav.springboot.controller;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.linkTo;
import static org.springframework.hateoas.mvc.ControllerLinkBuilder.methodOn;
import java.net.URI;
import java.util.List;
import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.hateoas.Resource;
import org.springframework.hateoas.mvc.ControllerLinkBuilder;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.servlet.support.ServletUriComponentsBuilder;
import com.gaurav.springboot.bean.User;
import com.gaurav.springboot.exception.UserNotFoundException;
import com.gaurav.springboot.repository.UserRepository;
@RestController
@RequestMapping(value = { "/users" })
public class UserController {
@Autowired
private UserRepository userRepository;
/**
* To create a user
*
* @param user
* @return
*/
@PostMapping("/new")
public ResponseEntity<Object> createUser(@RequestBody User user) {
User savedUser = userRepository.save(user);
URI location = ServletUriComponentsBuilder.fromCurrentRequest().path("/{id}")
.buildAndExpand(savedUser.getId()).toUri();
return ResponseEntity.created(location).build();
}
/**
* To retrieve all users
*
* @return
*/
@GetMapping("/get/all")
public List<User> getAllUsers() {
return userRepository.findAll();
}
/**
* To retrieve specific users
*
* @param id
* @return
*/
@GetMapping("/get/{id}")
public Resource<User> getUser(@PathVariable long id) {
Optional<User> user = userRepository.findById(id);
if (!user.isPresent())
throw new UserNotFoundException("id-" + id+" is not available");
Resource<User> resource = new Resource<User>(user.get());
ControllerLinkBuilder linkTo = linkTo(methodOn(this.getClass()).getAllUsers());
resource.add(linkTo.withRel("get-all-users"));
return resource;
}
/**
* To update specific user
*
* @param user
* @param id
* @return
*/
@PutMapping("/update/{id}")
public ResponseEntity<Object> updateUser(@RequestBody User user, @PathVariable long id) {
Optional<User> userDet = userRepository.findById(id);
if (!userDet.isPresent())
return ResponseEntity.notFound().build();
user.setId(id);
userRepository.save(user);
// return ResponseEntity.noContent().build();
return ResponseEntity.ok().build();
}
/**
* To Delete specific user
*
* @param id
*/
@DeleteMapping("/delete/{id}")
public void deleteUser(@PathVariable long id) {
userRepository.deleteById(id);
}
}
8. GlobalExceptionHandlingApplication.java
package com.gaurav.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class GlobalExceptionHandlingApplication {
public static void main(String[] args) {
SpringApplication.run(GlobalExceptionHandlingApplication.class, args);
}
}
9. application.properties
logging.level.org.springframework.web=INFO
spring.datasource.driver: com.mysql.jdbc.Driver
spring.datasource.url: jdbc:mysql://localhost:3306/experimentdemo
spring.datasource.username:root
spring.datasource.password:root
spring.jpa.hibernate.dialect:org.hibernate.dialect.MySQL5Dialect
spring.jpa.show-sql:true
spring.jpa.hibernate.ddl-auto :update
spring.jpa.entitymanager.packagesToScan:com.gaurav.springboot
Get All Users: http://localhost:8080/users/get/all
Get Specific User: http://localhost:8080/users/get/1
POST(Create a new User):http://localhost:8080/users/new
Check the Created User in DB:
PUT(Updated the User): http://localhost:8080/users/update/11
Delete(Delete User): http://localhost:8080/users/delete/11
