Jersey ExceptionMapper (user defined exceptions) in RESTful web Service (java/ example)

  • In this post, we will discuss Jersey (RESTFul Service) Exception mapper example for user defined or custom exceptions.
  • We have already discussed, usage of standard exceptions in ExceptionMapper – RESTFul web Service.
  • We will create couple of user defined exceptions
    1. MyNullPointerException (extending NullPointerException).
    2. MyArithmeticException (extending ArithmeticException).
  • We will define following exceptionmappers to catch application & user defined exceptions.
    1. ApplicationExceptionMapper will catch all application exceptions.
    2. ArithmeticExceptionMapper will catch all sort of Arithmetic (or MyArithmeticException)  exceptions.
    3. MyNullPointerExceptionMapper will catch NullPointer exceptions (or MyNullPointerException).

Jersey maven dependency

<dependency>
 <groupId>org.glassfish.jersey.containers</groupId>
 <artifactId>jersey-container-servlet</artifactId>
 <version>2.23.2</version>
</dependency>

Web.xml – jersey RESTful web Service

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
         id="WebApp_ID" version="3.0">

  <display-name>REST Web Application using Jersey framework</display-name>

  <servlet>
    <servlet-name>rest-server</servlet-name>
    <servlet-class>org.glassfish.jersey.servlet.ServletContainer</servlet-class>
    <init-param>
      <param-name>jersey.config.server.provider.packages</param-name>
      <param-value>org.learn</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
    <servlet-name>rest-server</servlet-name>
    <url-pattern>/*</url-pattern>
  </servlet-mapping>

</web-app>

Program – Jersey ExceptionMapper in RESTFul Web Service (User defined exception)

1.) MyNullPointerException class (Custom exception):

  • MyNullPointerException class extends NullPointerException class.
package org.learn.exception;

public class MyNullPointerException extends NullPointerException {

 private static final long serialVersionUID = 5627096569547521249L;

 public MyNullPointerException(String s) {
  super(s);
 }
}

2.) MyArithmeticException class (Custom exception)  :

  • MyArithmeticException class extends ArithmeticException class.
package org.learn.exception;

public class MyArithmeticException extends ArithmeticException {
 
 private static final long serialVersionUID = 652325545058196579L;

 public MyArithmeticException(String s) {
        super(s);
    }
}

3.) ApplicationExceptionMapper class:

  • ApplicationExceptionMapper will catch exceptions extending from Exception class.
  • Any uncaught exception will be caught by ApplicaitonExceptionMapper.
  • As we have specialized the exception mappers to catch NullPointer & Arithmetic exception, so
    • NullPointerException will be caught by MyNullPointerException.
    • ArithmeticException will be caught by MyArithmeticException
package org.learn.exceptionmapper;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

@Provider
public class ApplicationExceptionMapper implements ExceptionMapper<Exception> {

    public Response toResponse(Exception e) {     
     
        return Response
          .status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode())
          .type(MediaType.TEXT_PLAIN)
          .entity("Catching in ApplicaitonExceptionMapper : " + e.getMessage())
          .build();
    }
}

4.) ArithmeticExceptionMapper class:

  • ArithmeticExceptionMapper will catch all Arithmetic exceptions.
  • Our user defined exception MyArithmeticException will also by caught of ArithmeticException mapper only.
package org.learn.exceptionmapper;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

@Provider
public class ArithmeticExceptionMapper implements ExceptionMapper<ArithmeticException> {

    @Override
    public Response toResponse(ArithmeticException e) {
     
     return Response
                .status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode())
                .type(MediaType.TEXT_PLAIN)
                .entity("Catching in ArithmeticExceptionMapper : "+ e.getMessage())
                .build();
    }
}

5.) MyNullPointerExceptionMapper class:

  • MyNullPointerExceptionMapper will catch exceptions of type MyNullPointerException.
  • When MyNullPointerException is thrown from our resource class, It will be caught in MyNullPointerExceptionMapper class.
package org.learn.exceptionmapper;

import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;

import org.learn.exception.MyNullPointerException;

@Provider
public class MyNullPointerExceptionMapper implements ExceptionMapper<MyNullPointerException> {

    @Override
    public Response toResponse(MyNullPointerException e) {
          
        return Response
                .status(Response.Status.INTERNAL_SERVER_ERROR.getStatusCode())
                .type(MediaType.TEXT_PLAIN)
                .entity("Catching in MyNullPointerExceptionMapper : "+ e.getMessage())
                .build();
    }
}

6.) Resource class (REST resource):

Resource class is our REST resource, where we have exposed the following APIs.

  1. /outofbound: In this api, we are accessing the array beyond its bounds so its length, so StringIndexOutOfBoundsException exception will be thrown.
    • As we have not created any specific exception mapper, so It will be caught in ApplicationExceptionMapper class.
  2. /nullp: We are throwing null pointer exception here. It will be caught in MyNullPointerExceptionMapper.
  3. /dividebyzero: We are throwing MyArithmeticException from this resource,  It will be caught in ArithmeticExceptionMapper.

package org.learn.resource;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.core.Response;

import org.learn.exception.MyArithmeticException;
import org.learn.exception.MyNullPointerException;


@Path("/exp")
public class Resource {

 @GET 
 @Path("outofbound")
 public Response indexOutOfBoundException() {
  String indexOutOfBound = "hello";
  
  /*
   Any code come here and suppose following exception raised
   */
  
  //It will raise index out of bound exception
  //It will be caught in ApplicationExceptionMapper
  indexOutOfBound.charAt(indexOutOfBound.length());
  return  Response.status(Response.Status.OK).build();
 }
 @GET 
 @Path("nullp")
 public Response nullPointerException() {
  /*
   
   Any code come here and suppose following exception raised
   
   */
  //It will be caught in MyNullPointerExceptionMapper
  throw new MyNullPointerException("Throwing my null pointer exception");
 }
 
 @GET 
 @Path("dividebyzero")
 public Response divideByZero() {  
  /*
   
   Any code come here and suppose following exception raised
   
   
   * */
  //Raising divide by zero exception 
  int divByZero  = 0;
  try {
   divByZero = 100 / 0;
  } catch(ArithmeticException exp) {
   //It will be caught in yArithmeticExceptionMapper
   throw new MyArithmeticException("Throwing MyArithmeticException "+exp.getMessage());
  }
  System.out.println(divByZero);
  return Response.status(Response.Status.OK).build();
 } 
}

Output – Jersey ExceptionMapper in RESTFul Web Service (User defined exception)

  • We have deployed our application at context root.
  • As, we have three method defined in our resource class, we have capture their request response as follows:
Request : http://localhost:9095/exp/outofbound
Response : Catching in ApplicaitonExceptionMapper : String index out of range: 5
Request : http://localhost:9095/exp/nullp
Response : Catching in MyNullPointerExceptionMapper : Throwing my null pointer exception
Request : http://localhost:9095/exp/dividebyzero
Response : Catching in ArithmeticExceptionMapper : Throwing MyArithmeticException / by zero.

Download Code – Jersey ExceptionMapper in RESTFul Web Service

 

Scroll to Top