Edson Gonçalves

Olá, tudo bom? Como vão vocês?
Este artigo é o primeiro de uma série ao qual vou ensiná-los a trabalhar com o Spring MVC 3.0.
Nesta primeira parte iremos conhecer o framework Spring MVC 3.0 através de um simples exemplo no estilo “Hello World!”.
Dúvidas e críticas são bem vindas.

Iniciando com o Spring MVC 3.0

Embora no Brasil o mais famoso do Spring Framework seja sua implementação tradicional como contêiner IoC (Inversion of Control – Inversão de Controle[¹]), também temos um excelente framework Web chamado de Spring MVC.

O Spring MVC é um framework open-source que usa como princípio o design MVC  Model 2, ao qual possui suporte, em sua view, também para outras tecnologias como: JSP/JSTL/Tiles, XML/XSLT, Velocity e  FreeMarker. A integração com JasperReports e exportação de documentos para PDF e Excel também estão inclusas.

Em Spring MVC 3.0 – Parte 1, iremos aprender a configurar um ambiente e rodar um exemplo simples utilizando o Spring MVC 3.0.

Download do Framework

Para trabalhar com o Spring MVC 3.0, você deve realizar o download na página: http://www.springsource.org/download. No momento em que este artigo é escrito, a versão utilizada é a Spring Framework 3.0.1.RELEASE. Clique em Download. Neste framework, temos mais de uma opção para baixar. Vamos escolher apenas o framework, cujo tamanho é o menor de todos.

Ao baixar, descompacte o arquivo extraindo todos os JARs existentes no diretório lib.

O ambiente de trabalho

A própria empresa responsável pelo Spring Source, divisão da VMware, possui uma ferramenta completa, criada sobre a plataforma Eclipse, chamada de SpringSource Tools Suite.

Para baixar o SpringSource Tools Suite, clique aqui, preencha o formulário e faça o Download. Como a ferramenta possui uma opção de instalador, use-a como facilitador se desejar. Na própria página onde baixar o arquivo, haverá a explicação da instalação em cada plataforma, em Installation Instructions.

Criando um projeto

No SpringSource Tools Suite, clique no menu File>New>Dynamic Web Project. Na caixa de diálogo New Dynamic Web Project, digite ConhecendoSpringMVC (ou o nome que desejar dar) em Project name.

O SpringSource Tools Suite possui embutido um servidor de aplicações Java Web baseado no Apache Tomcat 6, só que com algumas modificações. Como já o temos por padrão, ele será utilizado no primeiro projeto de exemplo.  Confirme no botão Finish.

O Apache Tomcat no Projeto

Caso deseje configurar o Apache Tomcat 6.0.x, pode ser adicionado através do botão New. Siga os passos a seguir para instalar:

1) Expanda Apache e selecione Apache Tomcat v6.0. Clique em Next;

2) Na etapa seguinte, em Tomcat Server, selecione Download and Install;

3) Antes de baixar, aceite os termos de licença. Confirme no botão Finish.

Determine o local onde será instalado o Apache Tomcat e confirme. Retornando a etapa onde determinamos o local de instalação do Tomcat, se houver erro de não reconhecimento após baixá-lo (veja a execução do download na barra de status da ferramenta), clique em Browse e OK novamente para que seja reconhecido o local de instalação. Por fim, confirme em Finish.

Finalizando o projeto

Após retornar a etapa final do projeto, confirme no botão Finish. O SpringSource Tools Suite pedirá para que você mude de perspectiva. E confirme.

Ao finalizar o assistente, terá um projeto criado e acessível através da view Project Explorer.

Adicionando as bibliotecas ao projeto

Clique com o direito sobre o projeto, na view Project Explorer e selecione, no menu de contexto, o item Properties.

Na caixa de diálogo aberta, vá até Java EE Module Dependencies e adicione os seguintes JARs do Spring Framework que descompactou (através do botão Add JARs):

org.springframework.asm-3.0.1.RELEASE-A.jar
org.springframework.beans-3.0.1.RELEASE-A.jar
org.springframework.context.support-3.0.1.RELEASE-A.jar
org.springframework.context-3.0.1.RELEASE-A.jar
org.springframework.core-3.0.1.RELEASE-A.jar
org.springframework.expression-3.0.1.RELEASE-A.jar
org.springframework.web.servlet-3.0.1.RELEASE-A.jar
org.springframework.web-3.0.1.RELEASE-A.jar

Após adicionar estes JARs, clique em OK para confirmar.

Seu primeiro projeto Spring MVC 3.0

O projeto deste artigo como início será o famoso “Hello World”, necessário para compreendermos as configurações básicas do framework.

Configurando o web.xml

Dê um duplo clique em  Deployment Descriptor na view Project Explorer e altere o arquivo conforme é exibido na Listagem 1:

Listagem 1 – Configurações do Spring Framework no web.xml

<?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" version="2.5">
<display-name>ConhecendoSpringMVC</display-name>
<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>
<welcome-file-list>
<welcome-file>index.jsp</welcome-file>
</welcome-file-list>
</web-app>

Para que o Spring funcione, incluindo o seu módulo MVC, utilizamos o servlet org.springframework.web.servlet.DispatcherServlet, configurado no arquivo web.xml da aplicação.

Por padrão, o Spring MVC procura por beans em arquivos de configuração do próprio framework cujo o princípio de nome possui um similar ao do Servlet configurado no web.xml, seguido de -servlet.xml. A Listagem 2 coloca em prática esta situação, criando o arquivo springmvc-servlet.xml.

Criando o arquivo springmvc-servlet.xml

Para criar o arquivo, clique com o direito do mouse sobre o diretório WebContent/WEB-INF, selecionando no menu de contexto o item XML.

Se estiver utilizando o SpringSource Tool Suite, selecione no menu de contexto o item New>Other.

Na caixa de diálogo New, selecione Spring>Spring Bean Configuration File e prossiga no assistente.

Na segunda etapa, mantenha o diretório WEB-INF selecionado e digite o nome do arquivo de springmvc-servlet.xml. Tirando “–servlet.xml”, o nome springmvc foi definido por você no arquivo web.xml da Listagem 1.

Na terceira etapa, selecione os seguintes namespaces e seus respectivos XSDs:

beans – http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

context – http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd

Listagem 2 – Configurações do arquivo springmvc-servlet.xml

<?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:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd>
<!-- Rastreia as anotacoes encontradas  -->
<context:component-scan base-package="br.com.integrator.web"/>
<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/jsp/"/>
<property name="suffix" value=".jsp"/>
</bean>
</beans>

O arquivo springmvc-servlet.xml é lido graças ao seguinte trecho encontrado dentro do arquivo web.xml:

<servlet>
<servlet-name>springmvc</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springmvc</servlet-name>
<url-pattern>/</url-pattern>
</servlet-mapping>

Com a classe org.springframework.web.servlet.view.InternalResourceViewResolver, pré-fixamos o caminho das páginas em /WEB-INF/jsp/ e com o sufixo “.jsp”. InternalResourceViewResolver é uma subclasse de UrlBasedViewResolver, que suporta JSTL, também usada em nossas views.

Como boa prática recomendada pelo Spring, colocamos as páginas JSP dentro do diretório WEB-INF, impedindo assim seu acesso direto, manualmente, através da URL.

Criando o Controller

Com o direito do mouse sobre  Java Resources:src, selecione no menu de contexto New>Class. Na caixa de diálogo New Java Class, digite o pacote e, em OlaMundoController no campo Name. Confime em Finish a criação da classe.

Altere a classe como mostrado na Listagem 3.

Listagem 3 – A classe OlaMundoController

package br.com.integrator.web;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.stereotype.Controller;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class OlaMundoController {
@RequestMapping("/ola")
public ModelAndView ola() {
String mensagem = "Conhecendo o Spring MVC 3.0";
ModelAndView modelAndView = new ModelAndView("ola");
modelAndView.addObject("mensagem", mensagem);
return modelAndView;
}
}

Desde a versão do Spring MVC 2.5, podemos declarar uma classe controller utilizando simplesmente a anotação @Controller, de org.springframework.stereotype.Controller. Esta anotação permite que o Spring faça uma varredura automatica nas classes através do elemento <context:component-scan>.

Através da anotação @RequestMapping, definimos o caminho HTTP que será utilizado na aplicação, sendo mapeada pela classe. Na prática, todas as chamadas à aplicação contendo “/ola” serão analisadas pela classe controller.

DispatcherServlet (configurado no arquivo web.xml – Listagem 1) é o responsável por receber todas as requisições do cliente, executando a parte comum destes pedidos e delegando implementações específicas para os controllers. Este servlet é responsável por ler todas as configurações e usar a leitura de componentes deste framework.

Após DispatcherServlet receber o pedido e fazer o seu trabalho, ele tenta encontrar um controller, usando a interface HandlerMapping (implementada pelos objetos que definem um mapeamento entre requisições e manipulações).

Ao encontrar o controller, o método handleRequest(HttpServletRequest request, HttpServletResponse response) é chamado com a responsabilidade do pedido e, caso seja necessário, retorna um adequado ModelAndView.  Como padrão, uma instância de ModelAndView consiste em um nome da view e um Map, que contém nomes do bean e objetos correspondentes (como um comando ou formulário, contendo dados).

No caso, o Controller chama a view ola e passa mensagem com o valor de “Conhecendo o Spring MVC 3.0”.

Criando a View

Clique com o direito sobre o diretório WebContent/WEB-INF e selecione, no menu de contexto, o item New>Folder. Chame este diretório de jsp. Estamos fazendo isso porque será onde adicionaremos a página JSP. Este nome foi configurado no arquivo springmvc-servlets.xml, conforme a Listagem 2 no elemento <property value=”/WEB-INF/jsp/”/>.

Clique novamente com o direito do mouse, só que, desta vez,  sobre o diretório jsp recém criado, selecionando New>JSP.

Na caixa de diálogo chame de ola.jsp e clique no bota Finish. Altere como mostrado na Listagem 4.

Listagem 4 – A View ola.jsp

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>${mensagem}</title>
</head>
<body>
<h2>${mensagem}</h2>
</body>
</html>

Para visualizar a página, digite em seu navegador:

http://localhost:8080/ConhecendoSpringMVC/ola

O projeto

O resultado final de todos os arquivos criados e configurados no projeto será como mostrado na Figura 14.

---

[¹] Veja mais sobre IoC e DI no site do Martin Fowler: http://martinfowler.com/articles/injection.html

Tags: Eclipse IDE, MVC, Spring, Spring MVC