Introdução ao Spring Web MVC
This tutorial needs a review. You can open a JIRA issue, or edit it in GitHub following these contribution guidelines. |
Este documento mostra como construir uma aplicação Web MVC simples usando o Spring Framework. A aplicação permite que um usuário indique seu nome em um campo de texto e, ao clicar em OK, o nome seja retornado e exibido em uma segunda página com uma saudação de boas-vindas.
O Spring Framework é um framework de aplicação de código-fonte aberto popular que pode facilitar o desenvolvimento do Java EE. Ele consiste em um contêiner, um framework para gerenciar componentes, e um conjunto de serviços de snap-in para interfaces de usuário, transações e persistência da Web. Uma parte do Spring Framework é o Spring Web MVC, um framework MVC extensível para criação de aplicações Web.
O IDE oferece suporte incorporado para Spring Framework 4.x e 3.x. As bibliotecas de framework são fornecidas com o IDE e adicionadas automaticamente ao classpath do projeto quando o framework é selecionado. As definições de configuração são fornecidas, tais como nomeação e mapeamento do DispatcherServlet
do Spring Web MVC. A biblioteca JSTL pode, como opção, ser registrada na criação do projeto. O suporte para arquivos de configuração de bean Spring XML também é fornecido, incluindo a seguinte funcionalidade:
-
Autocompletar código. Chamada nos arquivos de configuração Spring XML para classes Java assim como referências de bean.
-
Navegação. Hiperlink de classes e propriedades Java mencionadas nas definições de bean Spring, bem como hiperlink para outras referências de bean Spring.
-
Refatoração. Renomeação de referências a classes Java nos arquivos de configuração Spring XML.
Para obter mais informações sobre o Spring Framework, visite http://www.springsource.org/. Para obter uma explicação detalhada de como os artefatos do Spring Framework se comportam e interagem com outros objetos em uma aplicação, consulte a Documentação de Referência do Spring Framework oficial ou consulte a Documentação da API do Spring Framework.

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.
Software ou Recurso | Versão Necessária |
---|---|
Java EE 7.2, 7.3, 7.4, 8.0 |
|
versão 7 ou 8 |
|
3.x, 4.x |
Observações:
-
A instalação Java do IDE permite, como opção, baixar e registrar o GlassFish Server com o IDE.
-
Se você precisar comparar seu projeto com uma solução que funciona, faça download da aplicação de amostra.
Configurando um Novo Projeto com Suporte a Spring Web MVC
Criando um Projeto de Esqueleto do Spring Web MVC
Comece criando um novo projeto para uma aplicação Web usando o Spring Framework.
-
Selecione Novo Projeto (Ctrl-Shift-N; ⌘-Shift-N no Mac) no menu Arquivo do IDE. Selecione a categoria Java Web e, em Projetos, selecione Aplicação Web. Clique em Próximo.
-
Em Nome do Projeto, digite HelloSpring. Clique em Próximo.
-
Na Etapa 3: Servidor e Definições, desmarque a opção Ativar Injeção de Dependência e Contextos, já que você não está trabalhando com a especificação JSR-299 neste tutorial.
-
Confirme se o GlassFish server está selecionado na lista drop-down Servidor. Clique em Próximo.
A versão do Java EE depende da versão do servidor que está selecionada. A versão default do Java EE é Java EE 7 Web quando o servidor selecionado for GlassFish Server 4.0
-
Na Etapa 4, no painel Frameworks, selecione Spring Web MVC.
-
Selecione Spring Framework 3.x na lista drop-down Biblioteca de Springs.

Observe que o IDE permite adicionar a biblioteca do Spring 4.x ao projeto, mas neste tutorial você usará SimpleFormController, que não é suportado no Spring 4.x. Além disso, quando você selecionar Spring Web MVC, lembre-se de que a biblioteca JSTL (JavaServer Pages Standard Tag Library) é adicionada ao classpath durante a criação do projeto por padrão. Desmarque essa opção (conforme indicado na captura de tela acima), já que o JSTL não é necessário para este tutorial.
-
Clique na guia Configuração e observe que o assistente permite especificar o nome e o mapeamento do servlet Spring Dispatcher.

-
Clique em Finalizar. O IDE cria um projeto para a aplicação inteiro, incluindo todos os metadados, assim como o script de construção Ant do projeto que você pode inspecionar na janela Arquivos (Ctrl-2; ⌘-2 no Mac). Você pode exibir a estrutura do modelo na janela Projetos (Ctrl-1; ⌘-1 no Mac). Observe também que quatro arquivos são abertos por default no editor do IDE:
dispatcher-servlet.xml
,applicationContext.xml
,redirect.jsp
eindex.jsp
. -
Na janela Projetos, expanda o novo nó Bibliotecas do projeto e observe que JARs do Spring estão incluídos no classpath do projeto.

Executando o Projeto de Esqueleto
Antes de fazer quaisquer alterações nos arquivos do projeto, tente executar o novo projeto no IDE:
-
Clique em Executar Projeto (
) na barra de ferramentas principal do IDE. O IDE inicia automaticamente o GlassFish Server se ele ainda não estiver sendo executado, compila o projeto e o implanta no servidor. Observe as saída exibida na janela de Saída do IDE (Ctrl-4; ⌘-4 no Mac). A saída gerada termina com a mensagem
BUILD SUCCESSFUL.

O browser default do IDE é iniciado e você vê o conteúdo da view da página de boas-vindas (/WEB-INF/jsp/index.jsp
).

Quando você executa o projeto no IDE, o projeto é compilado e implantado no servidor e, em seguida, aberto no browser default. Além disso, o IDE fornece uma funcionalidade Implantar ao Salvar, que é ativado por default em projetos Web. Quando você salva arquivos no editor, o projeto é automaticamente recompilado e implantado no servidor. Para exibir alterações, você pode, simplesmente, atualizar as páginas no browser.
Para entender o que acabou de acontecer, comece examinando o descritor de implantação do projeto (web.xml
). Para abrir esse arquivo no Editor de Código-Fonte, clique com o botão direito do mouse no nó WEB-INF
> web.xml
na janela Projetos e selecione Editar. O ponto de entrada default da aplicação é redirect.jsp
:
<welcome-file-list>
<welcome-file>redirect.jsp</welcome-file>
</welcome-file-list>
Em redirect.jsp
, existe uma instrução de redirecionamento que aponta todas as solicitações para index.htm
:
<% response.sendRedirect("index.htm"); %>
No descritor de implantação, observe que todas as solicitações de padrões de URL que correspondem a *.htm
são mapeadas para `DispatcherServlet` do Spring.
<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>
O nome totalmente qualificado do servlet dispatcher, conforme mostrado acima, é org.springframework.web.servlet.DispatcherServlet
. Essa classe está contida na biblioteca do Spring, que foi adicionada ao classpath do projeto quando o projeto foi criado. Você pode verificar isso na janela Projetos, fazendo uma busca detalhada no nó Bibliotecas. Localize o arquivo spring-webmvc-3.1.1.RELEASE.jar
e, em seguida, expanda para encontrar org.springframework.web.servlet
> DispatcherServlet
.
A classe DispatcherServlet
manipula as solicitações de entrada com base nas definições de configuração encontradas em dispatcher-servlet.xml
. Abra dispatcher-servlet.xml
, clicando em sua guia no editor. Observe o código a seguir:
<bean id="urlMapping" class="org.springframework.web.servlet.handler.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.html[+SimpleUrlHandlerMapping+]">
<property name="mappings">
<props>
<prop key="/index.htm">indexController</prop>
</props>
</property>
</bean>
<bean id="viewResolver"
class="org.springframework.web.servlet.view.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/view/InternalResourceViewResolver.html[+InternalResourceViewResolver+]"
p:prefix="/WEB-INF/jsp/"
p:suffix=".jsp" />
<bean name="indexController"
class="org.springframework.web.servlet.mvc.link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html[+ParameterizableViewController+]"
p:viewName="index" />
Três beans são definidos nesse arquivo: indexController
, viewResolver
e urlMapping
. Quando a DispatcherServlet
recebe uma solicitação que coincide com *.htm
tal como index.htm
, ela procura um controle no urlMapping
que possa acomodar a solicitação. Acima, você vê que existe uma propriedade mappings
que vincula /index.htm
a indexController
.
O ambiente de runtime procura a definição de um bean chamado indexController
, que é convenientemente fornecido pelo projeto de esqueleto. Observe que indexController
estende `ParameterizableViewController`. Essa é uma outra classe fornecida pelo Spring, que simplesmente retorna uma view. Acima, observe que p:viewName="index"
especifica o nome da view lógica, que é resolvida por meio de viewResolver
acrescentado-se o prefixo /WEB-INF/jsp/
e o sufixo .jsp
. Isso permite que o runtime localize o arquivo no diretório da aplicação e responda com a view da página de boas-vindas (/WEB-INF/jsp/index.jsp
).
Visão Geral da Aplicação
A aplicação criada é composta de duas páginas JSP (que se chamam views na terminologia MVC). A primeira view contém um form HTML com um campo de entrada solicitando o nome do usuário. A segunda view é uma página que exibe simplesmente uma mensagem hello contendo o nome do usuário.
As views são gerenciadas por um controlador, que recebe as solicitações para a aplicação e decide quais views retornar. Ele também passa para as views as informações que precisam exibir (isso é chamado de modelo). Esse controlador de aplicação é chamado de HelloController
.
Em uma aplicação complexa da Web, a lógica de negócios não está contida diretamente no controlador. Em vez disso, outra entidade, denominada serviço, é utilizada pelo controlador sempre que ele precisar realizar a lógica de negócios. Em nossa aplicação, a lógica de negócios limita-se ao processamento da mensagem hello, sendo assim, para essa finalidade, você cria um HelloService
.
Implementando um Serviço
Agora que você tem certeza de que seu ambiente está configurado corretamente, você pode começar a estender o projeto de esqueleto de acordo com as suas necessidades. Comece criando a classe HelloService
.
-
Clique no botão Novo Arquivo (
) na barra de ferramentas do IDE. (Como alternativa, pressione Ctrl-N; ⌘-N no Mac.)
-
Selecione a categoria Java, Classe Java e clique em Próximo.
-
No assistente de Nova Classe Java exibido, digite HelloService no Nome da Classe e service no Nome do Pacote para criar um novo pacote para a classe.
-
Clique em Finalizar. O IDE cria a nova classe e a abre no editor.
A classe HelloService
realiza um serviço muito simples. Ela pega um nome como parâmetro, prepara e retorna uma String
que inclui o nome. No editor, crie o seguinte método sayHello()
para a classe (alterações em negrito).
public class HelloService {
*public static String sayHello(String name) {
return "Hello " + name + "!";
}*
}
Implementando o Controlador e o Modelo
Você pode usar um `SimpleFormController` para manipular dados do usuário e determinar qual view retornar.
*Observação: *SimpleFormController é obsoleto no Spring 3.x. Ele é utilizado neste tutorial para fins de demonstração. Entretanto, os controladores anotados devem ser utilizados em vez dos arquivos XML.
-
Abra o assistente de Novo Arquivo pressionando Ctrl-N (⌘-N no Mac). Em Categorias, selecione Spring Framework em Tipos de Arquivos e Controlador de Form Simplificado.

O NetBeans IDE fornece modelos para vários artefatos do Spring, incluindo o Arquivo de Configuração do Spring XML, o `AbstractController` e o `SimpleFormController`.
-
Clique em Próximo.
-
Chame a classe de HelloController e crie um novo pacote para ela, digitando controller no campo de texto Pacote. Clique em Finalizar. O IDE cria a nova classe e a abre no editor.
-
Especifique as propriedades do controlador, removendo o comentário dos métodos setter exibidos por default no modelo da classe. Para remover os comentários do snippet de código, realce o código como na imagem a seguir e pressione Ctrl-/ (⌘-/ no Mac).

Pressionar Ctrl-/ (⌘-/ no Mac) alterna entre os comentários no editor.
-
Faças as alterações a seguir (alterações em negrito).
public HelloController() {
link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandClass(java.lang.Class)[+setCommandClass+](*Name*.class);
link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandName(java.lang.String)[+setCommandName+]("*name*");
link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setSuccessView(java.lang.String)[+setSuccessView+]("*hello*View");
link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)[+setFormView+]("*name*View");
}
A definição de FormView
permite definir o nome da view utilizada para exibir o form. Essa é a página que contém o campo de texto que permite que os usuários digitem seus nomes. A configuração de SuccessView
, da mesma forma, permite que você defina o nome da view que deve ser exibida durante um envio bem-sucedido. Quando você configura CommandName
, você define o nome do comando no modelo. Nesse caso, o comando é o objeto do form com os parâmetros de solicitação vinculados a ele. A configuração de CommandClass
permite que você defina o nome da classe do comando. Uma instância dessa classe é preenchida e validada em cada solicitação.
Observe que um erro é sinalizado para Name
no método setCommandClass()
:

Você precisa criar a classe Name
como um bean simples para manter as informações de cada solicitação.
-
Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Nova > Classe Java. O assistente de Nova Classe Java é exibido.
-
Digite Name para o Nome da Classe, e, para Pacote, selecione controller na lista drop-down.
-
Clique em Finalizar. A classe
Name
é criada e aberta no editor. -
Para a classe
Name
, crie um campo denominadovalue
e, em seguida, crie os métodos acessadores (por exemplo, os métodos getter e setter) para esse campo. Inicie declarando o campovalue
:
public class Name {
*private String value;*
}
Para digitar “private” rapidamente, você pode digitar “pr” e pressionar Tab. O modificador de acesso “private” é automaticamente adicionado à linha. Esse é um exemplo de como utilizar os modelos de código do editor. Para obter uma lista completa de modelos de código, selecione Ajuda > Cartão de Atalhos do Teclado.
O IDE pode criar métodos do assessor para você. No editor, clique com o botão direito do mouse em `valor` e selecione Inserir Código (ou pressione Alt-Insert; Ctrl-I no Mac). No menu pop-up, escolha Getter e Setter.

-
Na caixa de diálogo exibida, selecione a opção
value : String`e clique em OK. Os métodos `getValue()
esetValue()
são adicionados à classeName
:
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}
-
Pressione Ctrl-Tab e selecione
HelloController
para retornar à classeHelloController
. Observe que o indicador de erro anterior desapareceu, mas a classeName
existe agora. -
Delete o método
doSubmitAction()
e remova os comentários do método `onSubmit()`. O métodoonSubmit()
permite que você crie seu próprioModelAndView
, que é o necessário aqui. Faça as seguintes alterações:
@Override
protected ModelAndView onSubmit(
HttpServletRequest request,
HttpServletResponse response,
Object command,
BindException errors) throws Exception {
Name name = (Name) command;
ModelAndView mv = new ModelAndView(getSuccessView());
mv.addObject("helloMessage", helloService.sayHello(name.getValue()));
return mv;
}
Conforme indicado acima, o command
é reconvertido como um objeto Name
. Uma instância de ModelAndView
é criada, e a view de sucesso é obtida por meio de um getter em SimpleFormController
. Finalmente, o modelo é preenchido com os dados. O único item em nosso modelo é a mensagem hello obtida do HelloService
criado anteriormente. Use o método addObject()
para adicionar a mensagem hello ao modelo sob o nome helloMessage
.
-
Corrija os erros de importação clicando com o botão direito do mouse no editor e selecionando Corrigir importações (Ctrl-Shift-I; ⌘-Shift-I no Mac).

Observação. Certifique-se de que as opções * org.springframework.validation.BindException
* e * org.springframework.web.servlet.ModelAndView
* estejam selecionadas na caixa de diálogo Corrigir Todas as Importações.
-
Clique em OK. A instrução de importação a seguir será adicionada ao início do arquivo:
import link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/ModelAndView.html[+org.springframework.web.servlet.ModelAndView+];
Conforme informado na documentação da API, essa classe "representa um modelo e uma view retornados por um handler, a serem resolvidos por um DispatcherServlet
. A view pode tomar a forma de um nome de view de String
, que precisará ser resolvido por um objeto ViewResolver
, como alternativa, um objeto View
poderá ser especificado diretamente. O modelo é um Map
, que permite o uso de vários objetos, classificados por nome".
Observe que nesse estágio, nem todos os erros são corrigidos, pois a classe ainda não pode identificar a classe HelloService
e não utiliza seu método sayHello()
.
-
No
HelloController
, declare um campo privado chamadoHelloService
:
private HelloService helloService;
Em seguida, crie um método setter público para o campo:
public void setHelloService(HelloService helloService) {
this.helloService = helloService;
}
Finalmente, clique com o botão direito do mouse no editor e selecione Corrigir Importações (Ctrl-Shift-I; ⌘-Shift-I no Mac). A instrução a seguir será adicionada ao início do arquivo:
import service.HelloService;
Todos os erros deverão ser corrigidos agora.
-
Registre
HelloService
emapplicationContext.xml
. AbraapplicationContext.xml
no editor e insira a seguinte declaração de bean:
<bean name="helloService" class="service.HelloService" />
O suporte a Spring no IDE inclui a funcionalidade autocompletar código nos arquivos de configuração XML para classes Java, bem como nas referências de bean. Para chamar a funcionalidade autocompletar código, pressione Ctrl-Espaço ao trabalhar no editor:

-
Registre
HelloController
emdispatcher-servlet.xml
. Abradispatcher-servlet.xml
no editor e insira a seguinte declaração de bean:
<bean class="controller.HelloController" p:helloService-ref="helloService"/>
Implementando as Views
Para implementar a view desse projeto, você precisa criar duas páginas JSP. A primeira, que você pode chamar de nameView.jsp
, serve como a página de boas-vindas e permite que os usuários insiram um nome. A outra página, helloView.jsp
, exibe uma mensagem de saudação que inclui o nome de entrada. Comece criando helloView.jsp
.
-
Na janela Projetos, clique com o botão direito do mouse no nó WEB-INF > `jsp ` e selecione Nova > JSP. O assistente de Novo Arquivo JSF será aberto. Chame o arquivo de helloView.
-
Clique em Finalizar. A nova página JSP será criada na pasta
jsp
e aberta no editor. -
No editor, altere o título do arquivo para
Hello
e altere a mensagem de saída para recuperar ahelloMessage
do objetoModelandView
criado emHelloController
.
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>*Hello*</title>
</head>
<body>
<h1>*${helloMessage}*</h1>
</body>
-
Crie outra página JSP da mesma maneira conforme acima, mas nomeie-a como
nameView
. -
No editor, adicione a declaração da biblioteca de tags do Spring a seguir a
nameView.JSP
.
<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
Isso importa a biblioteca de tags do Spring, que contém tags úteis para a implementação de views como páginas JSP.
-
Altere o conteúdo das tags
<title>
e<h1>
para que se leia:Enter Your Name
. -
Insira o código a seguir abaixo das tags
<h1>
:
<spring:nestedPath path="name">
<form action="" method="post">
Name:
<spring:bind path="value">
<input type="text" name="${status.expression}" value="${status.value}">
</spring:bind>
<input type="submit" value="OK">
</form>
</spring:nestedPath>
spring:bind permite que você vincule uma propriedade de bean. A tag de vinculação fornece um status de e valor de vinculação, que você utiliza como o nome e o valor do campo de entrada. Dessa forma, quando o form for enviado, o Spring saberá como extrair o valor enviado. Aqui, nossa classe de comando (controller.Name
) possui uma propriedade value
, portanto, a definição de path
como value
.
spring:nestedPath permite que você anexe um caminho especificado a um bean. Sendo assim, quando usado com spring:bind
conforme mostrado acima, o caminho para o bean se torna: name.value
. Como você deve lembrar, o nome do comando de HelloController
é name
. Portanto, esse caminho se refere à propriedade value
de um bean chamado name
no escopo da página.
-
Altere o ponto de entrada relativo da aplicação. Atualmente, o ponto de entrada do projeto ainda é
index.htm
que, conforme descrito em Executando o Projeto de Esqueleto acima, redireciona paraWEB-INF/jsp/index.jsp
. Você pode especificar um ponto de entrada para o projeto quando ele é implantado e executado. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Propriedades. A caixa de diálogo Propriedades do Projeto será exibida. Em Categorias, selecione Executar. No campo URL Relativo, digite/hello.htm
, em seguida, clique em OK.
Nesse momento, você deve estar pensando onde o mapeamento de hello.htm
para HelloController
se encontra. Você não adicionou um mapeamento para o bean urlMapping
, como é o caso de index.htm
, a página de boas-vindas do projeto de esqueleto. Isso é possível com um pouco da mágica do Spring fornecida a seguir pela definição do bean em dispatcher-servlet.xml
:
<bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
Esse bean é responsável por criar automaticamente um mapeamento de URL para todos os controladores registrados no arquivo. Ele pega o nome de classe totalmente qualificado do controlador (em nosso caso, controller.HelloController
) e retira o nome do pacote e o sufixo Controller
, em seguida, usa o resultado como um mapeamento de URL. Portanto, para HelloController
, ele cria um mapeamento hello.htm
. Entretanto, essa mágica não funciona para controladores que estão incluídos no Spring Framework, como o ParameterizableViewController
. Eles requerem mapeamento explícito.
-
Na janela Projetos, clique com o botão direito do mouse no nó do projeto e selecione Executar. Isso compilará, implantará e executará o projeto. Seu browser default abrirá, exibindo
hello.htm
como onameView
do projeto:

Informe seu nome no campo de texto e clique Enter. O helloView
é exibido com uma mensagem de saudação:

Consulte Também
Isso inclui a Introdução ao Spring Framework no NetBeans IDE. Este documento demonstrou como construir uma aplicação Web MVC simples no NetBeans IDE utilizando o Spring Framework e apresentou a você a interface do IDE para o desenvolvimento de aplicações Web.
Recomendamos que você continue aprendendo sobre o Spring Framework trabalhando em outros tutoriais do NetBeans IDE, como Desenvolvendo uma aplicação Spring Framework MVC passo a passo utilizando o NetBeans e o GlassFish Server. Esse é o tutorial oficial do Spring Framework de Thomas Risberg que foi adaptado para o NetBeans IDE por Arulazi Dhesiaseelan.
Muitos dos recursos de Módulo do Spring NetBeans também podem ser aplicados a aplicações Spring Framework não baseados na Web.
Para outros tutoriais relacionados, consulte os seguintes recursos:
-
Adicionando Suporte a um Framework da Web Um guia básico que descreve como adicionar suporte instalando um plug-in de framework da Web usando a Central de Atualização do NetBeans.
-
Introdução ao JavaServer Faces 2.0. Demonstra como adicionar suporte do JSF 2.0 a um projeto existente, beans gerenciados por fios e como aproveitar os modelos de Facelets.