{"id":18948,"date":"2013-11-18T10:00:00","date_gmt":"2013-11-18T08:00:00","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=18948"},"modified":"2013-11-17T22:29:20","modified_gmt":"2013-11-17T20:29:20","slug":"controlleradvice-improvements-in-spring-4","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2013\/11\/controlleradvice-improvements-in-spring-4.html","title":{"rendered":"@ControllerAdvice improvements in Spring 4"},"content":{"rendered":"

Among many new features in Spring 4 I found @ControllerAdvice improvements. @ControllerAdvice is a specialization of a @Component that is used to define @ExceptionHandler, @InitBinder, and @ModelAttribute methods that apply to all @RequestMapping methods. Prior to Spring 4, @ControllerAdvice assisted all controllers in the same Dispatcher Servlet. With Spring 4 it has changed. As of Spring 4 @ControllerAdvice may be configured to support defined subset of controllers, whereas the default behavior can be still utilized.<\/p>\n

<\/a><\/p>\n

@ControllerAdvice assisting all controllers<\/h2>\n

Let’s assume we want to create an error handler that will print application errors to the user. Let’s assume this is a basic Spring MVC application with Thymeleaf as a view engine and we have an ArticleController with the following @RequestMapping method:<\/p>\n

package pl.codeleak.t.articles;\r\n\r\nimport org.springframework.stereotype.Controller;\r\nimport org.springframework.web.bind.annotation.PathVariable;\r\nimport org.springframework.web.bind.annotation.RequestMapping;\r\n\r\n@Controller\r\n@RequestMapping(\"article\")\r\nclass ArticleController {\r\n\r\n    @RequestMapping(\"{articleId}\")\r\n    String getArticle(@PathVariable Long articleId) {\r\n        throw new IllegalArgumentException(\"Getting article problem.\");\r\n    }\r\n}<\/pre>\n
Our method throws an imaginary exception, as we can see. Let’s now create an exception handler using @ControllerAdvice. (this is not only possible method in Spring to deal with exceptions).<\/p>\n
package pl.codeleak.t.support.web.error;\r\n\r\nimport com.google.common.base.Throwables;\r\nimport org.springframework.web.bind.annotation.ControllerAdvice;\r\nimport org.springframework.web.bind.annotation.ExceptionHandler;\r\nimport org.springframework.web.context.request.WebRequest;\r\nimport org.springframework.web.servlet.ModelAndView;\r\n\r\n@ControllerAdvice\r\nclass ExceptionHandlerAdvice {\r\n\r\n @ExceptionHandler(value = Exception.class)\r\n public ModelAndView exception(Exception exception, WebRequest request) {\r\n  ModelAndView modelAndView = new ModelAndView(\"error\/general\");\r\n  modelAndView.addObject(\"errorMessage\", Throwables.getRootCause(exception));\r\n  return modelAndView;\r\n }\r\n}<\/pre>\n
The class is not public, as it does not to be. We added @ExceptionHandler method that will handle all types of Exceptions and it will return the “error\/general” view:<\/p>\n
<!DOCTYPE html>\r\n<html xmlns=\"http:\/\/www.w3.org\/1999\/xhtml\" xmlns:th=\"http:\/\/www.thymeleaf.org\">\r\n<head>\r\n    <title>Error page<\/title>\r\n    <meta http-equiv=\"Content-Type\" content=\"text\/html; charset=UTF-8\"\/>\r\n    <link href=\"..\/..\/..\/resources\/css\/bootstrap.min.css\" rel=\"stylesheet\" media=\"screen\" th:href=\"@{\/resources\/css\/bootstrap.min.css}\"\/>\r\n    <link href=\"..\/..\/..\/resources\/css\/core.css\" rel=\"stylesheet\" media=\"screen\" th:href=\"@{\/resources\/css\/core.css}\"\/>\r\n<\/head>\r\n<body>\r\n<div class=\"container\" th:fragment=\"content\">\r\n    <div th:replace=\"fragments\/alert :: alert (type='danger', message=${errorMessage})\"> <\/div>\r\n<\/div>\r\n<\/body>\r\n<\/html><\/pre>\n
To test the solution we can either run the server or (preferably) create a test with Spring MVC Test module. Thanks to the fact that we use Thymeleaf, we can verify the rendered view:
 
<\/div> <\/div><\/p>\n
@RunWith(SpringJUnit4ClassRunner.class)\r\n@WebAppConfiguration\r\n@ContextConfiguration(classes = {RootConfig.class, WebMvcConfig.class})\r\n@ActiveProfiles(\"test\")\r\npublic class ErrorHandlingIntegrationTest {\r\n\r\n    @Autowired\r\n    private WebApplicationContext wac;\r\n\r\n    private MockMvc mockMvc;\r\n\r\n    @Before\r\n    public void before() {\r\n        this.mockMvc = webAppContextSetup(this.wac).build();\r\n    }\r\n\r\n    @Test\r\n    public void shouldReturnErrorView() throws Exception {\r\n        mockMvc.perform(get(\"\/article\/1\"))\r\n                .andDo(print())\r\n                .andExpect(content().contentType(\"text\/html;charset=ISO-8859-1\"))\r\n                .andExpect(content().string(containsString(\"java.lang.IllegalArgumentException: Getting article problem.\")));\r\n    }\r\n}<\/pre>\n
We expect the content type is text\/html and the view contains the HTML fragment with an error message. Not really user friendly, though. But the test is green.<\/p>\n
Using the above solution we provide a general mechanism for handling errors of all our controllers. As mentioned earlier, we can do much more with @ControllerAdvice:. E.g:<\/p>\n
@ControllerAdvice\r\nclass Advice {\r\n\r\n    @ModelAttribute\r\n    public void addAttributes(Model model) {\r\n        model.addAttribute(\"attr1\", \"value1\");\r\n        model.addAttribute(\"attr2\", \"value2\");\r\n    }\r\n\r\n    @InitBinder\r\n    public void initBinder(WebDataBinder webDataBinder) {\r\n        webDataBinder.setBindEmptyMultipartFiles(false);\r\n    }\r\n}<\/pre>\n
@ControllerAdvice assisting selected subset of controllers<\/h2>\n
As of Spring 4, @ControllerAdvice can be customized through annotations(), basePackageClasses(), basePackages() methods to select a subset of controllers to assist. I will demonstrate a simple case how to utilize this new feature.<\/p>\n
Let’s assume we want to add an API to expose articles via JSON. So we can define a new controller like this:<\/p>\n
@Controller\r\n@RequestMapping(\"\/api\/article\")\r\nclass ArticleApiController {\r\n\r\n    @RequestMapping(value = \"{articleId}\", produces = \"application\/json\")\r\n    @ResponseStatus(value = HttpStatus.OK)\r\n    @ResponseBody\r\n    Article getArticle(@PathVariable Long articleId) {\r\n        throw new IllegalArgumentException(\"[API] Getting article problem.\");\r\n    }\r\n}<\/pre>\n
Our controller is not very sophisticated. It returns an Article as a response body, as @ResponseBody annotation indicates. Of course, we want to deal with exceptions. And we don’t want to return an error as text\/html but as application\/json. Let’s create a test then:<\/p>\n
@RunWith(SpringJUnit4ClassRunner.class)\r\n@WebAppConfiguration\r\n@ContextConfiguration(classes = {RootConfig.class, WebMvcConfig.class})\r\n@ActiveProfiles(\"test\")\r\npublic class ErrorHandlingIntegrationTest {\r\n\r\n    @Autowired\r\n    private WebApplicationContext wac;\r\n\r\n    private MockMvc mockMvc;\r\n\r\n    @Before\r\n    public void before() {\r\n        this.mockMvc = webAppContextSetup(this.wac).build();\r\n    }\r\n\r\n    @Test\r\n    public void shouldReturnErrorJson() throws Exception {\r\n        mockMvc.perform(get(\"\/api\/article\/1\"))\r\n                .andDo(print())\r\n                .andExpect(status().isInternalServerError())\r\n                .andExpect(content().contentType(\"application\/json\"))\r\n                .andExpect(content().string(containsString(\"{\\\"errorMessage\\\":\\\"[API] Getting article problem.\\\"}\")));\r\n    }\r\n}<\/pre>\n
The test is red. What we can do to make it green? We need to make another advice, this time targeting only our Api controller. For that, we will use @ControllerAdvice annotations() selector. In order to do it we need to either create a customer or use existing annotation. We will use @RestController predefined annotation. Controllers annotated with @RestController assume @ResponseBody semantic by default. We may slighlty modify our controller by replacing @Controller with @RestController and removing @ResponseBody from the handler’s method:<\/p>\n
@RestController\r\n@RequestMapping(\"\/api\/article\")\r\nclass ArticleApiController {\r\n\r\n    @RequestMapping(value = \"{articleId}\", produces = \"application\/json\")\r\n    @ResponseStatus(value = HttpStatus.OK)\r\n    Article getArticle(@PathVariable Long articleId) {\r\n        throw new IllegalArgumentException(\"[API] Getting article problem.\");\r\n    }\r\n}<\/pre>\n
We also need to create another advice that will return ApiError (simple POJO):<\/p>\n
@ControllerAdvice(annotations = RestController.class)\r\nclass ApiExceptionHandlerAdvice {\r\n\r\n    \/**\r\n     * Handle exceptions thrown by handlers.\r\n     *\/\r\n    @ExceptionHandler(value = Exception.class)\r\n    @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)\r\n    @ResponseBody\r\n    public ApiError exception(Exception exception, WebRequest request) {\r\n        return new ApiError(Throwables.getRootCause(exception).getMessage());\r\n    }\r\n}<\/pre>\n
This time when we run our test suite, both tests are green meaning that ExceptionHandlerAdvice assisted “standard” ArticleController whereas ApiExceptionHandlerAdvice assisted ArticleApiController.<\/p>\n
Summary<\/h2>\n
In the above scenario I demonstrated how easily we can utilize new configuration capabilities of @ControllerAdvice annotation and I hope you like the change as I do.<\/p>\n
References<\/h2>\n