Google Git
Sign in
apache / netbeans-website-cleanup / refs/heads/asciidoc-features / . / src / content / kb / docs / web / quickstart-webapps-spring_pt_BR.html
blob: 9a04b241c7c5e0455e555ce44614c8a948f5d833 [file] [log] [blame]
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<meta name="description" content="An introduction to using the Spring Framework
in NetBeans IDE">
<meta name="keywords" content="NetBeans, IDE, integrated development environment,
Spring framework, frameworks, MVC, Model View Controller, web application">
<link rel="stylesheet" type="text/css" href="../../../netbeans.css">
<title>Introdução ao Spring Web MVC: Tutorial do NetBeans IDE</title>
</head>
<body>
<!--
Copyright (c) 2009, 2010, 2011, Oracle and/or its affiliates. All rights reserved.
-->
<h1>Introdução ao Spring Web MVC</h1>
<p>Este documento mostra como construir uma aplicação Web <a href="http://www.oracle.com/technetwork/articles/javase/index-142890.html">MVC</a> simples usando o <a href="http://www.springframework.org/">Spring Framework</a>. 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.</p>
<p>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.</p>
<p>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 <code>DispatcherServlet</code> 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:</p>
<ul>
<li><strong>Autocompletar código</strong>. Chamada nos arquivos de configuração Spring XML para classes Java assim como referências de bean.</li>
<li><strong>Navegação</strong>. Hiperlink de classes e propriedades Java mencionadas nas definições de bean Spring, bem como hiperlink para outras referências de bean Spring.</li>
<li><strong>Refatoração</strong>. Renomeação de referências a classes Java nos arquivos de configuração Spring XML.</li>
</ul>
<p>Para obter mais informações sobre o Spring Framework, visite <a href="http://www.springsource.org/">http://www.springsource.org/</a>. 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 <a href="http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/html/">Documentação de Referência do Spring Framework</a> oficial ou consulte a <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/">Documentação da API do Spring Framework</a>.</p>
<p><strong>Conteúdo</strong></p>
<img alt="O conteúdo desta página se aplica ao NetBeans IDE 7.2, 7.3, 7.4 e 8.0" class="stamp" src="../../../images_www/articles/73/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">
<ul class="toc">
<li><a href="#setting">Configurando um Novo Projeto com o suporte a Spring Web MVC</a>
<ul>
<li><a href="#creating">Criando um projeto de Esqueleto do Spring Web MVC</a></li>
<li><a href="#running">Executando o Projeto de Esqueleto</a></li>
</ul></li>
<li><a href="#overview">Visão Geral da Aplicação</a></li>
<li><a href="#service">Implementando um Serviço</a></li>
<li><a href="#controller">Implementando o Controlador e o Modelo</a></li>
<li><a href="#view">Implementando as Views</a></li>
<li><a href="#seeAlso">Consulte Também</a></li>
</ul>
<p><strong>Para concluir este tutorial, você precisa dos seguintes recursos e softwares.</strong></p>
<table>
<tbody>
<tr>
<th class="tblheader" scope="col">Software ou Recurso</th>
<th class="tblheader" scope="col">Versão Necessária</th>
</tr>
<tr>
<td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
<td class="tbltd1">Java EE 7.2, 7.3, 7.4, 8.0</td>
</tr>
<tr>
<td class="tbltd1"><a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">JDK (Java Development Kit)</a></td>
<td class="tbltd1">versão 7 ou 8</td>
</tr>
<tr>
<td class="tbltd1"><a href="http://glassfish.dev.java.net/public/downloadsindex.html">GlassFish Server</a></td>
<td class="tbltd1">3.x, 4.x</td>
</tr>
</tbody>
</table>
<p><strong class="notes">Observações:</strong></p>
<ul>
<li>A instalação Java do IDE permite, como opção, baixar e registrar o GlassFish Server com o IDE.</li>
<li>Se você precisar comparar seu projeto com uma solução que funciona, <a href="https://netbeans.org/projects/samples/downloads/download/Samples%252FJava%2520Web%252FHelloSpring69.zip">faça download da aplicação de amostra</a>.</li>
</ul>
<h2 id="setting">Configurando um Novo Projeto com Suporte a Spring Web MVC</h2>
<ul>
<li><a href="#creating">Criando um projeto de Esqueleto do Spring Web MVC</a></li>
<li><a href="#running">Executando o Projeto de Esqueleto</a></li>
</ul>
<div class="indent">
<h3 id="creating">Criando um Projeto de Esqueleto do Spring Web MVC</h3>
<p>Comece criando um novo projeto para uma aplicação Web usando o Spring Framework.</p>
<ol>
<li>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.</li>
<li>Em Nome do Projeto, digite <strong>HelloSpring</strong>. Clique em Próximo.</li>
<li>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 <a href="http://jcp.org/en/jsr/detail?id=299">JSR-299</a> neste tutorial.</li>
<li>Confirme se o GlassFish server está selecionado na lista drop-down Servidor. Clique em Próximo.
<p>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
</p></li>
<li>Na Etapa 4, no painel Frameworks, selecione Spring Web MVC.</li>
<li>Selecione <strong>Spring Framework 3.x</strong> na lista drop-down Biblioteca de Springs. <br> <img alt="Spring Web MVC exibido no painel Frameworks" class="margin-around b-all" src="../../../images_www/articles/80/web/spring/frameworks-window.png" title="Spring Web MVC exibido no painel Frameworks">
<p class="alert">
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. </p></li>
<li>Clique na guia Configuração e observe que o assistente permite especificar o nome e o mapeamento do servlet Spring Dispatcher.<br><img alt="Opções de configuração do Spring" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/spring-configuration.png" title="Especifique o nome e o mapeamento do servlet Spring Dispatcher na guia Configuração"></li>
<li>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: <code>dispatcher-servlet.xml</code>, <code>applicationContext.xml</code>, <code>redirect.jsp</code> e <code>index.jsp</code>.</li>
<li>Na janela Projetos, expanda o novo nó Bibliotecas do projeto e observe que JARs do Spring estão incluídos no classpath do projeto.<br><img alt="JARs Spring listados no nó das Bibliotecas do projeto" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/spring-libraries.png" title="Os JARs Spring são listados no nó das Bibliotecas do projeto">
</li>
</ol>
<h3 id="running">Executando o Projeto de Esqueleto</h3>
<p>Antes de fazer quaisquer alterações nos arquivos do projeto, tente executar o novo projeto no IDE:</p>
<ol>
<li>Clique em Executar Projeto (<img alt="Botão Executar Projeto" src="../../../images_www/articles/72/web/spring/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 <code>BUILD SUCCESSFUL.</code> <br> <img alt="Janela de Saída exibindo informações ao executar o projeto" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/output.png" title="A janela de Saída exibe informações ao executar o projeto"> <br>O browser default do IDE é iniciado e você vê o conteúdo da view da página de boas-vindas (<code>/WEB-INF/jsp/index.jsp</code>).<br><img alt="Saída de página de boas-vindas exibida no browser" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/browser-output.png" title="A saída de página de boas-vindas é exibida no browser" width="668"></li>
</ol>
<p class="tips">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.</p>
<p>Para entender o que acabou de acontecer, comece examinando o descritor de implantação do projeto (<code>web.xml</code>). Para abrir esse arquivo no Editor de Código-Fonte, clique com o botão direito do mouse no nó <code>WEB-INF</code> > <code>web.xml</code> na janela Projetos e selecione Editar. O ponto de entrada default da aplicação é <code>redirect.jsp</code>:</p>
<div class="indent">
<pre class="examplecode">
&lt;welcome-file-list&gt;
&lt;welcome-file&gt;redirect.jsp&lt;/welcome-file&gt;
&lt;/welcome-file-list&gt;</pre>
</div>
<p>Em <code>redirect.jsp</code>, existe uma instrução de redirecionamento que aponta todas as solicitações para <code>index.htm</code>:</p>
<div class="indent">
<pre class="examplecode">&lt;% response.sendRedirect(&quot;index.htm&quot;); %&gt;</pre>
</div>
<p>No descritor de implantação, observe que todas as solicitações de padrões de URL que correspondem a <code>*.htm</code> são mapeadas para <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html"><code>DispatcherServlet</code></a> do Spring.</p>
<div class="indent">
<pre class="examplecode">
&lt;servlet&gt;
&lt;servlet-name&gt;dispatcher&lt;/servlet-name&gt;
&lt;servlet-class&gt;org.springframework.web.servlet.DispatcherServlet&lt;/servlet-class&gt;
&lt;load-on-startup&gt;2&lt;/load-on-startup&gt;
&lt;/servlet&gt;
&lt;servlet-mapping&gt;
&lt;servlet-name&gt;dispatcher&lt;/servlet-name&gt;
&lt;url-pattern&gt;*.htm&lt;/url-pattern&gt;
&lt;/servlet-mapping&gt;</pre>
</div>
<p class="tips">O nome totalmente qualificado do servlet dispatcher, conforme mostrado acima, é <code>org.springframework.web.servlet.DispatcherServlet</code>. 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 <code>spring-webmvc-3.1.1.RELEASE.jar</code> e, em seguida, expanda para encontrar <code>org.springframework.web.servlet</code> > <code>DispatcherServlet</code>.</p>
<p>A classe <code>DispatcherServlet</code> manipula as solicitações de entrada com base nas definições de configuração encontradas em <code>dispatcher-servlet.xml</code>. Abra <code>dispatcher-servlet.xml</code>, clicando em sua guia no editor. Observe o código a seguir:</p>
<div class="indent">
<pre class="examplecode">
&lt;bean id=&quot;urlMapping&quot; class=&quot;org.springframework.web.servlet.handler.<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.html">SimpleUrlHandlerMapping</a>&quot;&gt;
&lt;property name=&quot;mappings&quot;&gt;
&lt;props&gt;
&lt;prop key=&quot;/index.htm&quot;&gt;indexController&lt;/prop&gt;
&lt;/props&gt;
&lt;/property&gt;
&lt;/bean&gt;
&lt;bean id=&quot;viewResolver&quot;
class=&quot;org.springframework.web.servlet.view.<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/view/InternalResourceViewResolver.html">InternalResourceViewResolver</a>&quot;
p:prefix=&quot;/WEB-INF/jsp/&quot;
p:suffix=&quot;.jsp&quot; /&gt;
&lt;bean name=&quot;indexController&quot;
class=&quot;org.springframework.web.servlet.mvc.<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html">ParameterizableViewController</a>&quot;
p:viewName=&quot;index&quot; /&gt;</pre>
</div>
<p>Três beans são definidos nesse arquivo: <code>indexController</code>, <code>viewResolver</code> e <code>urlMapping</code>. Quando a <code>DispatcherServlet</code> recebe uma solicitação que coincide com <code>*.htm</code> tal como <code>index.htm</code>, ela procura um controle no <code>urlMapping</code> que possa acomodar a solicitação. Acima, você vê que existe uma propriedade <code>mappings</code> que vincula <code>/index.htm</code> a <code>indexController</code>.</p>
<p>O ambiente de runtime procura a definição de um bean chamado <code>indexController</code>, que é convenientemente fornecido pelo projeto de esqueleto. Observe que <code>indexController</code> estende <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html"><code>ParameterizableViewController</code></a>. Essa é uma outra classe fornecida pelo Spring, que simplesmente retorna uma view. Acima, observe que <code>p:viewName="index"</code> especifica o nome da view lógica, que é resolvida por meio de <code>viewResolver</code> acrescentado-se o prefixo <code>/WEB-INF/jsp/</code> e o sufixo <code>.jsp</code>. 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 (<code>/WEB-INF/jsp/index.jsp</code>).</p>
</div>
<h2 id="overview">Visão Geral da Aplicação</h2>
<p>A aplicação criada é composta de duas páginas JSP (que se chamam <em>views</em> na terminologia <a href="http://www.oracle.com/technetwork/articles/javase/index-142890.html">MVC</a>). 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.</p>
<p>As views são gerenciadas por um <em>controlador</em>, 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 <em>modelo</em>). Esse controlador de aplicação é chamado de <code>HelloController</code>.</p>
<p>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 <em>serviço</em>, é 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 <code>HelloService</code>.<a name="service"></a>
<h2>Implementando um Serviço</h2>
<p>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 <code>HelloService</code>.</p>
<ol>
<li>Clique no botão Novo Arquivo (<img alt="Botão Novo Arquivo" src="../../../images_www/articles/72/web/spring/new-file-btn.png">) na barra de ferramentas do IDE. (Como alternativa, pressione Ctrl-N; ⌘-N no Mac.)</li>
<li>Selecione a categoria <strong>Java</strong>, <strong>Classe Java</strong> e clique em Próximo.</li>
<li>No assistente de Nova Classe Java exibido, digite <strong>HelloService</strong> no Nome da Classe e <strong>service</strong> no Nome do Pacote para criar um novo pacote para a classe.</li>
<li>Clique em Finalizar. O IDE cria a nova classe e a abre no editor.</li>
</ol>
<p>A classe <code>HelloService</code> realiza um serviço muito simples. Ela pega um nome como parâmetro, prepara e retorna uma <code>String</code> que inclui o nome. No editor, crie o seguinte método <code>sayHello()</code> para a classe (alterações em <strong>negrito</strong>).</p>
<div class="indent">
<pre class="examplecode">
public class HelloService {
<strong>public static String sayHello(String name) {
return &quot;Hello &quot; + name + &quot;!&quot;;
}</strong>
}</pre></div>
<h2 id="controller">Implementando o Controlador e o Modelo</h2>
<p>Você pode usar um <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html"><code>SimpleFormController</code></a> para manipular dados do usuário e determinar qual view retornar.</p>
<p class="notes"><strong>Observação: </strong>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.</p>
<ol>
<li>Abra o assistente de Novo Arquivo pressionando Ctrl-N (⌘-N no Mac). Em Categorias, selecione <strong>Spring Framework</strong> em Tipos de Arquivos e <strong>Controlador de Form Simplificado</strong>. <br> <img alt="Assistente de Novo Arquivo - categoria do Spring Framework" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/simple-form-controller.png" style="width:668px" title="O NetBeans IDE fornece modelos para diversos artefatos do Spring"> <br> <span class="tips">O NetBeans IDE fornece modelos para vários artefatos do Spring, incluindo o Arquivo de Configuração do Spring XML, o <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/AbstractController.html"><code>AbstractController</code></a> e o <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html"><code>SimpleFormController</code></a>.</span>
</li>
<li>Clique em Próximo.</li>
<li>Chame a classe de <strong>HelloController</strong> e crie um novo pacote para ela, digitando <strong>controller</strong> no campo de texto Pacote. Clique em Finalizar. O IDE cria a nova classe e a abre no editor.</li>
<li>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). <br> <img alt="Snippet do código realçado no editor" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/comment-out.png" title="Realce os snippets do código e, em seguida, pressione Ctrl-/ para alternar entre os comentários"> <br> <span class="tips">Pressionar Ctrl-/ (&amp;#8984-/ no Mac) alterna entre os comentários no editor.</span>
</li>
<li>Faças as alterações a seguir (alterações em <strong>negrito</strong>).
<pre class="examplecode">
public HelloController() {
<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandClass(java.lang.Class)">setCommandClass</a>(<strong>Name</strong>.class);
<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandName(java.lang.String)">setCommandName</a>(&quot;<strong>name</strong>&quot;);
<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setSuccessView(java.lang.String)">setSuccessView</a>(&quot;<strong>hello</strong>View&quot;);
<a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)">setFormView</a>(&quot;<strong>name</strong>View&quot;);
}</pre>
<p>A definição de <code>FormView</code> 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 <code>SuccessView</code>, da mesma forma, permite que você defina o nome da view que deve ser exibida durante um envio bem-sucedido. Quando você configura <code>CommandName</code>, 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 <code>CommandClass</code> permite que você defina o nome da classe do comando. Uma instância dessa classe é preenchida e validada em cada solicitação.</p>
<p>Observe que um erro é sinalizado para <code>Name</code> no método <code>setCommandClass()</code>:</p>
<img alt="O editor exibindo um erro para setCommandClass()" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/set-command-class.png" title="Um indicador de erro é exibido para setCommandClass()">
<p>
Você precisa criar a classe <code>Name</code> como um bean simples para manter as informações de cada solicitação.</p></li>
<li>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.</li>
<li>Digite <strong>Name</strong> para o Nome da Classe, e, para Pacote, selecione <strong>controller</strong> na lista drop-down.</li>
<li>Clique em Finalizar. A classe <code>Name</code> é criada e aberta no editor.</li>
<li>Para a classe <code>Name</code>, crie um campo denominado <code>value</code> e, em seguida, crie os métodos acessadores (por exemplo, os métodos getter e setter) para esse campo. Inicie declarando o campo <code>value</code>:
<pre class="examplecode">
public class Name {
<strong>private String value;</strong>
}</pre>
<p class="tips">Para digitar "<code>private</code>" rapidamente, você pode digitar "<code>pr</code>" e pressionar Tab. O modificador de acesso "<code>private</code>" é 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.</p>
<br><a name="createAccessors"></a> O IDE pode criar métodos do assessor para você. No editor, clique com o botão direito do mouse em <code>valor</code> e selecione Inserir Código (ou pressione Alt-Insert; Ctrl-I no Mac). No menu pop-up, escolha Getter e Setter.<br><img alt="Menu pop-up Gerar Código exibido no editor" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/generate-code.png" title="O menu pop-up Gerar Código permite definir métodos acessadores"></li>
<li>Na caixa de diálogo exibida, selecione a opção <code>value : String</code>e clique em OK. Os métodos <code>getValue()</code> e <code>setValue()</code> são adicionados à classe <code>Name</code>:
<pre class="examplecode">
public String getValue() {
return value;
}
public void setValue(String value) {
this.value = value;
}</pre></li>
<li>Pressione Ctrl-Tab e selecione <code>HelloController</code> para retornar à classe <code>HelloController</code>. Observe que o indicador de erro anterior desapareceu, mas a classe <code>Name</code> existe agora.</li>
<li>Delete o método <code>doSubmitAction()</code> e remova os comentários do método <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)"><code>onSubmit()</code></a>. O método <code>onSubmit()</code> permite que você crie seu próprio <code>ModelAndView</code>, que é o necessário aqui. Faça as seguintes alterações:
<pre class="examplecode">@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;
}</pre>
Conforme indicado acima, o <code>command</code> é reconvertido como um objeto <code>Name</code>. Uma instância de <code>ModelAndView</code> é criada, e a view de sucesso é obtida por meio de um getter em <code>SimpleFormController</code>. Finalmente, o modelo é preenchido com os dados. O único item em nosso modelo é a mensagem hello obtida do <code>HelloService</code> criado anteriormente. Use o método <code>addObject()</code> para adicionar a mensagem hello ao modelo sob o nome <code>helloMessage</code>.</li>
<li>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). <br> <img alt="Caixa de diálogo Corrigir Todas as Importações" class="margin-around b-all" src="../../../images_www/articles/72/web/spring/fix-imports70.png" title="Pressione Ctrl-Shift-I para corrigir as importações no seu arquivo">
<p class="notes"><strong>Observação.</strong> Certifique-se de que as opções <strong><tt>org.springframework.validation.BindException</tt></strong> e <strong><tt>org.springframework.web.servlet.ModelAndView</tt></strong> estejam selecionadas na caixa de diálogo Corrigir Todas as Importações.</p></li>
<li>Clique em OK. A instrução de importação a seguir será adicionada ao início do arquivo:
<pre class="examplecode">import <a href="http://static.springsource.org/spring/docs/3.1.x/javadoc-api/org/springframework/web/servlet/ModelAndView.html">org.springframework.web.servlet.ModelAndView</a>;</pre>
Conforme informado na documentação da API, essa classe "representa um modelo e uma view retornados por um handler, a serem resolvidos por um <code>DispatcherServlet</code>. A view pode tomar a forma de um nome de view de <code>String</code>, que precisará ser resolvido por um objeto <code>ViewResolver</code>, como alternativa, um objeto <code>View</code> poderá ser especificado diretamente. O modelo é um <code>Map</code>, que permite o uso de vários objetos, classificados por nome". <br><br> Observe que nesse estágio, nem todos os erros são corrigidos, pois a classe ainda não pode identificar a classe <code>HelloService</code> e não utiliza seu método <code>sayHello()</code>.</li>
<li>No <code>HelloController</code>, declare um campo privado chamado <code>HelloService</code>:
<pre class="examplecode">private HelloService helloService;</pre>
Em seguida, crie um método setter público para o campo:
<pre class="examplecode">public void setHelloService(HelloService helloService) {
this.helloService = helloService;
}</pre>
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:
<pre class="examplecode">import service.HelloService;</pre>
Todos os erros deverão ser corrigidos agora.</li>
<li>Registre <code>HelloService</code> em <code>applicationContext.xml</code>. Abra <code>applicationContext.xml</code> no editor e insira a seguinte declaração de bean:
<pre class="examplecode">
&lt;bean name=&quot;helloService&quot; class=&quot;service.HelloService&quot; /></pre>
<div class="tips">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:<br><img alt="Funcionalidade autocompletar código chamada ao pressionar Ctrl-Espaço" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/code-completion.png" title="Funcionalidade autocompletar código chamada ao pressionar Ctrl-Espaço"></div></li>
<li>Registre <code>HelloController</code> em <code>dispatcher-servlet.xml</code>. Abra <code>dispatcher-servlet.xml</code> no editor e insira a seguinte declaração de bean:
<pre class="examplecode">
&lt;bean class=&quot;controller.HelloController&quot; p:helloService-ref=&quot;helloService&quot;/&gt;</pre></li>
</ol>
<h2 id="view">Implementando as Views</h2>
<p>Para implementar a view desse projeto, você precisa criar duas páginas JSP. A primeira, que você pode chamar de <code>nameView.jsp</code>, serve como a página de boas-vindas e permite que os usuários insiram um nome. A outra página, <code>helloView.jsp</code>, exibe uma mensagem de saudação que inclui o nome de entrada. Comece criando <code>helloView.jsp</code>.</p>
<ol>
<li id="create-jsp">Na janela Projetos, clique com o botão direito do mouse no nó WEB-INF > <code>jsp </code> e selecione Nova > JSP. O assistente de Novo Arquivo JSF será aberto. Chame o arquivo de <strong>helloView</strong>.</li>
<li>Clique em Finalizar. A nova página JSP será criada na pasta <code>jsp</code> e aberta no editor.</li>
<li>No editor, altere o título do arquivo para <code>Hello</code> e altere a mensagem de saída para recuperar a <code>helloMessage</code> do objeto <code>ModelandView</code> criado em <code>HelloController</code>.
<pre class="examplecode">
&lt;head&gt;
&lt;meta http-equiv=&quot;Content-Type&quot; content=&quot;text/html; charset=UTF-8&quot;&gt;
&lt;title&gt;<strong>Hello</strong>&lt;/title&gt;
&lt;/head&gt;
&lt;body&gt;
&lt;h1&gt;<strong>${helloMessage}</strong>&lt;/h1&gt;
&lt;/body&gt;
</pre></li>
<li>Crie outra página JSP da mesma maneira <a href="#create-jsp">conforme acima</a>, mas nomeie-a como <code>nameView</code>.</li>
<li>No editor, adicione a declaração da biblioteca de tags do Spring a seguir a <code>nameView.JSP</code>.
<pre class="examplecode">&lt;%@taglib uri=&quot;http://www.springframework.org/tags&quot; prefix=&quot;spring&quot; %&gt;</pre>
Isso importa a <a href="http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html">biblioteca de tags do Spring</a>, que contém tags úteis para a implementação de views como páginas JSP.
<li>Altere o conteúdo das tags <code>&lt;title></code> e <code>&lt;h1></code> para que se leia: <code>Enter Your Name</code>.</li>
<li>Insira o código a seguir abaixo das tags <code>&lt;h1></code>:
<pre class="examplecode">
&lt;spring:nestedPath path=&quot;name&quot;&gt;
&lt;form action=&quot;&quot; method=&quot;post&quot;&gt;
Name:
&lt;spring:bind path=&quot;value&quot;&gt;
&lt;input type=&quot;text&quot; name=&quot;${status.expression}&quot; value=&quot;${status.value}&quot;&gt;
&lt;/spring:bind&gt;
&lt;input type=&quot;submit&quot; value=&quot;OK&quot;&gt;
&lt;/form&gt;
&lt;/spring:nestedPath&gt;
</pre>
<a href="http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.bind">spring:bind</a> 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 (<code>controller.Name</code>) possui uma propriedade <code>value</code>, portanto, a definição de <code>path</code> como <code>value</code>. <br><br> <a href="http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html#spring.tld.nestedPath">spring:nestedPath</a> permite que você anexe um caminho especificado a um bean. Sendo assim, quando usado com <code>spring:bind</code> conforme mostrado acima, o caminho para o bean se torna: <code>name.value</code>. Como você deve lembrar, o nome do comando de <code>HelloController</code> é <code>name</code>. Portanto, esse caminho se refere à propriedade <code>value</code> de um bean chamado <code>name</code> no escopo da página.
<li>Altere o ponto de entrada relativo da aplicação. Atualmente, o ponto de entrada do projeto ainda é <code>index.htm</code> que, conforme descrito em <a href="#running">Executando o Projeto de Esqueleto</a> acima, redireciona para <code>WEB-INF/jsp/index.jsp</code>. 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 <code>/hello.htm</code>, em seguida, clique em OK. <br><br> Nesse momento, você deve estar pensando onde o mapeamento de <code>hello.htm</code> para <code>HelloController</code> se encontra. Você não adicionou um mapeamento para o bean <code>urlMapping</code>, como é o caso de <code>index.htm</code>, 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 <code>dispatcher-servlet.xml</code>:
<pre class="examplecode">&lt;bean class=&quot;org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping&quot;/&gt;</pre>
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, <code>controller.HelloController</code>) e retira o nome do pacote e o sufixo <code>Controller</code>, em seguida, usa o resultado como um mapeamento de URL. Portanto, para <code>HelloController</code>, ele cria um mapeamento <code>hello.htm</code>. Entretanto, essa mágica não funciona para controladores que estão incluídos no Spring Framework, como o <code>ParameterizableViewController</code>. Eles requerem mapeamento explícito.</li>
<li>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 <code>hello.htm</code> como o <code>nameView</code> do projeto: <br> <img alt="nameView exibida em um browser" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/name-view.png" title="A nameView é exibida em um browser"> <br>Informe seu nome no campo de texto e clique Enter. O <code>helloView</code> é exibido com uma mensagem de saudação:<br><img alt="helloView exibida em um browser" class="b-all margin-around" src="../../../images_www/articles/72/web/spring/hello-view.png" title="A helloView é exibida em um browser"></li>
</ol>
<div class="feedback-box">
<a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Introduction%20to%20Spring">Envie-nos Seu Feedback</a></div>
<br style="clear:both;">
<h2 id="seeAlso">Consulte Também</h2>
<p>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.</p>
<p>Recomendamos que você continue aprendendo sobre o Spring Framework trabalhando em outros tutoriais do NetBeans IDE, como <a href="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</a>. Esse é o <a href="http://static.springframework.org/docs/Spring-MVC-step-by-step/">tutorial oficial do Spring Framework</a> de Thomas Risberg que foi adaptado para o NetBeans IDE por Arulazi Dhesiaseelan.</p>
<p>Muitos dos recursos de Módulo do Spring NetBeans também podem ser aplicados a aplicações Spring Framework não baseados na Web.
<p>Para outros tutoriais relacionados, consulte os seguintes recursos:</p>
<ul>
<li><a href="../../docs/web/framework-adding-support.html">Adicionando Suporte a um Framework da Web</a> 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.</li>
<li><a href="jsf20-intro.html">Introdução ao JavaServer Faces 2.0</a>. Demonstra como adicionar suporte do JSF 2.0 a um projeto existente, beans gerenciados por fios e como aproveitar os modelos de Facelets.</li>
</ul>
</body>
</html>