Spring 3 MVC – Parte 2 – Criando uma aplicação Hello World com o Spring 3.0 MVC

Essa é a parte 2 da série de artigos sobre o Spring 3.0 MVC. No artigo anterior vimos uma introdução a framework, seu ciclo de processamento de requisições e diagrama de sua arquitetura. Nesse artigo, vamos criar uma aplicação Hello World simples usando o Spring 3.0 MVC. Para isso, usaremos o IDE Eclipse.

Coisas que vamos precisar

Antes de começarmos o desenvolvimento de nosso programa Hello World exemplo usando o Spring MVC, precisamos de algumas ferramentas.

  1. JDK 1.5 ou superior (download)
  2. Tomcat 5.x ou superior ou qualquer outro servidor de aplicações (Glassfish, JBoss, Websphere, Weblogic etc) (download)
  3. Eclipse 3.2.x ou superior (download)
  4. Arquivos JAR do Spring 3.0 MVC:(download). Abaixo segue a lista dos arquivos JAR necessários para essa aplicação.
    • commons-logging-1.0.4.jar
    • jstl-1.2.jar
    • org.springframework.asm-3.0.1.RELEASE-A.jar
    • org.springframework.beans-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

Observe que dependendo da versão atual do Spring MVC o número da versão nos arquivos JAR acima pode mudar.

Nosso objetivo

Nosso objetivo é criar uma aplicação Spring MVC básica usando a última versão (3.0). Haverá uma página index que exibirá um link “Say Hello” ao usuário. Clicando nesse link, o usuário será redirecionado para uma outra página chamada hello que exibirá a mensagem “Hello World, Spring 3.0!”.

spring-mvc-hello-world-screen

Começando

Vamos iniciar o desenvolvimento de nossa primeira aplicação baseado no Spring 3.0 MVC.
Abra o Eclipse e vá para File -> New -> Project e selecione Dynamic Web Project na tela do assistente New Project.

Dynamic Web Project in Eclipse

Após selecionar Dynamic Web Project, clique em Next.

eclipse-dynamic-web-project

Insira um nome para o projeto. Por exemplo Spring3MVC. Uma vez que isso foi feito, selecione o ambiente alvo (e.g. Apache Tomcat v6.0). Isso é feito para rodar o projeto dentro do ambiente do Eclipse. Depois disso clique em Finish.

Quando o projeto é criado, você poderá visualizar sua estrutura no Project Explorer.

spring-mvc-3-eclipse-project

Agora copie todos os arquivos JAR necessários para a pasta WebContent > WEB-INF > lib. Crie esse pasta se ela não existir.

spring-3-mvc-jar-files

A classe Controller do Spring

Precisaremos de um classe controller do Spring MVC que irá processar as requisições e exibirá a mensagem “Hello World”. Para isso criaremos um pacote net.viralpatel.spring3.controller na paste de código fonte. Esse pacote irá conter o arquivo do controller.

spring-3-package

Crie uma classe chamada HelloWorldController no pacote net.viralpatel.spring3.controller e copie o código a seguir nele.

Arquivo: net.viralpatel.spring3.controller.HelloWorldController

package net.viralpatel.spring3.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class HelloWorldController {
    @RequestMapping("/hello")
    public ModelAndView helloWorld() {
        String message = "Hello World, Spring 3.0!";
        return new ModelAndView("hello", "message", message);
    }
}

Observe que teremos temos algumas anotações na classe HelloWorldController com @Controller e@RequestMapping("/hello") nas linhas  7 e 10. Quando o Spring escanear o nosso pacote, reconhecerá esse bean como um bean do tipo controller para processamento de requisições. A anotação @RequestMapping diz ao Spring que esse controller deve processar todas as requisições que começem com /hello na URL. Isso inclui /hello/*e /hello.html.

O método helloWorld() retorna um objeto ModelAndView . O objeto ModelAndView tenta determinar um view chamado “hello” e o modelo de dados é passado de volta ao navegador de forma que podemos acessar os dados de dentro do JSP. O nome lógico do view irá determinar o caminho "/WEB-INF/jsp/hello.jsp". Iremos discutir brevemente como o nome lógico “hello” que é retornado pelo objeto ModelAndView é mapeado para o caminho /WEB-INF/jsp/hello.jsp.

O objeto ModelAndView contém também uma mensagem com a chave “message” e o valor “Hello World, Spring 3.0!”. Esse é o dado que passaremos para nosso view. Normalmente esse será um objeto na forma de um bean do Java que conterá os dados que serão exibidos em nosso  view. Aqui iremos simplesmente retornar uma String.

Criando o arquivo JSP

Para exibir a mensagem “Hello World” criaremos um arquivo JSP; Observe que esse JSP é criado na pasta /WEB-INF/jsp. Crie o arquivo hello.jsp sob o diretório WEB-INF/jsp e copie o código abaixo nele.

Arquivo: WEB-INF/jsp/hello.jsp

<html>
<head>
    <title>Spring 3.0 MVC Series: Hello World - ViralPatel.net</title>
</head>
<body>
    ${message}
</body>
</html>

O JSP acima simplesmente exibe uma mensagem usando a expressão ${message}. Observe que o nome “message” é um que foi configurado no objeto ModelAndView com a String da mensagem.

Também precisamos de um arquivo index.jsp que será o ponto de partida de nossa aplicação. Crie um arquivo index.jsp sob o diretório WebContent de seu projeto e copie o código abaixo nele.

Arquivo: WebContent/index.jsp

<html>
<head>
    <title>Spring 3.0 MVC Series: Index - ViralPatel.net</title>
</head>
<body>
    <a href="hello.html">Say Hello</a>
</body>
</html>

Mapeando o Spring MVC no WEB.xml

Como discutido no artigo anterior (Introdução ao Spring 3.0 MVC), o ponto de partida de uma aplicação Spring MVC será o Servlet definido no descritor de carregamento “deployment descriptor” (web.xml). Por isso definiremos uma entrada da classe org.springframework.web.servlet.DispatcherServlet no arquivo web.xml.
Abra o arquivo web.xml que está sob o diretório WEB-INF folder e copie o código abaixo nele.

Arquivo: WEB-INF/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"
    id="WebApp_ID" version="2.5">
    <display-name>Spring3MVC</display-name>
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
    <servlet>
        <servlet-name>spring</servlet-name>
        <servlet-class>
            org.springframework.web.servlet.DispatcherServlet
        </servlet-class>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring</servlet-name>
        <url-pattern>*.html</url-pattern>
    </servlet-mapping>
</web-app>

O código acima do web.xml mapeará DispatcherServlet com o padrão de URL *.html. Note também que definimos index.jsp como arquivo de boas vindas.

Uma coisa a ser observada aqui é que o nome do Servlet especificado na tag <servlet-name> do  web.xml. Uma vez que DispatcherServlet é inicializado, ele procurará por uma arquivo com o nome [servlet-name]-servlet.xml no diretório WEB-INF de nossa aplicação Web. Nesse exemplo, o framework procurará por um arquivo chamado spring-servlet.xml.

Arquivo de configuração do Spring

Crie um arquivo chamado spring-servlet.xml no diretório WEB-INF e copie o código abaixo nele.

Arquivo: WEB-INF/spring-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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context"
    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">
    <context:component-scan
        base-package="net.viralpatel.spring3.controller" />
        
    <bean id="viewResolver"
        class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass"
            value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

No arquivo de configuração acima, definimos uma tag <context:component-scan>. Isso permitirá que o Spring carregue todos os componentes do pacote net.viralpatel.spring3.controller e de todos os seus pacotes filhos. Isso irá carregar nossa clase HelloWorldController. Definimos também um bean viewResolver. Esse bean irá determinar e adicionar o prefixo /WEB-INF/jsp/ e o sufixo .jsp ao view no ModelAndView. Observe que em nossa classe HelloWorldController, retornamos um objeto ModelAndView com o nome “hello”. Isso será transformado no caminho /WEB-INF/jsp/hello.jsp.

Isso é tudo pessoal

Você pode agora rodar a aplicação para visualizar o resultado. Aqui assumimos que você já configurou o Tomcat com o Eclipse. Tudo o que você precisa fazer é:

Abra a view Server em Windows > Show View > Server. Clique com o botão direito do mouse nesse view e selecione New > Server e adicione os detalhes do servidor.

Para rodar o projeto, clique com o botão direito do mouse sobre o nome do projeto no Project Explorer e selecione Run as > Run on Server (Atalho: Alt+Shift+X, R)

spring-mvc-hello-world-screen

Baixar o código fonte

Clique aqui para baixar o código fonte desse artigo