Controllo dell’autenticazione con Spring MVC e Handler Interceptor

Nel contesto di un’applicazione web Spring MVC, l’oggetto HandlerInterceptor sostituisce il concetto del tradizionale Servlet Filter J2EE. Il suo scopo è quello di rimanere in ascolto e intercettare tutte le URL mappate sull’applicazione e processate da un Handler. In termini di programmazione event-driven, gli Handler sono dei gestori di eventi che vengono richiamati per gestire e rispondere ad un determinato evento come può essere per esempio un processo d’invocazione Request-Response di un servizio web. L’oggetto HandlerInterceptor si inserisce nel ciclo di vita di un Handler ed è in grado di effettuare delle operazioni indipendenti e in maniera completamente disaccoppiata da esso. HandlerInterceptor definisce tre metodi per gestire operazioni sulla chain-execution di un Handler:

– preHandle: richiamato prima che l’Handler corrente venga eseguito
– postHandle: richiamato dopo l’esecuzione dell’Handler corrente ma prima che la vista venga renderizzata
– afterCompletion: richiamato al completamento di tutto il flusso Request/Response

In questo articolo mostro un esempio di come effettuare un controllo sull’autenticazione dell’utente utilizzando HandlerInterceptor in un’applicazione Spring MVC. Ovviamente esistono altre soluzioni più sicure e affidabile che implementano il processo di autenticazione e access-control (vedi per esempio Spring Security). Tuttavia questo esempio può essere molto utile per capire il concetto di Interceptor e di chain-execution in Spring MVC. Per avere un’idea di quello che succede a livello temporale, ho abbozzato alcuni sequence diagram isolando i principali casi d’uso relativamente al meccanismo di autenticazione.

1 - Request for base URI

Immagine 1 di 4

ROADMAP
STEP 1. Configurazione Spring MVC
STEP 2. Configurazione Login
STEP 3. Configurazione Interceptor

STEP 1. Configurazione Spring MVC

Creo lo skeleton dell’applicazione con Maven e aggiungo nel pom.xml le dipendenze per Spring MVC. Importo il progetto in Eclipse e imposto su di esso “Project Facets” > “Dynamic Web Module”. Questo mi permette di pubblicare l’applicazione di esempio dentro il Tomcat integrato in Eclipse e di effettuare facilmente attività di debugging. Preparo la struttura del progetto e aggiungo alcune risorse per la componente di visualizzazione delle pagine come css, immagini e librerie javascript.

$ mvn archetype:generate 
-DgroupId=eu.giuseppeurso.sampleintercep 
-DartifactId=sample-intercep
-DarchetypeArtifactId=maven-archetype-quickstart 
-DinteractiveMode=false

Definisco e configuro la Servlet Dispatcher di Spring MVC. Grazie al parametro contextConfigLocation posso definire per i file di configurazione di spring, un path personalizzato che punta alla cartella WEB-INF/spring. Ecco un’estratto del file web.xml e spring-dispatcher.xml

<!-- web.xml -->
<servlet>
    <servlet-name>spring-dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>/WEB-INF/spring/spring-dispatcher.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>spring-dispatcher</servlet-name>
    <url-pattern>/</url-pattern>
  </servlet-mapping>

<!-- spring-dispatcher.xml -->

<!-- DispatcherServlet Context: defines this servlet's request-processing infrastructure -->
	<context:component-scan base-package="eu.giuseppeurso.sampleinterc" />

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

	<!-- Handles HTTP GET requests for /resources/** by efficiently serving up static resources in the ${webappRoot}/* directory -->
	<resources mapping="/css/**" location="/css/" />
	<resources mapping="/js/**" location="/js/" />
	<resources mapping="/images/**" location="/images/" />
	<resources mapping="/jquery-ui-1.9.2/**" location="/jquery-ui-1.9.2/" />

	<!-- Resolves views selected for rendering by @Controllers to .jsp resources in the /WEB-INF/views directory -->
	<beans:bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
		<beans:property name="prefix" value="/WEB-INF/views/" /> 
		<beans:property name="suffix" value=".jsp" />
	</beans:bean>

Creo l’instanza di Spring MVC Controller e configuro una RequestMapping che porta a una pagina di benvenuto welcome.jsp.

//SampleController.java
@Controller
public class SampleController {

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

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

<!-- welcome.jsp -->
<div>
	<h1>WELCOME!
     Spring MVC Interceptor Sample</h1>
</div>

STEP 2. Configurazione Login Form

Modifico il Controller per far puntare il context-root dell’applicazione a un form di login (http://localhost:8080/spring-interc/). Il Model di Spring mi servirà successivamente per avere accesso agli attributi del form di login. Creo inoltre il bean di login con gli attributi username e password e la pagina jsp per il form. Il modelAttribute del tag form:form deve avere lo stesso nome utilizzato nel Controller (“loginAttribute“).

// SampleController.java
@RequestMapping(value = "/", method = RequestMethod.GET)
	public String showLogin(Model model, LoginForm loginForm) {
		logger.info("Login page");
		model.addAttribute("loginAttribute", loginForm);
		return "login";
	}

// LoginForm.java
public class LoginForm {

	private String username;
	private String password;

	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}	
}

<!-- login.jsp -->
<form:form action="login" method="post"  modelAttribute="loginAttribute">
	<table border="0" cellpadding="0" cellspacing="0">
		<tr>
			<th>Username</th>
			<td><form:input type="text"  class="login-inp" path="username" /></td>
		</tr>
		<tr>
			<th>Password</th>
			<td><form:input type="password" value="************"  onfocus="this.value=''" class="login-inp" path="password"/></td>
		</tr>
		<tr>
			<th></th>
			<td valign="top"><input type="checkbox" class="checkbox-size" id="login-check" /><label for="login-check">Remember me</label></td>
		</tr>
		<tr>
			<th></th>
			<td><input type="submit" class="submit-login"  /></td>
		</tr>
	</table>
</form:form>

STEP 3. Configurazione Interceptor

Definisco nel file spring-dispatcher.xml la mia implementazione di HandlerInterceptor che sarà in ascolto su tutte le url applicative. Per effettuare il controllo sull’autenticazione dell’utente faccio l’overriding del metodo preHandle. Utilizzo l’attributo LOGGEDIN_USER come flag per verificare se la sessione contiene o meno un utente correttamente autenticato. Inoltre faccio un controllo sull’url corrente per evitare dei redirect loop nel caso di accesso alla pagina di default oppure di submit login corretto o errato (vedi sequence diagram precedenti).

<!-- spring-dispatcher.xml-->
<interceptors>
	<interceptor>
		<mapping path="/*"/>
		<beans:bean class="eu.giuseppeurso.sampleinterc.interceptor.AuthenticationInterceptor" />
	</interceptor>
</interceptors>

// AuthenticationInterceptor.java
@Override
	public boolean preHandle(HttpServletRequest request,HttpServletResponse response, Object handler) throws Exception {

		log.info("Interceptor: Pre-handle");

		// Avoid a redirect loop for some urls
		if( !request.getRequestURI().equals("/sample-interc/") &&
		    !request.getRequestURI().equals("/sample-interc/login.do") &&
		    !request.getRequestURI().equals("/sample-interc/login.failed"))
		  {
			  LoginForm userData = (LoginForm) request.getSession().getAttribute("LOGGEDIN_USER");
		   if(userData == null)
		   {
		    response.sendRedirect("/sample-interc/");
		    return false;
		   }   
		  }
		  return true;

Infine aggingo tre RequestMapping nel mio Controller per mappare i casi d’uso mostrati nei sequence diagram. Il metodo di tipo POST controlla username e password inseriti nel form di login. Per motivi di praticità, non configuro un Persistence Layer basato su DB. Puttosto simulo lo strato di dati con un semplice file di testo in cui inserisco dei valori per username e password. Per accedere al file utilizzo un semplice ResourceBundle di java.util. All’avvio del Tomcat, vengono inizializzati l‘HandlerInterceptor e tutte le RequestMapping che ho definito nel mio Controller. Faccio puntare il browser al root-context applicativo http://localhost:11000/sample-interc/. La request viene intercettata da AuthenticationInterceptor che mostra la pagina di login. L’interceptor resterà sempre in ascolto su tutte le url gestite dall’Handler, per verificare la presenza o meno in Sessione di un utente correttamente autenticato.

//SampleController.java
@RequestMapping(value = "/login.do", method = RequestMethod.POST)
	public String login(Model model, LoginForm loginform, Locale locale, HttpServletRequest request) throws Exception {

		String username = loginform.getUsername();
		String password = loginform.getPassword();

		// A simple authentication manager
		if(username != null && password != null){

			if( username.equals(settings.getString("username")) &&	password.equals(settings.getObject("password")) ){
				//return "welcome"; 
				request.getSession().setAttribute("LOGGEDIN_USER", loginform);
				return "redirect:/welcome";
			}else{
				return "redirect:/login.failed";
			}
		}else{
			return "redirect:/login.failed";
		}	
	}