- 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
- MyNullPointerException (extending NullPointerException).
- MyArithmeticException (extending ArithmeticException).
- We will define following exceptionmappers to catch application & user defined exceptions.
- ApplicationExceptionMapper will catch all application exceptions.
- ArithmeticExceptionMapper will catch all sort of Arithmetic (or MyArithmeticException) exceptions.
- 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.
- /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.
- /nullp: We are throwing null pointer exception here. It will be caught in MyNullPointerExceptionMapper.
- /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
