Spring MVC: Centralizing Common Configurations using @ControllerAdvice

Handling Exceptions using HandlerExceptionResolver

Once upon a time, Spring 2.0 introduced HandlerExceptionResolver to handle thrown exceptions. While this approach works, it is like throwing a big net to catch all types of fish. If we are only interested in catching piranhas and clownfish, this approach becomes a little tedious because we need to weed out the types of fish we don’t care.

@Controller
public class ErrorController implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest,
                                         HttpServletResponse httpServletResponse,
                                         Object o,
                                         Exception e) {

        ModelAndView modelAndView = new ModelAndView("error");

        if (e instanceof PiranhaException) {
            // stir fry it
        }
        else if (e instanceof ClownfishException) {
            // make me laugh first
        }
        else {
            // don't care...
        }

        return modelAndView;
    }

    @RequestMapping(value = "/error", method = RequestMethod.GET)
    public String error() {
        return "error";
    }
}

Handling Exceptions using @ExceptionHandler

Then, Spring 3.0 introduced a more elegant way to handle exceptions using @ExceptionHandler. Now, we can easily catch the types of fish we need and handle accordingly.

@Controller
@RequestMapping(value = "/fish")
public class FishController {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }

    @RequestMapping(method = RequestMethod.GET)
    public String home() {
        return "home";
    }
}

While this is a more elegant solution than the previous approach, @ExceptionHandler has to be defined within the Controller class. If we want to apply the same exception handling across multiple controllers, we either have to define @ExceptionHandler in every Controller class or create something “clever” such as extending a parent controller that contains the common configurations.

Handling Exceptions using @ControllerAdvice

Then, Spring 3.2 introduced an even better approach to centralize common configurations using @ControllerAdvice. Instead of defining @ExceptionHandler all over places or extending a parent controller, we can create a separate class that contains these common configurations and annotate it with @ControllerAdvice.

@ControllerAdvice
public class FishControllerAdvice {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }
}

… and now, the controller will look as simple as this:-

@Controller
@RequestMapping(value = "/fish")
public class FishController {

    @RequestMapping(method = RequestMethod.GET)
    public String home() {
        return "home";
    }
}

In fact, @ControllerAdvice can be used to define @ExceptionHandler, @ModelAttribute and @InitBinder that apply to all @RequestMapping methods.

Here’s an example:-

@ControllerAdvice
public class MyAdviceToAllFish {

    @ExceptionHandler(PiranhaException.class)
    public String piranhaException(Exception e) {
        // stir fry it
        return "error";
    }

    @ExceptionHandler(ClownfishException.class)
    public String clownfishException(Exception e) {
        // make me laugh first
        return "error";
    }

    // Catch all other exceptions
    @ExceptionHandler(Exception.class)
    public String exception(Exception e) {
        // when shit happens
        return "error";
    }

    // Return a list of tech support emails
    @ModelAttribute("techSupportEmails")
    public List<String> getTechSupportEmails() {
        return Arrays.asList("generaltso@chicken.com", "bat@man.com");
    }

    // Handles `String` and Joda Time's `LocalDate` object
    @InitBinder
    private void initBinder(WebDataBinder binder) {
        // Trim string and set empty string as `null` value
        binder.registerCustomEditor(String.class, new StringTrimmerEditor(true));

        // Convert Joda Time's `LocalDate` object to text, vice versa
        binder.registerCustomEditor(LocalDate.class, new PropertyEditorSupport() {
            private final DateTimeFormatter pattern = DateTimeFormat.forPattern("MM/dd/yyyy");

            @Override
            public void setAsText(String text) throws IllegalArgumentException {
                setValue(StringUtils.isBlank(text) ? null : pattern.parseLocalDate(text));
            }

            @Override
            public String getAsText() throws IllegalArgumentException {
                LocalDate localDate = (LocalDate) getValue();
                return localDate != null ? pattern.print(localDate) : "";
            }
        });
    }
}

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s