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.
Figura 1 - Download do Spring Framework em sua página oficial
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.
Figura 2 - Criando o projeto Conhecendo SpringMVC
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;
Figura 3 - Selecionando o Apache Tomcat v6.0 para adicionar a ferramenta
2) Na etapa seguinte, em Tomcat Server, selecione Download and Install;
Figura 4 - Baixando e Instalando o servidor Apache Tomcat
3) Antes de baixar, aceite os termos de licença. Confirme no botão Finish.
Figura 5 - Termos de licença para a instalação automática do Tomcat no SO Windows 7
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.
Figura 6 - Associando a perspectiva ao tipo de projeto a ser criado
Ao finalizar o assistente, terá um projeto criado e acessível através da view Project Explorer.
Figura 7 - Projeto com sua estrutura gerada
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.
Figura 8 - Bibliotecas do Spring Framework adicionadas ao projeto
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.
Figura 9 - Criando um arquivo de configuração do Spring
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.
Figura 10 - Definindo o nome do arquivo
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
Figura 11 - Seleção do primeiro namespace do arquivo de configuração do Spring MVC
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.
Figura 12 - Criação da classe OlaMundoController
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
Figura 13 - Resultado da saída gerada pelo Spring MVC 3.0
O projeto
O resultado final de todos os arquivos criados e configurados no projeto será como mostrado na Figura 14.
Figura 14 – O projeto completo
[¹] Veja mais sobre IoC e DI no site do Martin Fowler: http://martinfowler.com/articles/injection.html
Tags: Eclipse IDE, MVC, Spring, Spring MVC
