Points To Remember

How to do Exception Handling in Rest Application

• @ControllerAdvice tells your spring application that this class will do the exception handling for your application.
• @RestController will make it a controller and let this class render the response.
• Use @ExceptionHandler annotation to define the class of Exception it will catch. (A Base class will catch all the Inherited and extended classes)
• You can set the response status for exception using @ResponseStatus annotation.

HomeController.class

GlobalExceptionHandler.class

• handleBaseException(BaseException e) ::  will catch all the exceptions for classes BaseException, CustomException1 and CustomException2.
• handleException(Exception e) ::  will handle all the exceptions that are childs of Exception class.

Way 2 : Controller Level Exception handling using @ExceptionHandler

Points To Remember

• You can handle all types of runtime exceptions and custom exceptions using @ExceptionHandler annotation. 
• You just need to define the class to the annotation to handle exceptions of that class.

Spring MVC handle Exceptions in Controller

• HomeController wih three actions 
• throw1 - throws Custom exception
• throw2 - throws Custom exception
• throw3 - throws Runtime exception

Home Controller

package com.ekiras.controller;

import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;

import com.ekiras.exception.MyException;
import com.ekiras.exception.MyGlobalException;

@Controller
public class HomeController {
 
 private static final Logger logger = LoggerFactory.getLogger(HomeController.class);
 
 @RequestMapping(value = "/", method = RequestMethod.GET)
 public String home(Locale locale, Model model) {
  logger.info("Welcome home! The client locale is {}.", locale);
  
  Date date = new Date();
  DateFormat dateFormat = DateFormat.getDateTimeInstance(DateFormat.LONG, DateFormat.LONG, locale);
  
  String formattedDate = dateFormat.format(date);
  
  model.addAttribute("serverTime", formattedDate );
  
  return "home";
 }
 
 @RequestMapping(value="/throw1")
 public String throw1(){
  throw new MyException();
 }
 

 @RequestMapping(value="/throw2")
 public String throw2(){
  throw new MyGlobalException();
 }

 @RequestMapping(value="/throw3")
 public String throw3(){
  throw new RuntimeException();
 }
 

 
 @ResponseBody
 @ExceptionHandler(MyException.class)
 public String myException(MyException exception){
  return "exception caught message="+ exception.getMessage();
 }

 @ResponseBody
 @ExceptionHandler(MyGlobalException.class)
 public String myGlobalException(MyGlobalException exception){
  return "exception caught message="+ exception.getMessage();
 }
 
}

The above code will not catch any  Exception of class RuntimeException.  If you want to catch it you can add another method like following to your code.

 @ResponseBody
 @ExceptionHandler(Exception.class)
 public String myGlobalException(Exception exception){
  return "exception caught message="+ exception.getMessage();
 }

Now, after adding the above code to your controller. Your controller will handle all types of Exceptions.

• First create a ParentException class and this class should either extend Exception class or RuntimeException class. 
• All the nested Exceptions will extend the ParentException and thus will lie in a hierarchy.

Scenario

Creating Nested Custom Exceptions 

1. QuixException
2. InvalidQuestionIdException
3. InvalidAnswerException

class QuizException extends Exception {

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

}

class InvalidQuestionIdException extends QuizException {

 public InvalidQuestionIdException() {
  super("invalid question id provided");
 }

}

class InvalidAnswerException extends QuizException {

 public InvalidAnswerException() {
  super("invalid answer is provided");
 }

}
class Question {
 public String getQuestion(Integer id) throws InvalidQuestionIdException{
  switch (id) {
  case 1:
   return "This is question 1";
  case 2:
   return "This is question 2";
  default:
   throw new InvalidQuestionIdException();
  }
 }

}


class Answer{
 public String getAnswer(Integer ans)throws InvalidAnswerException{
  switch(ans){
  case 1:
   return "right answer";
  case 2:
   return "wrong answer";
  default:
   throw new InvalidAnswerException();
  }
  }
 }
 
 


public class Test {
 public static void main(String args[]) {
  try {
   System.out.println(new Question().getQuestion(1));
   System.out.println(new Question().getQuestion(5));
  } catch (QuizException e) {
   e.printStackTrace();
  }
  try {
   System.out.println(new Answer().getAnswer(1));
   System.out.println(new Answer().getAnswer(3));
  } catch (QuizException e) {
   e.printStackTrace();
  }
 }

}

Points To Remember

• All the custom Exceptions must implement the Exception class or any of its subclass.
• There are four types of Constructors that you can use while defining your Custom Exception.

Ex 1 : Basic Custom Exception

class CustomException extends Exception {

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

}

public class Test {
 public static void main(String args[]) {
  try {
   throw new CustomException("Throwing Custom Exception");
  } catch (CustomException e) {
   e.printStackTrace();
  }
  try {
   throw new CustomException(" ThrowingAnother Custom Exception");
  } catch (CustomException e) {
   e.printStackTrace();
  }
 }

}

Ex 2 : Custom Exception with same Message

class CustomException extends Exception {

 public CustomException() {
  super("Custom Exception has Occured");
 }

}

public class Test {
 public static void main(String args[]) {
  try {
   throw new CustomException();
  } catch (CustomException e) {
   e.printStackTrace();
  }
  try {
   throw new CustomException();
  } catch (CustomException e) {
   e.printStackTrace();
  }
 }

}

Points To Remember

1. You need to first add the errors in the web.xml and redirect them to a url.
2. Then you need to map these url to controller to handle them and take necessary actions. 
3. You can either handle exceptions in your controllers as explained in the link.

Custom Error Pages

 <error-page>
  <error-code>400</error-code>
  <location>/400</location>
 </error-page>
 
 <error-page>
  <error-code>404</error-code>
  <location>/404</location>
 </error-page>
 
 <error-page>
  <error-code>500</error-code>
  <location>/500.jsp</location>
 </error-page>

package com.ekiras.util;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class HTTPErrorHandler{

 String path = "/error";
 
 @RequestMapping(value="/400")
 public String error400(){
  System.out.println("custom error handler");
  return path+"/400";
 }
 
 @RequestMapping(value="/404")
 public String error404(){
  System.out.println("custom error handler");
  return path+"/404";
 }
 
 @RequestMapping(value="/500")
 public String error500(){
  System.out.println("custom error handler");
  return path+"/500";
 }
 
 
}