Spring Framework MVC: mapeamento do Dispatcher Servlet

O padr�o de projeto MVC � um dos mais utilizados na programaç�o, contudo, em Java esse padr�o era implementado praticamente na m�o ou com o uso de pequenos frameworks. Como era algo que dava muito trabalho e funcionava muito bem em outras linguagens, ent�o logo a comunidade recebeu o Struts e outros frameworks para criar as aplicaç�es com as tr�s camadas: model, view e controller.

O Framework Spring MVC � um framework web MVC desenvolvido pela Spring Source e de c�digo aberto. Ele � projetado em torno de um Servlet, o DispatcherServlet, que despacha pedidos para os controladores. Um controlador padr�o do Spring MVC faz uso das anotaç�es @Controller e @RequestMapping, que oferecem uma ampla gama de recursos flex�veis para manipulaç�o das requisiç�es.

Controladores do Spring MVC

Os controladores do Spring MVC d�o acesso a parte da aplicaç�o que normalmente � respons�vel por resolver as quest�es relacionadas a l�gica de neg�cio e geralmente s�o denominadas como interfaces de serviços. O DispatcherServlet direciona as requisiç�es dos usu�rios para os controladores de acordo com o mapeamento realizado nestes �ltimos. Esses controladores interpretam a entrada do usu�rio (requisiç�es) e transformam-na em um modelo que no Spring MVC � representado pela Interface Model e suas implementaç�es. O Spring implementa um controlador de uma forma muito abstrata, permitindo criar uma grande variedade de controladores. No Spring 2.5 foi introduzido um modelo de programaç�o baseado em anotaç�es para controladores MVC como, por exemplo, @RequestMapping, @RequestParam, @ModelAttribute.

As anotaç�es @Controller e @RequestMapping

A anotaç�o @Controller indica que uma classe particular serve como um controlador, atuando como um estere�tipo para a classe anotada, indicando o seu papel. J� a anotaç�o @RequestMapping � usada para mapear URLs como www.DNS_da_aplicaç�o/cliente para toda uma classe ou para um m�todo manipulador particular. Normalmente, a anotaç�o de n�vel de classe mapeia um caminho de requisiç�es espec�fico em um controlador de formul�rio, com anotaç�es adicionais em n�vel de m�todo, estreitando o mapeamento prim�rio para um m�todo espec�fico de solicitaç�o HTTP ("GET", "POST", etc.) ou uma condiç�o de par�metro de solicitaç�o HTTP.

Um exemplo do uso das anotaç�es @Controller e @Request ser� mostrado na Listagem 1, onde a anotaç�o @Controller indica que a classe Cliente � um controlador do Spring MVC. Dessa forma, o DispatcherServlet poder� encaminhar requisiç�es de usu�rio para serem manipuladas nesta classe.


package br.com.cazuzaneto.cotrolador;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
 
@Controller
@RequestMapping(value = "/cliente")
public class Cliente {
 
    @RequestMapping(method = RequestMethod.GET)
    public String exibeTodosOsClientes(Model uiModel) {
        // ...
        return "pagina";
    }
 
    @RequestMapping(method = RequestMethod.POST)
    public String persisteNovoCliente(Model uiModel) {
        // ...
        return "pagina";
    }
}

Listagem 1. Uso das anotaç�es

A anotaç�o @RequestMapping indica que o controlador, que neste caso � a classe Cliente, receber� as requisiç�es feitas � URL www.DNS_da_aplicaç�o/cliente. O m�todo exibeTodosOsClientes tamb�m est� anotado com a anotaç�o @RequestMapping, indicando que esse m�todo ir� receber as requisiç�es feitas a URL www.DNS_da_aplicaç�o/cliente sempre que se tratar de uma requisiç�o HTTP GET.

Por sua vez, o m�todo persisteNovoCliente receber� as requisiç�es feitas a URL www.DNS_da_aplicaç�o/cliente usando o m�todo POST. Esse crit�rio � definido atrav�s do uso do par�metro method da anotaç�o @RequestMapping. Um m�todo mapeado com a anotaç�o @RequestMapping dever� ter algum retorno que, por sua vez, ser� exibido ao usu�rio. Esse retorno pode ser de v�rios formatos: uma p�gina de hipertexto, um arquivo (XML, JSON, JPEG, PDF), entre outros. Quando se trata de p�ginas que ser�o exibidas ao usu�rio, estas dever�o ser tratadas por algum ViewResolver, que veremos na pr�xima seç�o.

ViewResolver

O retorno de um m�todo anotado com @RequestMapping dever� ser tratado por algum ViewResolver. Este permite ao desenvolvedor renderizar modelos de p�ginas web em um navegador sem amarr�-lo a uma tecnologia espec�fica. Ele deve ser configurado no contexto do DispatcherServlet. Existem muitas opç�es para ViewResolvers que podem ser usadas no Spring MVC: uma delas � a integraç�o com o projeto Apache Tiles. Neste trabalho ser� utilizado um ViewResolver do Spring MVC: o InternalResourceViewResolver.

Lembrando que o Apache Tiles permite definir fragmentos de p�ginas que podem ser montadas em p�ginas mais completas em tempo de execuç�o. Esses fragmentos, ou tiles, podem ser usados para reduzir a duplicaç�o de elementos de p�gina dentro de outras tiles para desenvolver templates reutiliz�veis.

Configuraç�o do Spring MVC

A configuraç�o do Spring MVC est� focada no arquivo web.xml e na configuraç�o do contexto do DispatcherServlet. Como o Spring MVC � projetado em torno de um Servlet, o DispatcherServlet, este precisa ser registrado e mapeado no arquivo web.xml. J� a configuraç�o do contexto do DispatcherServlet pode ser feita em um arquivo XML. Esse arquivo deve ser carregado junto com a aplicaç�o. Para isso, � necess�rio indicar no arquivo web.xml do projeto que o arquivo de configuraç�o do Spring dever� ser carregado. Essa n�o � a �nica forma de configurar o contexto do DispatcherServlet, mas ser� a forma utilizada neste trabalho. Na documentaç�o (seç�o Links) voc� encontra mais informaç�es, lembrando que a forma vista aqui � a mais recomendada.

Criaç�o e configuraç�o do projeto

O projeto-exemplo criado neste artigo tem apenas fins did�ticos, por este motivo ser� utilizado um cen�rio simples, que ir� utilizar uma pequena parte dos recursos do Spring Framework MVC.

A primeira coisa a se fazer � criar um projeto web Java usando o Maven (vide seç�o Links). O nome dado ao projeto desenvolvido foi "spring-mvc". A ferramenta Spring Tool Suite (STS) foi utilizada para o desenvolvimento do projeto em quest�o, por�m qualquer IDE Java (Eclipse, NetBeans, etc.) poder� ser utilizada para recriaç�o deste exemplo. A STS pode ser usada tanto em m�quinas com Windows, Linux ou MAC. Seu ambiente � baseado no Eclipse e fornece um ambiente completo para o desenvolvimento.

O Apache Tomcat (seç�o Links) foi o software escolhido para ser o cont�iner web desta aplicaç�o, apesar da STS contar com o Pivotal, que � a substituiç�o do Tomcat dentro do Spring.

Configuraç�o do arquivo pom.xml

O arquivo pom.xml dever� conter duas depend�ncias do Spring Framework e as depend�ncias para o uso de Servlet, JSP e JSTL, como mostra a Listagem 2.


spring-context
spring-webmvc
servlet-api
jsp-api
jstl

Listagem 2. Lista de depend�ncias

Assim, a Listagem 3 mostra a configuraç�o do pom.xml.


<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
  http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>br.com.cazuzaneto</groupId>
  <artifactId>spring-mvc</artifactId>
  <version>1.0.0-BUILD-SNAPSHOT</version>
  <name>spring-mvc</name>
  <packaging>war</packaging>

  <dependencies>
    <!-- Spring -->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>

    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>4.2.4.RELEASE</version>
    </dependency>
    <!-- Servlet -->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>3.1.0</version>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.1</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.3</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
    </plugins>
  </build>
</project>

Listagem 3. Configuraç�o do pom.xml

Configuraç�o do arquivo web.xml

O arquivo web.XML � usado para realizar a configuraç�o dos servlets da aplicaç�o. Ele � obrigat�rio desde as vers�es anteriores a 3.0. Neste exemplo � importante destacar a configuraç�o do servlet do Spring MVC: o Dispatcher Servlet. Ele ser� respons�vel por receber todas as requisiç�es feitas � aplicaç�o em quest�o, como est� sendo definido na tag servlet-mapping. Um outro arquivo XML est� sendo passado como par�metro na inicializaç�o do DispatcherServlet: o servlet-context.xml, que � o arquivo de configuraç�o do contexto do DispatcherServlet, como mostra a Listagem 4.


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
  http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">

  <!-- Servlet que ir� processar as requisiçoes -->
  <servlet>
    <servlet-name>dispatcherServlet</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet
    </servlet-class>
    <init-param>
          <param-name>contextConfigLocation</param-name>
          <param-value>/WEB-INF/dispatcherServlet/servlet-context.xml
          </param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
  </servlet>

  <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
  </servlet-mapping>

</web-app>

Listagem 4. Configuraç�o do web.xml

Criaç�o e configuraç�o do contexto do DispatcherServlet

O contexto do DispatcherServlet define a infraestrutura do processamento das requisiç�es feitas ao mesmo. Esse contexto pode ser configurado atrav�s de um arquivo XML que dever� ser carregado junto com este Servlet. Para isto, ser� criada uma pasta com o nome �dispatcherServlet� dentro do diret�rio WEB-INF e, dentro desta pasta ser� criado um arquivo XML com o nome servlet-context.xml, cuja conte�do � o mesmo da Listagem 5.


<?xml version="1.0" encoding="UTF-8"?>
  <beans:beans xmlns="http://www.springframework.org/schema/mvc"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xmlns:beans="http://www.springframework.org/schema/beans"
        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">
   
        <!-- Contexto do DispatcherServlet: define a infraestrutura do processamento 
              das requisiç�es feitas ao Servlet (DispatcherServlet) -->
   
        <!-- Ativa o modelo de programaç�o padr�o do Spring MVC (@Controller) -->
        <annotation-driven />
   
        <!-- ViewResolver: Resolver as vis�es retornadas pelos controladores (@Controller) 
              para recursos .jsp que est�o do diret�rio /WEB-INF/views -->
        <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>
   
        <!-- Define o pacote base para o escaneamento das anotaç�es de contexto 
              (@Component, @Repository, @Service, @Controller, etc) -->
        <context:component-scan base-package="br.com.cazuzaneto" />
  </beans:beans>

Listagem 5. Conte�do do servlet-context.xml

Criaç�o do Controlador

Uma vez configurado o projeto est� pronto para ser codificado. Nesta seç�o ser� criada uma classe chamada Controlador que ir� ser um controlador do Spring MVC. Para isso ela dever� ser anota com @Controller e @RequestMapping. O par�metro value da anotaç�o @RequestMapping foi preenchido com o car�cter "/", indicando que essa classe atender� as requisiç�es feitas � raiz da aplicaç�o. O m�todo home tamb�m est� anotado com @RequestMapping e, dessa forma, esse m�todo tamb�m receber� requisiç�es tratadas pelo DispatcherServlet. Como o par�metro value da anotaç�o @RequestMapping do m�todo home n�o est� preenchido, esse m�todo ir� receber as anotaç�es feitas � raiz da aplicaç�o que possuam o m�todo GET. Observe o c�digo da Listagem 6.


package br.com.cazuzaneto.cotrolador;
 
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
 
/**
 * Controla as requisiç�es feitas � raiz da aplicaç�o.
 * 
 * @author Cazuza Neto
 * @version 1.0
 * @since 2016-01-12
 */
@Controller
@RequestMapping(value = "/")
public class Controlador {
 
    /**
     * Atende as requisiç�es GET feitas � raiz da aplicaç�o.
     */
    @RequestMapping(method = RequestMethod.GET)
    public String home(Model model) {
        model.addAttribute("mensagem",
                "Minha primeira aplicaç�o utilizando o Spring Framework MVC!");
        return "home";
    }
 
}

Listagem 6. Classe Controlador

O par�metro de entrada do m�todo home � uma Interface Model, pois os controladores do Spring MVC interpretam a entrada do usu�rio (requisiç�es) e transformam-na em um modelo que � representado pela Interface e suas implementaç�es. Dessa forma, pode-se compreender que esta � um recurso do Spring MVC que encapsula a requisiç�o do usu�rio. Uma Interface Model tamb�m � retornada ao usu�rio.

Observaç�o: A Interface Model � um modelo criado a partir de uma requisiç�o de usu�rio, por�m os m�todos mapeados com @RequestMapping podem receber outros par�metros de entrada, tais como HttpServletRequest, Locale, etc.

Como pode ser visto na Listagem 7, o retorno deste m�todo � uma String. Esse retorno dever� ser tratado por algum ViewResolver, que nesse caso � o InternalResourceViewResolver, bem como foi definido no arquivo servlet-context.xml.


<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>

Listagem 7. InternalResourceViewResolver

Dessa forma, o InternalResourceViewResolver define que o retorno dos m�todos anotados com @RequestMapping ser�o os recursos .jsp, que est�o na p�gina WEB-INF/views e possuem o nome que est� sendo retornado como string pelos m�todos mapeados. O padr�o do Spring MVC � colocar as p�ginas .jsp dentro da pasta WEB-INF.

Criaç�o da p�gina home.jsp

A p�gina que ser� retornada ao usu�rio ap�s a requisiç�o � www.DNS_da_aplicaç�o/cliente ser� criada na pasta WEB-INF/views. Antes disso, a pasta views dever� ser criada dentro da pasta WEB-INF, seguindo o padr�o do Spring. Em seguida a p�gina home.jsp dever� ser criada dentro da pasta views, com o conte�do da Listagem 8.


<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
<%@ page session="false"%>
<!DOCTYPE html>
<html>
<head>
<title>Spring MVC</title>
</head>
<body>
  <h1>Ol�!</h1>
  <P>$</P>
</body>
</html>

Listagem 8. P�gina home.jsp

A p�gina home.jsp dever� imprimir para o usu�rio o atributo "mensagem", que foi setado na Interface Model, no m�todo home da classe Controlador.

Executando o projeto

Uma vez configurado e criado, resta apenas usar o Maven para limpeza e criaç�o do projeto. Feito isso, segue a implantaç�o e execuç�o, devendo acess�-la a partir da URL http://localhost:8080/cazuzaneto/.

Imagine criar uma aplicaç�o dessas �no braço� hoje em dia? Cada vez mais precisamos de tempo para agilizar as entregas e perder tempo criando as camadas e os relacionamentos entre elas.

E o que vimos nesse artigo foi apenas um pouco de todo a estrutura do framework Spring MVC. O Container Spring facilita muito, e vimos isso claramente no mapeamento do DispatcherServlet, que � muito flex�vel, j� que pode ser usado com praticamente qualquer fluxo de trabalho, desde que tenha classes adaptadas.

Links:

Spring Framework Reference Documentation: Spring Source 2016
Maven
Spring Tool Suite (STS)
Tomcat