Tutorial básico sobre o Spring MVC

O Spring MVC ajuda a construir aplicações web flexíveis e com baixo acoplamento. O padrão de design Modelo-visão-controlador ajuda na separação da lógica de negócio, lógica de apresentação e lógica de navegação. Os Modelos são responsáveis por encapsular os dados da aplicação. As Visões renderizam as repostas ao usuário com a ajuda do objeto modelo. Os Controladores são responsáveis por receber as requisições do usuário e executar os serviços.

A figura abaixo mostra o fluxo de uma requisição no Framework Spring MVC:

Quando uma requisição é enviada ao Framework Spring MVC a seguinte sequência de eventos acontece.

  • DispatcherServlet recebe a requisição em primeiro lugar.
  • DispatcherServlet consulta o HandlerMapping e invoca o Controller associado a requisição.
  • O Controller processa a requisição através da chamada aos métodos apropriados do serviço e retorna um objeto ModeAndView para DispatcherServlet. O objeto ModeAndView contém os dados do modelo e o nome da visão.
  • DispatcherServlet envia o nome de visão para um ViewResolver para que ele encontre o View que deve ser invocado.
  • Agora o DispatcherServlet passará o objeto modelo para o View para que o resultado seja renderizado.
  • O View com a ajuda dos dados do modelo irá renderizar o resultado para o usuário.

Para entender o Framework Spring MVC iremos criar um exemplo simples usando o Eclipse. Nesse artigo, estaremos usando o Eclipse 3.4 com o plugin Spring IDE, Tomcat 6.0 e Spring 3.0 para demonstrar esse exemplo.

Vá para File -> New -> Dynamic Web Project, para criar um projeto web.

Informe o nome do projeto e clique no botão Finish.

Clique com o botão direito na pasta do projeto, e selecione Spring Tools -> Add Spring Project Nature, para adicionar os recursos do Spring ao projeto. Esse recursos estará disponível apenas se você instalar o Spring IDE.

Crie um novo pacote com.vaannila dentro do diretório src. A classe do controlador do Spring estende a classe org.springframework.web.servlet.mvc.AbstractController. Para criar uma nova classe de controlador clique com o botão direito no diretório src e crie um nova classe java, informe o nome da classe do controlador e o nome da super-classe e clique no botão Finish.

Copie o código abaixo dentro da classe HelloWorldController.

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

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class HelloWorldController extends AbstractController {

    private String message;

    @Override
    protected ModelAndView handleRequestInternal(HttpServletRequest request, HttpServletResponse response) throws Exception {
        return new ModelAndView("welcomePage","welcomeMessage", message);
    }

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

}

A classe HelloWorldController tem uma propriedade message que é ajustada através de um método setter. A classe HelloWorldController deve sobrecarregar o método handleRequestInternal() para processar a requisição. Depois do processamento da requisição o método handleRequestInternal() retorna um objeto  ModelAndView de volta ao DispatcherServlet.

O DispatcherSevlet, como o nome indica, é um servlet único que gerencia todo o processo de manipulação de requisições. Quando uma requisição é enviada para o DispatcherServlet ele delega o trabalho através da invocação do controlador apropriado para a requisição. Como qualquer outro servlet, o DispatcherServlet precisa ser configurado no arquivo web.xml como mostrado abaixo.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID" version="2.5">
  	<servlet>
        <servlet-name>dispatcher</servlet-name>
        <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcher</servlet-name>
        <url-pattern>*.htm</url-pattern>
    </servlet-mapping>
    <welcome-file-list>
        <welcome-file>redirect.jsp</welcome-file>
    </welcome-file-list>
</web-app>

Aqui o nome do servlet é dispatcher. Por padrão o DispatcherServlet procurará por um arquivo chamado dispatcher-servlet.xml para carregar a configuração do Spring MVC. Esse nome de arquivo é formado pela concatenação do nome do servlet (“dispatcher“) com “-servlet.xml“. Aqui usamos o padrão url-pattern como “.htm” de modo a esconder a tecnologia de implementação dos usuários.

O arquivo redirect.jsp será invocado em primeiro lugar quando executamos a aplicação web Spring. Esse é o único arquivo  jsp que está localizado fora do diretório WEB-INF e está nesse local para redirecionar para o  DispatcherServlet. Todas as outras visões devem ser armazenadas dentro do diretório  WEB-INF de modo que possam ser invocadas apenas pelo controlador.

Para criar um arquivo de configuração de bean clique com o botão direito do mouse na pasta  WebContent e selecione New -> Other. A seguinte caixa de diálogo aparece:

Selecione o arquivo de configuração do Bean Spring e clique em Next.

Informe o nome do arquivo como “dispatcher-servlet.xml” e clique no botão  Finish.

Agora que o arquivo de configuração do bean foi criado, precisamos configurar as classes do Controller e do ViewResolver. O código abaixo mostra como fazer isso

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

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

    <bean name="/welcome.htm" class="com.vaannila.HelloWorldController" >
        <property name="message" value="Hello World!" />
    </bean>

</beans>

Em primeiro lugar, vamos entender como configurar o controlador

<bean name="/welcome.htm" class="com.vaannila.HelloWorldController" >
    <property name="message" value="Hello World!" />
</bean>

Aqui o atributo name do elemento bean indica o padrão da URL que irá mapear a requisição. Como o atributo  id não pode conter caracteres especiais como  “/” , nós devemos especificar o padrão de URL usando o atributo name do elemento bean. Por padrão, o DispatcherServlet usa BeanNameUrlHandlerMapping para mapear requesições recebidas. O BeanNameUrlHandlerMapping usa o nome do bean como padrão de URL. Como BeanNameUrlHandlerMapping é usado por padrão, você não precisa criar nenhuma configuração separada para isso.

Ajustamos o atributo message da classe HelloWorldController para o método setter correspondente. A classe HelloWorldController é configurada como qualquer outra classe JavaBean no contexto da aplicação JavaBean, assim como qualquer outro JavaBean pode ter valores ajustados através da Injeção de Dependência (Dependency Injection – DI).

O arquivo redirect.jsp irá redirecionar as requisições para DispatcherServlet, que por sua vez consultará o BeanNameUrlHandlerMapping e invocará HelloWorldController. O método handleRequestInternal() da classe HelloWorldController será invocado. Aqui retornaremos a propriedade message sob o nome welcomeMessage e o nome da visão welcomePage para o DispatcherServlet. Como agora só sabemos o nome da visão, para achar a visão a ser invocada precisamos de um ViewResolver.

ViewResolver é configurado usando o código  a seguir:

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

Aqui InternalResourceViewResolver é usado para resolver o nome da visão na visão em si. O prefixo + nome da visão + sufixo lhe fornecerá a localização da visão. Nesse casom a localização da visão é /WEB-INF/jsp/welcomePage.jsp

Os seguintes arquivos de bibliotecas precisam ser adicionados para executar o exemplo.

antlr-runtime-3.0
commons-logging-1.0.4
org.springframework.asm-3.0.0.M3
org.springframework.beans-3.0.0.M3
org.springframework.context-3.0.0.M3
org.springframework.context.support-3.0.0.M3
org.springframework.core-3.0.0.M3
org.springframework.expression-3.0.0.M3
org.springframework.web-3.0.0.M3
org.springframework.web.servlet-3.0.0.M3

Para executar o exemplo, execute o arquivo redirect.jsp. A seguinte página será exibida.

A estrutura do diretório do exemplo é mostrada abaixo.

Você pode baixar e testar o exemplo clicando nos links abaixo.

Source Download -> SpringExample5
War Download -> SpringExample5.war.tar

Traduzido de http://www.vaannila.com/spring/spring-mvc-tutorial-1.html