Back to Spring Hub

Nearby lessons

26 of 35
Spring - MVC ValidationSpring - HandlerMappingsSpring - HandlerInterceptorSpring - ViewResolversSpring - File Upload & Download

Spring - HandlerInterceptor

📌 What You Will Learn
  • Write an interceptor class and understand its three callback points
  • Register an interceptor against a specific handler mapping
  • Register interceptors globally with the mvc namespace

Run code before and after a controller without touching the controller. Write a HandlerInterceptor and register it three different ways — the interceptors property, the <interceptors> tag, and <mvc:interceptors>.

HandlerInterceptor

In general, in web applications, to provide pre-processing and post-processing services for web resources like Servlets and JSPs we will use "Servlet Filters".

In web applications, we are able to provide single filter for multiple Servlets and JSPs and we are able to provide multiple filters for Single Servlet or JSP.

In the above representation, when we submit request to the container for a particular Servlet then container will perform the following actions.

  • Container will check whether any Filter or Filters are associated with the respective Servlet or not.
  • If any Filter or Filters are associated with the Servlet then container will execute all the Filters in one by one fashion in an order which we configured in web.xml file.
  • If the present request is satisfying Filter constraints then Container will forward request to the next filter or to the Servlet if no filter is existed in next.
  • If the present request is not satisfying the Filter constraints then Filter will send response to the client through all the previous filters.
  • If all the Filters are executed then Container will execute the respective Servlet, after execution of the Servlet Container will send the generated response to the client through all the Filters in reverse order.

Similarly in Spring Web MVC applications, if we want to provide Pre-Processing and Post- Processing services to any controller or all the controllers components then we have to use Interceptors.

If we provide Interceptors in Spring WEB MVC applications then they will be executed before executing the controller, after executing the controller and then after sending response to client.

If we provide Interceptors in Spring WEB MVC applications then they will be executed before executing the controller, after executing the controller and before sending response to client and then after sending response to client.

If we want to use Interceptors in Spring WEB MVC applications then we have to use the following two steps.

  • Prepare Interceptor class
  • Configure Interceptor class in Spring configuration File.

Prepare Interceptor class

To prepare Interceptor class we have to declare an user defined class and either implement org.springframework.web.servlet.HandlerInterceptor interface or extend org.springframework.web.servlet.handler.HandlerInterceptorAdapter class in User defined class. Where HandlerInterceptor is an interface contains the following three methods.

  • public boolean preHandle(HttpServletRequest request,HttpServletResponse response, Object

handler)throws Exception

 This method will include pre-processing logic which we want to execute before executing

controller method

 This method will be executed before executing controller class.

 This method will return a boolean value like true or false.

 If this method returns 'true' value then DispatcherServlet will understand the present

Interceptor is executed successfully and request will be forwarded to the next

interceptor or to the Controller if no interceptor is existed.

 If this method returns 'false' value then the present Interceptor constraints are not satisfied

by the present request and Interceptor generates the required response to the client

through all the previos interceptors with out executing the respective Controller.

  • public void postHandle( HttpServletRequest request, HttpServletResponse response, Object handler,

ModelAndView modelAndView) throws Exception  This method will include the Post-Processing services logic which we want to execute after

executing the controller component.  This method will be executed after executing the controller component and before

submitting response to client.  This method can be used to add additional attribute to the ModelAndView object to be used

in the view pages.  Thismethod can be used to determine the time taken by handler method to process the

client request.

  • public void afterCompletion( HttpServletRequest request, HttpServletResponse response, Object handler,

Exception e) throws Exception  This method will be executed after executing the controiller class and after sending

response to client.  This method will be executed only once for all the controller classes, that is, after the

response renderring. Note: In Spring WEB MVC applications, preHandler() and postHandle() methods are executed for each and every controller, but, afterCompletion() method will be executed only once after the response renderring.

If more than one Interceptor is provided for a controller component then all the Interceptors are executed like below.

If we provide Multiple Interceptors in Spring WEDB MVC application then preHandle() methods will be executed as per the Interceptors configuration order which we configured in Spring configuration file, but, postHandle() and afterCompletion() methods are executed in reverse order of the Interceptors.

  • Configure Interceptor class in Spring configuration File.

To configure Interceptor class in Spring configuration file , we have to use the following approaches.

  • Use "interceptors" property of type list in HandlerMapping configuration
  • User <interceptors> tag in spring configuration file directly.
  • Use <mvc:interceptors> tag in Spring configuration file.

Use "interceptors" property of type list in HandlerMapping configuration

<beans> ----- <bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
<property name="interceptors"> <list> <ref bean="maintenanceInterceptor" /> <ref bean="executeTimeInterceptor" /> </list>
</property> </bean> ---- </beans>

User <interceptors> tag in spring configuration file directly

<beans> ---- <interceptors>
<interceptor> <mapping path="/home" /> <beans:bean

class="com.durgasoft.interceptors.RequestProcessingTimeInterceptor"></beans:bean> </interceptor>

</interceptors> ------ </beans>

Use <mvc:interceptors> tag in Spring configuration file — index.jsp

<beans> -----
<mvc:interceptors> <bean class="com.javapapers.spring.mvc.interceptor.GreetingInterceptor" /> <mvc:interceptor> <mvc:mapping path="/AnimalList" /> <bean class="com.durgasoft.interceptor.AnimalInterceptor" /> </mvc:interceptor>
</mvc:interceptors> ----- </beans>

Example:

Example06
JCode Cell
1 
2<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
3pageEncoding="ISO-8859-1"%>
4<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
5<html>
6<head>
7<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
8<title>Insert title here</title>
9</head>
10<body>
11<jsp:forward page="wish"/>
12</body>
13</html>
14

Use <mvc:interceptors> tag in Spring configuration file — helloform.jsp

Example07
JCode Cell
1 
2<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
3pageEncoding="ISO-8859-1"%>
4<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
5<html>
6<head>
7<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
8<title>Insert title here</title>
9</head>
10<body>
11<h2 style="color: red;" align="center"> Durga Software Solutions </h2>
12<h3 style="color: blue;" align="center"> User Hello Form </h3>
13<form method="POST" action="wish">
14<center>
15<table>
16<tr>
17<td>User Name</td>
18<td><input type="text" name="uname"/></td>
19</tr>
20<tr>
21<td><input type="submit" value="SayHello"/></td>
22</tr>
23</table>
24</center>
25</form>
26</body>
27</html>
28

Use <mvc:interceptors> tag in Spring configuration file — wish.jsp

Example08
JCode Cell
1 
2<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
3pageEncoding="ISO-8859-1"%>
4<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
5<html>
6<head>
7<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
8<title>Insert title here</title>
9</head>
10<body>
11<h2 style="color: red;" align="center"> Durga Software Solutions </h2>
12<h3 style="color: blue;" align="center"> User Hello Status </h3>
13<h1 style="color: red;" align="center"> Hello ${uname} </h1>
14<h1 style="color: blue;" align="center">
15Start Time: ${startTime}ms<br>
16End Time : ${endTime}ms<br>
17HelloController Processing Time : ${totalTime} ms
18</h1>
19</body>
20</html>
21

Use <mvc:interceptors> tag in Spring configuration file — WishController.java

Example09
JCode Cell
1 
2package com.durgasoft.controller;
3 
4import javax.servlet.http.HttpServletRequest;
5import javax.servlet.http.HttpServletResponse;
6 
7import org.springframework.stereotype.Controller;
8import org.springframework.web.bind.annotation.RequestMapping;
9import org.springframework.web.bind.annotation.RequestMethod;
10import org.springframework.web.servlet.ModelAndView;
11 
12 
13@Controller
14@RequestMapping("/wish")
15public class WishController {
16@RequestMapping(method=RequestMethod.GET)
17public String getForm() {
18return "helloform";
19}
20 
21@RequestMapping(method=RequestMethod.POST)
22public ModelAndView wish(HttpServletRequest request, HttpServletResponse response) {
23String uname = request.getParameter("uname");
24return new ModelAndView("wish", "uname", uname);
25}
26}
27

Use <mvc:interceptors> tag in Spring configuration file — ProcessingTimeInterceptor.java

Example10
JCode Cell
1 
2package com.durgasoft.interceptor;
3import javax.servlet.http.HttpServletRequest;
4import javax.servlet.http.HttpServletResponse;
5 
6import org.springframework.web.servlet.HandlerInterceptor;
7import org.springframework.web.servlet.ModelAndView;
8 
9public class ProcessingTimeInterceptor implements HandlerInterceptor {
10 
11@Override
12public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)
13 throws Exception {
14System.out.println("Response Rendered");
15}
16@Override
17public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView)
18 throws Exception {
19 long startTime = (Long) request.getAttribute("startTime");
20 request.removeAttribute("startTime");
21 
22 long endTime = System.currentTimeMillis();
23 System.out.println("End Time :"+endTime);
24 
25 System.out.println("Processing Time : "+(endTime-startTime));
26 modelAndView.addObject("startTime", startTime);
27 modelAndView.addObject("endTime", endTime);
28 modelAndView.addObject("totalTime", endTime - startTime);
29}
30@Override
31public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
32long startTime = System.currentTimeMillis();
33request.setAttribute("startTime", startTime);
34System.out.println("start Time :"+startTime);
35return true;
36}
37}
38

Use <mvc:interceptors> tag in Spring configuration file — ds-servlet.xml

Example11
JCode Cell
1 
2<?xml version="1.0" encoding="UTF-8"?>
3<beans xmlns="http://www.springframework.org/schema/beans"
4xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5xmlns:p="http://www.springframework.org/schema/p"
6xmlns:context="http://www.springframework.org/schema/context"
7xsi:schemaLocation="
8 http://www.springframework.org/schema/beans
9 http://www.springframework.org/schema/beans/spring-beans.xsd
10 http://www.springframework.org/schema/context
11http://www.springframework.org/schema/context/spring-context.xsd">
12<context:annotation-config/>
13<context:component-scan base-package="com.durgasoft.controller"/>
14<bean name="processingTimeInterceptor" class="com.durgasoft.interceptor.ProcessingTimeInterceptor"/>
15<bean class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping">
16<property name="interceptors">
17<list>
18 <ref bean="processingTimeInterceptor"/>
19</list>
20</property>
21</bean>
22<bean name="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
23<property name="prefix" value="/WEB-INF/"/>
24<property name="suffix" value=".jsp"/>
25</bean>
26</beans>
27

Use <mvc:interceptors> tag in Spring configuration file — web.xml

Example12
JCode Cell
1 
2<?xml version="1.0" encoding="UTF-8"?>
3<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://xmlns.jcp.org/xml/ns/javaee" xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd" id="WebApp_ID" version="4.0">
4<display-name>app17</display-name>
5<welcome-file-list>
6<welcome-file>index.html</welcome-file>
7<welcome-file>index.htm</welcome-file>
8<welcome-file>index.jsp</welcome-file>
9<welcome-file>default.html</welcome-file>
10<welcome-file>default.htm</welcome-file>
11<welcome-file>default.jsp</welcome-file>
12</welcome-file-list>
13<servlet>
14<servlet-name>ds</servlet-name>
15<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
16<load-on-startup>1</load-on-startup>
17</servlet>
18<servlet-mapping>
19<servlet-name>ds</servlet-name>
20<url-pattern>/</url-pattern>
21</servlet-mapping>
22</web-app>
23
📝 Key Takeaways
  • An interceptor is cross-cutting request handling — logging, auth, timing — kept out of the controller
  • Registering on a HandlerMapping scopes the interceptor to that mapping's URLs
  • <mvc:interceptors> applies to every request unless you narrow it with a path