使用JERSEY框架输出JSON，需捕获所有的HTTP错误，如404等，业务错误及其他未定义的错误，将这些错误输出JSON，而不是TOMCAT的错误。
JERSEY已和SPRING整合。
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee">
<display-name>Restful Web Application</display-name>
<servlet>
<servlet-name>jersey-serlvet</servlet-name>
<servlet-class>
com.sun.jersey.spi.spring.container.servlet.SpringServlet
</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>restfullapi.rest.service,restfullapi.common.provider,restful.web</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.api.json.POJOMappingFeature</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jersey-serlvet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/mvc-dispatcher-servlet.xml</param-value>
</context-param>
<!-- spring logback -->
<context-param>
<param-name>logbackConfigLocation</param-name>
<param-value>classpath:logback.xml</param-value>
</context-param>
<listener>
<listener-class>ch.qos.logback.ext.spring.web.LogbackConfigListener</listener-class>
</listener>
<context-param>
<param-name>webAppRootKey</param-name>
<param-value>restfull-api</param-value>
</context-param>
<welcome-file-list>
<welcome-file>/index.jsp</welcome-file>
</welcome-file-list>
</web-app>
AbstractBaseRestfulException.java
public abstract class AbstractBaseRestfulException extends Exception{
private static final long serialVersionUID = 6779508767332777451L;
public AbstractBaseRestfulException()
{
}
public AbstractBaseRestfulException(String message)
{
super(message);
}
public abstract String getErrcode();
public abstract void setErrcode(String errcode);
public abstract String getDescription();
public abstract void setDescription(String description);
}
AbstractBaseRestfulExceptionMapper.java
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.paul.common.exception.AbstractBaseRestfulException;
import com.paul.common.json.DefaultJsonResponse;
@Provider
public class AbstractBaseRestfulExceptionMapper
implements ExceptionMapper<AbstractBaseRestfulException>{
private Logger logger = LoggerFactory.getLogger(AbstractBaseRestfulExceptionMapper.
class);
public Response toResponse(AbstractBaseRestfulException exception) {
logger.error(exception.getMessage(), exception);
DefaultJsonResponse<Object> response =
new DefaultJsonResponse<Object>();
response.setDescription(exception.getDescription());
response.setErrcode(exception.getErrcode());
response.setResult(
null);
return Response.status(Status.BAD_REQUEST)
.entity(response)
.type(MediaType.APPLICATION_JSON + ";charset=utf-8")
.build();
}
}
OtherExceptionMapper.java
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import javax.ws.rs.core.Response.Status;
import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.paul.common.json.DefaultJsonResponse;
import com.paul.common.json.JsonResponseStatus;
@Provider
public class OtherExceptionMapper implements ExceptionMapper<Exception>{
private Logger logger = LoggerFactory.getLogger(OtherExceptionMapper.class);
public Response toResponse(Exception exception) {
logger.error(exception.getMessage(), exception);
DefaultJsonResponse<Object> response = new DefaultJsonResponse<Object>();
response.setDescription(JsonResponseStatus.OTHER_ERROR.getMessage() + exception.getMessage());
response.setErrcode(JsonResponseStatus.OTHER_ERROR.getCode());
response.setResult(null);
return Response.status(Status.BAD_REQUEST)
.entity(response)
.type(MediaType.APPLICATION_JSON + ";charset=utf-8")
.build();
}
}
WebApplicationExceptionMapper.java
import javax.ws.rs.WebApplicationException;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.paul.common.json.DefaultJsonResponse;
@Provider
public class WebApplicationExceptionMapper implements ExceptionMapper<WebApplicationException >{
private Logger logger = LoggerFactory.getLogger(WebApplicationExceptionMapper.class);
public Response toResponse(WebApplicationException exception) {
logger.error(exception.getMessage(), exception);
DefaultJsonResponse<Object> response = new DefaultJsonResponse<Object>();
response.setDescription(exception.getMessage());
response.setErrcode(String.valueOf(exception.getResponse().getStatus()));
response.setResult(null);
return Response.status(exception.getResponse().getStatus())
.entity(response)
.type(MediaType.APPLICATION_JSON + ";charset=utf-8")
.build();
}
}
Controller中无须再处理异常
import javax.ws.rs.DefaultValue;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import com.paul.common.json.DefaultJsonResponse;
import com.paul.common.json.JsonResponseStatus;
import com.paul.program.stbstart.valueobject.StbStart;
import com.paul.stbstart.valueobject.StbStartRequest;
import com.paul.restfullapi.rest.service.AdvertisementRestfulService;
@Path("/advertisement")
@Controller
public class AdvertisementRestfulController {
private Logger logger = LoggerFactory.getLogger(AdvertisementRestfulController.class);
@Autowired
AdvertisementRestfulService advertisementRestfulService;
@Path("/getAdvertisement")
@Produces({MediaType.APPLICATION_JSON + ";charset=utf-8"})
@GET
public DefaultJsonResponse<StbStart> getAdvertisement(
@DefaultValue("") @QueryParam("version")String version,
@QueryParam("token")String token) throws Exception
{
DefaultJsonResponse<StbStart> response = new DefaultJsonResponse<StbStart>();
StbStartRequest request = new StbStartRequest();
logger.info(version);
request.setVersion(version);
request.setToken(token);
StbStart result = advertisementRestfulService.findByVersion(request);
response.setResult(result);
response.setDescription(JsonResponseStatus.SUCCESS.getMessage());
response.setErrcode(JsonResponseStatus.SUCCESS.getCode());
logger.info("----------------");
// double i = 1/0;
return response;
}
}