// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     "License"); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Introdução ao Spring Web MVC
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Introdução ao Spring Web MVC - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Introdução ao Spring Web MVC

Este documento mostra como construir uma aplicação Web link:http://www.oracle.com/technetwork/articles/javase/index-142890.html[+MVC+] simples usando o link:http://www.springframework.org/[+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 link:http://www.springsource.org/[+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 link:http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/[+Documentação de Referência do Spring Framework+] oficial ou consulte a link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/[+Documentação da API do Spring Framework+].


image::images/netbeans-stamp-80-74-73.png[title="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0"]


*Para concluir este tutorial, você precisa dos seguintes recursos e softwares.*

|===
|Software ou Recurso |Versão Necessária 

|link:https://netbeans.org/downloads/index.html[+NetBeans IDE+] |Java EE 7.2, 7.3, 7.4, 8.0 

|link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+JDK (Java Development Kit)+] |versão 7 ou 8 

|link:http://glassfish.dev.java.net/public/downloadsindex.html[+GlassFish Server+] |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, link:https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%2520Web%252FHelloSpring69.zip[+faça download da aplicação de amostra+].


[[setting]]
== Configurando um Novo Projeto com Suporte a Spring Web MVC

* <<creating,Criando um projeto de Esqueleto do Spring Web MVC>>
* <<running,Executando o Projeto de Esqueleto>>


[[creating]]
=== Criando um Projeto de Esqueleto do Spring Web MVC

Comece criando um novo projeto para uma aplicação Web usando o Spring Framework.

1. Selecione Novo Projeto (Ctrl-Shift-N; &amp;#8984-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.
2. Em Nome do Projeto, digite *HelloSpring*. Clique em Próximo.
3. 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 link:http://jcp.org/en/jsr/detail?id=299[+JSR-299+] neste tutorial.
4. 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


[start=5]
. Na Etapa 4, no painel Frameworks, selecione Spring Web MVC.

[start=6]
. Selecione *Spring Framework 3.x* na lista drop-down Biblioteca de Springs. 

image::images/frameworks-window.png[title="Spring Web MVC exibido no painel Frameworks"]

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.


[start=7]
. Clique na guia Configuração e observe que o assistente permite especificar o nome e o mapeamento do servlet Spring Dispatcher.

image::images/spring-configuration.png[title="Especifique o nome e o mapeamento do servlet Spring Dispatcher na guia Configuração"]

[start=8]
. 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; &amp;#8984-2 no Mac). Você pode exibir a estrutura do modelo na janela Projetos (Ctrl-1; &amp;#8984-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` e `index.jsp`.

[start=9]
. Na janela Projetos, expanda o novo nó Bibliotecas do projeto e observe que JARs do Spring estão incluídos no classpath do projeto.

image::images/spring-libraries.png[title="Os JARs Spring são listados no nó das Bibliotecas do projeto"]


[[running]]
=== Executando o Projeto de Esqueleto

Antes de fazer quaisquer alterações nos arquivos do projeto, tente executar o novo projeto no IDE:

1. Clique em Executar Projeto (image:images/run-project-btn.png[]) 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; &amp;#8984-4 no Mac). A saída gerada termina com a mensagem `BUILD SUCCESSFUL.` 

image::images/output.png[title="A janela de Saída exibe informações ao executar o projeto"] 

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`).

image::images/browser-output.png[title="A saída de página de boas-vindas é exibida no browser"]

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`:


[source,xml]
----

<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`:


[source,java]
----

<% 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 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html[+`DispatcherServlet`+] do Spring.


[source,xml]
----

<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:


[source,xml]
----

<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 link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html[+`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`).


[[overview]]
== Visão Geral da Aplicação

A aplicação criada é composta de duas páginas JSP (que se chamam _views_ na terminologia link:http://www.oracle.com/technetwork/articles/javase/index-142890.html[+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`.

1. Clique no botão Novo Arquivo (image:images/new-file-btn.png[]) na barra de ferramentas do IDE. (Como alternativa, pressione Ctrl-N; ⌘-N no Mac.)
2. Selecione a categoria *Java*, *Classe Java* e clique em Próximo.
3. 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.
4. 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*).


[source,java]
----

public class HelloService {

    *public static String sayHello(String name) {
        return "Hello " + name + "!";
    }*
}
----


[[controller]]
== Implementando o Controlador e o Modelo

Você pode usar um link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html[+`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.

1. 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*. 

image::images/simple-form-controller.png[title="O NetBeans IDE fornece modelos para diversos artefatos do Spring"] 

[tips]#O NetBeans IDE fornece modelos para vários artefatos do Spring, incluindo o Arquivo de Configuração do Spring XML, o link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/AbstractController.html[+`AbstractController`+] e o link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html[+`SimpleFormController`+].#

[start=2]
. Clique em Próximo.

[start=3]
. 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.

[start=4]
. 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-/ (&amp;#8984-/ no Mac). 

image::images/comment-out.png[title="Realce os snippets do código e, em seguida, pressione Ctrl-/ para alternar entre os comentários"] 

[tips]#Pressionar Ctrl-/ (&amp;#8984-/ no Mac) alterna entre os comentários no editor.#

[start=5]
. Faças as alterações a seguir (alterações em *negrito*).

[source,java]
----

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()`:

image::images/set-command-class.png[title="Um indicador de erro é exibido para setCommandClass()"]

Você precisa criar a classe `Name` como um bean simples para manter as informações de cada solicitação.


[start=6]
. 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.

[start=7]
. Digite *Name* para o Nome da Classe, e, para Pacote, selecione *controller* na lista drop-down.

[start=8]
. Clique em Finalizar. A classe `Name` é criada e aberta no editor.

[start=9]
. Para a classe `Name`, crie um campo denominado `value` e, em seguida, crie os métodos acessadores (por exemplo, os métodos getter e setter) para esse campo. Inicie declarando o campo `value`:

[source,java]
----

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.

image::images/generate-code.png[title="O menu pop-up Gerar Código permite definir métodos acessadores"]

[start=10]
. Na caixa de diálogo exibida, selecione a opção `value : String`e clique em OK. Os métodos `getValue()` e `setValue()` são adicionados à classe `Name`:

[source,java]
----

public String getValue() {
    return value;
}

public void setValue(String value) {
    this.value = value;
}
----

[start=11]
. Pressione Ctrl-Tab e selecione `HelloController` para retornar à classe `HelloController`. Observe que o indicador de erro anterior desapareceu, mas a classe `Name` existe agora.

[start=12]
. Delete o método `doSubmitAction()` e remova os comentários do método link:http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)[+`onSubmit()`+]. O método `onSubmit()` permite que você crie seu próprio `ModelAndView`, que é o necessário aqui. Faça as seguintes alterações:

[source,java]
----

@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`.

[start=13]
. 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). 

image::images/fix-imports70.png[title="Pressione Ctrl-Shift-I para corrigir as importações no seu arquivo"]

*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.


[start=14]
. Clique em OK. A instrução de importação a seguir será adicionada ao início do arquivo:

[source,java]
----

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()`.

[start=15]
. No `HelloController`, declare um campo privado chamado `HelloService`:

[source,java]
----

private HelloService helloService;
----
Em seguida, crie um método setter público para o campo:

[source,java]
----

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:

[source,java]
----

import service.HelloService;
----
Todos os erros deverão ser corrigidos agora.

[start=16]
. Registre `HelloService` em `applicationContext.xml`. Abra `applicationContext.xml` no editor e insira a seguinte declaração de bean:

[source,java]
----

<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:

image::images/code-completion.png[title="Funcionalidade autocompletar código chamada ao pressionar Ctrl-Espaço"]

[start=17]
. Registre `HelloController` em `dispatcher-servlet.xml`. Abra `dispatcher-servlet.xml` no editor e insira a seguinte declaração de bean:

[source,java]
----

<bean class="controller.HelloController" p:helloService-ref="helloService"/>
----


[[view]]
== 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`.

1. 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*.
2. Clique em Finalizar. A nova página JSP será criada na pasta `jsp` e aberta no editor.
3. No editor, altere o título do arquivo para `Hello` e altere a mensagem de saída para recuperar a `helloMessage` do objeto `ModelandView` criado em `HelloController`.

[source,xml]
----

<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>*Hello*</title>
</head>
<body>
    <h1>*${helloMessage}*</h1>
</body>

----

[start=4]
. Crie outra página JSP da mesma maneira <<create-jsp,conforme acima>>, mas nomeie-a como `nameView`.

[start=5]
. No editor, adicione a declaração da biblioteca de tags do Spring a seguir a `nameView.JSP`.

[source,java]
----

<%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
----
Isso importa a link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html[+biblioteca de tags do Spring+], que contém tags úteis para a implementação de views como páginas JSP.

[start=6]
. Altere o conteúdo das tags `<title>` e `<h1>` para que se leia: `Enter Your Name`.

[start=7]
. Insira o código a seguir abaixo das tags `<h1>`:

[source,xml]
----

<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>

----
link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.bind[+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`. 

link:http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.nestedPath[+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.

[start=8]
. Altere o ponto de entrada relativo da aplicação. Atualmente, o ponto de entrada do projeto ainda é `index.htm` que, conforme descrito em <<running,Executando o Projeto de Esqueleto>> acima, redireciona para `WEB-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`:

[source,java]
----

<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.

[start=9]
. 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 o `nameView` do projeto: 

image::images/name-view.png[title="A nameView é exibida em um browser"] 

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

image::images/hello-view.png[title="A helloView é exibida em um browser"]

link:/about/contact_form.html?to=3&subject=Feedback:%20Introduction%20to%20Spring[+Envie-nos Seu Feedback+]


[[seeAlso]]
== 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 link:http://sites.google.com/site/springmvcnetbeans/step-by-step/[+Desenvolvendo uma aplicação Spring Framework MVC passo a passo utilizando o NetBeans e o GlassFish Server+]. Esse é o link:http://static.springframework.org/docs/Spring-MVC-step-by-step/[+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:

* link:../../docs/web/framework-adding-support.html[+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.
* link:jsf20-intro.html[+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.