Spring MVC Interceptor using HandlerInterceptorAdapter Example

Spring provides a powerful request handling mechanism which includes the ability to intercept requests before they are processed by the controllers by using handler interceptors. These interceptors are used to apply some type of processing to the requests either before, after or after the complete request finished executing.

Getting Started using Spring MVC Interceptor

In order to run this tutorial yourself, you will need the following:

Java JDK 1.7 or greater
Spring Tool Suite (STS)
Tomcat 7 or greater or other popular container (Weblogic, Websphere, Glassfish, JBoss, VMWare vFabric, etc). For this tutorial I am using VMware vFabric tc Server Developer Edition which is essentially an enhanced Tomcat instance integrated with Spring STS
Spring Framework 4.0.6
Jackson Mapper for Object to JSON and vice-versa serialization/deserialization
log4J (for logging purposes)

Required Libraries

Copy all of the following jars to WEB-INF/lib folder of the current project. Once that has been done you should be able to verify that all of the jar files are included in your project by using the Java Build Path, Libraries tab.

aopalliance-1.0.jar
aspectjrt-1.6.10.jar
commons-logging-1.2.jar
jackson-core-asl-1.9.13.jar
jackson-mapper-asl-1.9.13.jar
log4j-1.2.17.jar
slf4j-api-1.7.10.jar
slf4j-simple-1.7.10.jar
spring-aop-4.0.6.RELEASE.jar
spring-aspects-4.0.6.RELEASE.jar
spring-beans-4.0.6.RELEASE.jar
spring-context-4.0.6.RELEASE.jar
spring-core-4.0.6.RELEASE.jar
spring-data-commons-1.10.0.RELEASE.jar
spring-data-mongodb-1.6.1.RELEASE.jar
spring-expression-4.0.6.RELEASE.jar
spring-test-4.0.6.RELEASE.jar
spring-tx-4.0.6.RELEASE.jar
spring-web-4.0.6.RELEASE.jar
spring-webmvc-4.0.6.RELEASE.jar

Complete Project Overview

I have added the project overview to give you a full view of the structure and show you all files contained in this sample project.

Spring MVC Archtecture with Regards to HandlerInterceptor

Spring interceptors implement the HandlerInterceptor interface from the org.springframework.web.servlet package.

Spring provides an adapter class called HandlerInterceptorAdapter which allows us to implement only the methods you wish to depending on whether you wish to perform some preprocessing or postprocessing or both on the requests.

HandlerInterceptor Methods

boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) intercepts the request before reaching the handler method. This method returns a boolean. If true, it allows the request to continue in the execution chain for either another interceptor to process or for the the handler itself. If false, Spring assumes the interceptor has processed the request and interrupts any future execution in the execution chain including the actual handler. At this point, our controller will never process this request.

void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) actually sits in between the HandlerAdapter and before DispatcherServlet renders the view allowing the interceptor to inject additional attributes into ModelAndView objects.
Note: This method will be invoked on each interceptor in the chain in reverse order, so the first interceptor will be the last to be invoked.
void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) is called after request has completed processing. Typically this method may be used to perform some type of cleanup of resources.
Note: This method will be invoked on each interceptor in the chain in reverse order, so the first interceptor will be the last to be invoked.

GreenZoneInterceptor Class (GreenZoneInterceptor.java)

package com.avaldes.util;

import java.io.ByteArrayOutputStream;
import java.io.InputStream;

import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpMethod;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;

public class GreenZoneInterceptor extends HandlerInterceptorAdapter {
 private boolean isGreenZone = false;
 private String greenZoneURL
            = "/SpringMVCInterceptorExample/greenzone.html";

 private static final Logger logger
         = LoggerFactory.getLogger(GreenZoneInterceptor.class);

 public void setGreenZone(boolean isGZ) {
  isGreenZone = isGZ;
 }

 public boolean isGreenZone() {
  return isGreenZone;
 }

 public String getGreenZoneURL() {
  return greenZoneURL;
 }

 public void setGreenZoneURL(String greenZoneURL) {
  this.greenZoneURL = greenZoneURL;
 }

 public boolean preHandle(HttpServletRequest request,
   HttpServletResponse response, Object handler) throws Exception {

  logger.info("Inside GreenZoneInterceptor preHandle...");
  if (isGreenZone) {
   logger.info("Inside GreenZone, redirecting to " + greenZoneURL);
   response.sendRedirect(greenZoneURL);
  }

  return true;
 }

 public void postHandle(HttpServletRequest request,
      HttpServletResponse response,
      Object handler,
      ModelAndView modelAndView) throws Exception {

  logger.info("Inside GreenZoneInterceptor postHandle...");
 }

 public void afterCompletion(HttpServletRequest request,
         HttpServletResponse response, Object handler,
         Exception ex) throws Exception {

  logger.info("Inside GreenZoneInterceptor afterCompletion...");
 }
}

Spring MVC Rest Controller (RestController.java)

package com.avaldes.tutorial;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.servlet.ModelAndView;

import com.avaldes.model.Person;
import com.avaldes.model.RestResponse;
import com.avaldes.util.ApplicationContextProvider;
import com.avaldes.util.GreenZoneInterceptor;

@Controller
public class RestController {

 private static final Logger logger
                        = LoggerFactory.getLogger(RestController.class);

 private Map<Integer, Person> persons = new HashMap<Integer, Person>();
 private GreenZoneInterceptor interceptor;
 public static final String APPLICATION_JSON = "application/json";
 public static final String APPLICATION_XML = "application/xml";
 public static final String APPLICATION_HTML = "text/html";

 public RestController() {
  interceptor = (GreenZoneInterceptor) ApplicationContextProvider
    .getApplicationContext().getBean("greenzoneInterceptor");

  // preinitialize the list of persons available...
  persons.put(1, new Person(1, "Amaury", "Valdes",
    "100 Main Street", "Waco", "Texas", "76701"));

  persons.put(2, new Person(2, "John", "Phillips",
    "24 Linden Avenue", "Waco", "Texas", "76701"));

  persons.put(3, new Person(3, "Lisa", "McDowell",
    "8821 Flag Way", "Waco", "Texas", "76701"));
 }

 @RequestMapping(value = "/status",
   method = RequestMethod.GET, produces = APPLICATION_HTML)
 public @ResponseBody String status() {
  return "RestController OK...";
 }

 @RequestMapping(value = "/setGreenZone", method = RequestMethod.GET)
 public @ResponseBody String setGreenZone(
                @RequestParam("value") String value) {

  if (value.equalsIgnoreCase("true") || value.equalsIgnoreCase("yes")
    || value.equalsIgnoreCase("1")) {
   interceptor.setGreenZone(true);
   return "GreenZone has been enabled..";
  } else {
   interceptor.setGreenZone(false);
  }
  return "GreenZone has NOT been enabled.";
 }

 @RequestMapping(value="/hello", method=RequestMethod.GET)
 public ModelAndView myWelcome() {
  logger.info("Inside myHelloWorld() method...");

  ModelAndView model = new ModelAndView("welcome");
  model.addObject("message", "Welcome to the SpringMVCInterceptorExample");

  return model;
 }

 @RequestMapping(value="/persons", method=RequestMethod.GET)
 @ResponseBody
 public List<Person> getAllPersons() {
  logger.info("Inside getAllPersons() method...");

  return new ArrayList<Person>(persons.values());
 }

 @RequestMapping(value="/personById", method=RequestMethod.GET)
 @ResponseBody
 public Person getPersonById(@RequestParam("id") int id) {
  logger.info("Inside getPersonById() method...");

  Person person = persons.get(id);

  if (person != null) {
   logger.info(
     "Inside getPersonById, returned: " + person.toString());
  } else {
   logger
     .info("Inside getPersonById, ID: " + id + ", NOT FOUND!");
  }
  return person;
 }

 @RequestMapping(value="/person/add", method=RequestMethod.POST)
 @ResponseBody
 public RestResponse addPerson(
   @RequestParam("id") String id, @RequestBody Person p) {
  RestResponse response;

  logger.info("Inside addPerson, details: "
    + p.toString());

  if (id == null) {
   response = new RestResponse(false, "ID may not be null.");
   return response;
  }

  int idValue = 0;
  try {
   idValue = Integer.parseInt(id);
   persons.put(idValue, p);
   response = new RestResponse(true,
      String.format("Successfully added Person (%d) %s %s",
         p.getId(), p.getFirstName(), p.getLastName()));

  } catch (NumberFormatException e) {
   response = new RestResponse(false,
            "Unable to add Person with ID: " + id);
  }
  return response;
 }
}

ApplicationContextProvider (ApplicationContextProvider.java)

package com.avaldes.util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class ApplicationContextProvider
              implements ApplicationContextAware {

  private static ApplicationContext applicationContext = null;
  private static final Logger logger
     = LoggerFactory.getLogger(ApplicationContextProvider.class);

  public static ApplicationContext getApplicationContext() {
    return applicationContext;
  }

  public void setApplicationContext(ApplicationContext ctx)
                     throws BeansException {
    applicationContext = ctx;
    logger.info("Setting App Context: "+ ctx);
  }
}

Spring Dispatcher Configuration (dispatcher-servlet.xml)

Modify the dispatcher-servlet.xml and add the necessary interceptor to the mvc:interceptors element. Use the mvc:interceptor element and add the appropriate mvc:mapping to ensure that the interceptor is mapped to anything that matches the path pattern. Subsequently, you may exclude certain path patterns from the interceptor and avoid any type of processing.

In this example, we are including all RESTful API URIs as evidenced by the path=”/**” pattern. However, we are excluding paths matching /persons/** and /setGreenZone** from any processing by the GreenZoneInterceptor class. This will allow us to set up the maintenance window in our Spring application and disable all APIs when the greenZone flag is set to true except the ones matching our exclude pattern.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns:mvc="http://www.springframework.org/schema/mvc"
 xmlns:context="http://www.springframework.org/schema/context"
 xsi:schemaLocation="http://www.springframework.org/schema/mvc
    http://www.springframework.org/schema/mvc/spring-mvc.xsd
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">

 <!-- Enables the Spring MVC @Controller programming model -->
 <mvc:annotation-driven />

 <!-- Handles HTTP GET requests for /resources/** by efficiently serving
  up static resources in the ${webappRoot}/resources directory -->
 <mvc:resources mapping="/resources/**" location="/resources/" />

 <bean name="applicationContext"
    class="com.avaldes.util.ApplicationContextProvider"/>

 <bean name="greenzoneInterceptor"
    class="com.avaldes.util.GreenZoneInterceptor"/>

 <mvc:interceptors>
  <mvc:interceptor>
    <mvc:mapping path="/**" />
    <mvc:exclude-mapping path="/persons/**" />
    <mvc:exclude-mapping path="/setGreenZone**" />
    <ref bean="greenzoneInterceptor" />
  </mvc:interceptor>
 </mvc:interceptors>

 <context:component-scan base-package="com.avaldes" />

 <bean id="viewResolver"
   class="org.springframework.web.servlet.view.InternalResourceViewResolver" >
   <property name="prefix">
     <value>/WEB-INF/</value>
   </property>

   <property name="suffix">
     <value>.jsp</value>
   </property>
  </bean>
</beans>

log4j Configuration (log4j.xml)

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE log4j:configuration PUBLIC
   "-//APACHE//DTD LOG4J 1.2//EN" "log4j.dtd">
<log4j:configuration debug="true"
	xmlns:log4j="http://jakarta.apache.org/log4j/">

	<!-- Appenders -->
<appender name="console" class="org.apache.log4j.ConsoleAppender">
  <param name="Target" value="System.out" />
  <layout class="org.apache.log4j.PatternLayout">
    <param
    name="ConversionPattern"
    value="%d{dd-MMM-yyyy HH:mm:ss.SSS} %-5p %-5l: %c - %m%n" />
  </layout>
</appender>

<appender name="fileAppender" class="org.apache.log4j.RollingFileAppender">
  <param name="append" value="false" />
  <param name="maxFileSize" value="10MB" />
  <param name="maxBackupIndex" value="10" />
  <param name="File" value="/local1/logs/SpringMVCInterceptorExample.log" />
  <layout class="org.apache.log4j.PatternLayout">
    <param
      name="ConversionPattern"
      value="%d{dd-MMM-yyyy HH:mm:ss.SSS} %-5p %-5l: %c - %m%n" />
  </layout>
</appender>

<!-- Application Loggers -->
<logger name="com.avaldes.tutorial.*">
	<level value="DEBUG" />
	<appender-ref ref="fileAppender" />
</logger>

<logger name="org.springframework.beans.*">
	<level value="INFO" />
	<appender-ref ref="fileAppender" />
</logger>

<!-- Root Logger -->
<root>
	<priority value="info" />
	<appender-ref ref="fileAppender" />
</root>
</log4j:configuration>

Person Model Class (Person.java)

package com.avaldes.model;

public class Person {
 private int id;
 private String firstName;
 private String lastName;
 private String address;
 private String city;
 private String state;
 private String zipCode;

 public Person() {};

 public Person(int id, String firstName,
   String lastName, String address,
   String city, String state, String zipCode) {

  this.id = id;
  this.firstName = firstName;
  this.lastName = lastName;
  this.address = address;
  this.city = city;
  this.state = state;
  this.zipCode = zipCode;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getFirstName() {
  return firstName;
 }

 public void setFirstName(String firstName) {
  this.firstName = firstName;
 }

 public String getLastName() {
  return lastName;
 }

 public void setLastName(String lastName) {
  this.lastName = lastName;
 }

 public String getAddress() {
  return address;
 }

 public void setAddress(String address) {
  this.address = address;
 }

 public String getCity() {
  return city;
 }

 public void setCity(String city) {
  this.city = city;
 }

 public String getState() {
  return state;
 }

 public void setState(String state) {
  this.state = state;
 }

 public String getZipCode() {
  return zipCode;
 }

 public void setZipCode(String zipCode) {
  this.zipCode = zipCode;
 }

 @Override
 public String toString() {
  return "Person [id=" + id + ", firstName=" + firstName
    + ", lastName=" + lastName + ", address=" + address
    + ", city=" + city + ", state=" + state + ", zipCode="
    + zipCode + "]";
 }
}

RestResponse Model Class (RestResponse.java)

package com.avaldes.model;

public class RestResponse {
 private boolean success;
   private String message;

   public RestResponse(boolean success, String message) {
     this.success = success;
     this.message = message;
   }

   public boolean isSuccess() {
     return success;
   }

   public void setSuccess(boolean success) {
     this.success = success;
   }

   public String getMessage() {
    return message;
   }

   public void setMessage(String message) {
     this.message = message;
   }
}

Output from Spring MVC Interceptor

Download the Complete Source Code

That’s It!

I hope you enjoyed this tutorial. It was certainly a lot of fun putting it together and testing it out. Please continue to share the love and like us so that we can continue bringing you quality tutorials. Happy Coding!!!

Spring MVC Interceptor using HandlerInterceptorAdapter Example

Spring MVC Interceptor using HandlerInterceptorAdapter Example

Getting Started using Spring MVC Interceptor

Required Libraries

Complete Project Overview

Spring MVC Archtecture with Regards to HandlerInterceptor

HandlerInterceptor Methods

GreenZoneInterceptor Class (GreenZoneInterceptor.java)

Spring MVC Rest Controller (RestController.java)

ApplicationContextProvider (ApplicationContextProvider.java)

Spring Dispatcher Configuration (dispatcher-servlet.xml)

log4j Configuration (log4j.xml)

Person Model Class (Person.java)

RestResponse Model Class (RestResponse.java)

Output from Spring MVC Interceptor

Download the Complete Source Code

Download Spring MVC Interceptor Example

That’s It!

Related Spring Posts

Please Share Us on Social Media

Leave a Reply Cancel reply