| <!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 é retornado e exibido em uma segunda página com uma saudação de boas-vindas.</p> |
| |
| <p>O Spring Framework é uma estrutura de aplicativo 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-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 criar aplicativos Web.</p> |
| |
| <p>O IDE fornece suporte embutido para Spring Framework 3.0 e 2.5. As bibliotecas da estrutura são empacotadas com o IDE e são adicionadas automaticamente ao classpath do projeto quando a estrutura é selecionado. As definições de configuração são fornecidas, tais como nomeação e mapeamento do Spring Web MVC <code>DispatcherServlet</code>. 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>Auto-completar de código</strong>. Chamado nos arquivos de configuração Spring XML para classes Java assim como referências de bean.</li> |
| |
| <li><strong>Navegação</strong>. Hyperlink de classes e propriedades Java mencionadas nas definições de bean Spring, assim como hyperlink 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 um aplicativo, consulte a <a href="http://static.springsource.org/spring/docs/3.0.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.0.x/javadoc-api/">Documentação da API do Spring Framework</a>.</p> |
| |
| <p><strong>Conteúdo</strong></p> |
| |
| <img src="../../../images_www/articles/69/netbeans-stamp-69-70-71.png" class="stamp" width="114" alt="O conteúdo desta página se aplica ao IDE NetBeans 6.9, 7.0 e 7.1" title="O conteúdo desta página se aplica ao IDE NetBeans 6.9, 7.0 e 7.1" /> |
| |
| <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 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 do aplicativo</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 visualizações</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">6.8, 6.9, 7.0, 7.1, Java</td> |
| </tr> |
| <tr> |
| <td class="tbltd1"><a href="http://www.oracle.com/technetwork/java/javase/downloads/index.html">Java Development Kit (JDK)</a></td> |
| <td class="tbltd1">versão 6</td> |
| </tr> |
| <tr> |
| <td class="tbltd1"><a href="https://glassfish.dev.java.net/public/downloadsindex.html">Servidor GlassFish</a></td> |
| <td class="tbltd1">Código-fonte aberto edição 3.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 servidor GlassFish 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">baixe o aplicativo 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 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 Spring Web MVC</h3> |
| |
| <p>Comece criando um novo projeto para uma aplicação Web usando o Spring Framework.</p> |
| |
| <ol> |
| <li>Escolha Novo projeto (Ctrl-Shift-N; &#8984-Shift-N no Mac) no menu Arquivo do IDE. Selecione a categoria Java Web e, em Projetos, selecione Aplicativo da 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 configurações, desmarque a opção Habilitar 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. |
| |
| <br><br> |
| Além disso, garanta que o servidor GlassFish esteja selecionado na lista suspensa Servidor e observe que Java EE 6 Web é a versão EE padrão para esse servidor. Clique em Próximo.</li> |
| |
| <li>Na Etapa 4, o painel Frameworks, selecione Spring Web MVC. |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/frameworks-window.png" |
| class="margin-around b-all" |
| title="Spring Web MVC exibido no painel Frameworks" |
| alt=" Spring Web MVC exibido no painel Frameworks"> |
| |
| <p> |
| Ao selecionar o Spring Web MVC, note que a biblioteca JSTL (Biblioteca de marcação padrão de páginas do JavaServer) é adicionada ao classpath durante a criação do projeto por padrão. Desmarque essa opção (como na captura de tela acima), já que o JSTL não é necessário para este tutorial. Observe também, que o IDE permite adicionar a biblioteca Spring 2.5 ao projeto, se essa for sua preferência.</p></li> |
| |
| <li>Clique na aba Configuração e observe que o assistente permite especificar o nome e o mapeamento do servlet Spring Dispatcher. |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/spring-configuration.png" |
| title="Especifique o nome e o mapeamento do servlet Spring Dispatcher na aba Configuração" |
| class="margin-around b-all" alt="Opções de configuração do Spring"></li> |
| |
| <li>Clique em Terminar. O IDE cria um projeto para o aplicativo inteiro, incluindo todos os metadados, assim como o script de construção do projeto Ant que você pode inspecionar na janela Arquivos (Ctrl-2; &#8984-2 no Mac). Você pode ver a estrutura do modelo na janela Projetos (Ctrl-1; &#8984-1 no Mac). Note também que quatro arquivos são abertos por padrão 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 src="../../../images_www/articles/71/web/spring/spring-libraries.png" |
| title="JARs do Spring estão listados no nó Bibliotecas do projeto" |
| class="margin-around b-all" alt="JARs do Spring listados no nó 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 no botão Executar projeto (<img src="../../../images_www/articles/71/web/spring/run-project-btn.png" |
| alt="botão Executar projeto">) na barra de ferramentas principal do IDE. O IDE inicia automaticamente o servidor GlassFish se ele ainda não estiver sendo executado, compila o projeto e o implanta no servidor. Note qualquer saída exibida na janela Saída do IDE (Ctrl-4; &#8984-4 no Mac). A saída gerada termina com a mensagem <code>CONSTRUÇÃO BEM-SUCEDIDA.</code> |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/output.png" |
| alt="Janela Saída exibindo informações durante a execução do projeto" |
| title="A janela Saída exibe informações durante a execução do projeto" |
| class="margin-around b-all"> |
| |
| <br> |
| O navegador padrão do IDE é iniciado e você vê o conteúdo da visualização da página de boas-vindas (<code>/WEB-INF/jsp/index.jsp</code>). |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/browser-output.png" |
| class="margin-around b-all" width="668" |
| title="A saída da página de boas-vindas é exibida no navegador" |
| alt="Saída da página de boas-vindas exibida no navegador"></li> |
| </ol> |
| |
| <p class="tips">Quando você executa o projeto no IDE, o projeto é compilado e implantado no servidor e, em seguida, aberto no navegador padrão. Além disso, o IDE fornece um recurso Implantar ao salvar, que está ativado por padrão para projetos da Web. Quando você salva arquivos no editor, o projeto é automaticamente recompilado e implantado no servidor. Para visualizar alterações, você pode, simplesmente, atualizar as páginas no navegador.</p> |
| |
| <p>Para entender o que acabou de acontecer, comece examinando o descritor de deployment 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 escolha Editar. O ponto de entrada padrão do aplicativo é <code>redirect.jsp</code>:</p> |
| |
| <div class="indent"> |
| <pre class="examplecode"> |
| <welcome-file-list> |
| <welcome-file>redirect.jsp</welcome-file> |
| </welcome-file-list></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"><% response.sendRedirect("index.htm"); %></pre> |
| </div> |
| |
| <p>No descritor de deployment, note que todas as requisiçõ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.0.x/javadoc-api/org/springframework/web/servlet/DispatcherServlet.html"><code>DispatcherServlet</code></a> do Spring.</p> |
| |
| <div class="indent"> |
| <pre class="examplecode"> |
| <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></pre> |
| </div> |
| |
| <p class="tips">O nome completamente qualificado do servlet dispatcher, conforme mostrado acima, é <code>org.springframework.web.servlet.DispatcherServlet</code>. Essa classe é 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 a partir do nó Bibliotecas. Localize o arquivo <code>spring-webmvc-3.0.0.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 aba no editor. Observe o código seguinte.</p> |
| |
| <div class="indent"> |
| <pre class="examplecode"> |
| <bean id="urlMapping" class="org.springframework.web.servlet.handler.<a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/servlet/handler/SimpleUrlHandlerMapping.html">SimpleUrlHandlerMapping</a>"> <property name="mappings"> <props> <prop key="/index.htm">indexController</prop> </props> </property> </bean> <bean id="viewResolver" class="org.springframework.web.servlet.view.<a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/servlet/view/InternalResourceViewResolver.html">InternalResourceViewResolver</a>" p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" /> <bean name="indexController" class="org.springframework.web.servlet.mvc.<a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/servlet/mvc/ParameterizableViewController.html">ParameterizableViewController</a>" p:viewName="index" /></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 por 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 tempo de execução 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.0.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 visualização. Acima, observe que <code>p:viewName="index"</code> especifica o nome da visualização lógica, que é resolvida por meio de <code>viewResolver</code> colocando-se o prefixo <code>/WEB-INF/jsp/</code> e o sufixo <code>.jsp</code>. Isso permite que o tempo de execução localize o arquivo no diretório do aplicativo e responda com a visualização da página de boas-vindas (<code>/WEB-INF/jsp/index.jsp</code>).</p> |
| </div> |
| |
| |
| <h2 id="overview">Visão geral do aplicativo</h2> |
| |
| <p>O aplicativo criado é composto de duas páginas JSP (que se chamam <em>visualizações</em> na terminologia <a href="http://www.oracle.com/technetwork/articles/javase/index-142890.html">MVC</a>). A primeira visualização contém um formulário HTML com um campo de entrada solicitando o nome do usuário. A segunda visualização é uma página que exibe simplesmente uma mensagem hello contendo o nome do usuário.</p> |
| |
| <p>As visualizações são gerenciadas por um <em>controlador</em>, que recebe as solicitações para o aplicativo e decide quais visualizações retornar. Ele também passa para as visualizações quaisquer informações que precisam exibir (isso é chamado de <em>modelo</em>). Esse controlador do aplicativo se chama <code>HelloController</code>.</p> |
| |
| <p>Em uma aplicação Web complexa, a lógica comercial não é 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 corporativa. Em nosso aplicativo, a lógica corporativa está limitada ao ato de processamento da mensagem olá, 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 que seu ambiente está configurado corretamente, é possível 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 src="../../../images_www/articles/71/web/spring/new-file-btn.png" |
| alt="botão Novo arquivo"> ) 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 para Nova classe Java exibido, digite <strong>HelloService</strong> para Nome da classe e digite <strong>service</strong> para Nome do pacote a fim de criar um novo pacote para a classe.</li> |
| |
| <li>Clique em Terminar. 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 "Hello " + name + "!"; |
| }</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.0.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html"><code>SimpleFormController</code></a> para manipular dados do usuário e determinar qual visualização retornar.</p> |
| |
| <ol> |
| <li>Abra o assistente para Novo arquivo pressionando Ctrl-N (⌘-N no Mac). Em Categorias, selecione <strong>Spring Framework</strong> em Tipos de arquivos e <strong>Controlador de formulário simplificado</strong>. |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/simple-form-controller.png" |
| class="b-all margin-around" style="width:668px" |
| alt="Assistente Novo arquivo: categoria Spring Framework " |
| title="O NetBeans IDE fornece modelos para vários 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.0.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.0.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 Terminar. 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 padrão no modelo da classe. Para retirar os comentários do trecho de código, realce o código como na imagem a seguir e pressione Ctrl-/ (&#8984-/ no Mac). |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/comment-out.png" |
| class="b-all margin-around" |
| alt="Trecho de código realçado no editor" |
| title="Realce trechos de código e pressione Ctrl-/ para alternar comentários"> |
| |
| <br> |
| <span class="tips">Pressionar Ctrl-/ (&#8984-/ no Mac) alterna 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.0.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.0.x/javadoc-api/org/springframework/web/servlet/mvc/BaseCommandController.html#setCommandName(java.lang.String)">setCommandName</a>("<strong>name</strong>"); |
| <a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setSuccessView(java.lang.String)">setSuccessView</a>("<strong>hello</strong>View"); |
| <a href="http://static.springsource.org/spring/docs/3.0.x/javadoc-api/org/springframework/web/servlet/mvc/SimpleFormController.html#setFormView(java.lang.String)">setFormView</a>("<strong>name</strong>View"); |
| }</pre> |
| |
| <p>Definir <code>FormView</code> permite que você defina o nome da visualização que é usada para exibir o formulário. Essa é a página que contém o campo de texto que permite aos usuários indicar seu nome. Configurar <code>SuccessView</code> da mesma forma permite que você defina o nome da visualização que deve ser exibida durante um envio bem sucedido. Quando configura <code>CommandName</code>, você define o nome do comando no modelo. Nesse caso, o comando é o objeto do formulário com os parâmetros de solicitação vinculados a ele. Configurar <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 pra <code>Name</code> no método <code>setCommandClass()</code>:</p> |
| |
| <img src="../../../images_www/articles/71/web/spring/set-command-class.png" class="b-all margin-around" |
| alt="O editor exibindo um erro para setCommandClass()" |
| title="Um identificador de erro é exibido para setCommandClass()"> |
| |
| <p> |
| Você precisa criar a classe <code>Nome</code> como um bean simples para manter as informações de cada requisição.</p></li> |
| |
| <li>Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha Novo > Classe Java. O assistente para Nova classe Java é exibido.</li> |
| |
| <li>Indique <strong>Name</strong> para o Nome da classe, e para Pacote, selecione <strong>controller</strong> na lista suspensa.</li> |
| |
| <li>Clique em Terminar. A classe <code>Nome</code> é criada e aberta no editor.</li> |
| |
| <li>Para a classe <code>Nome</code>, crie um campo denominado <code>valor</code> e, em seguida, crie os métodos do acessor (por exemplo, os métodos getter e setter) para esse campo. Inicie declarando o campo <code>valor</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, escolha 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 escolha Inserir código (ou pressione Alt-Insert; Ctrl-I no Mac). No menu pop-up, escolha Getter e Setter. |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/generate-code.png" |
| class="margin-around b-all" |
| alt="O menu pop-up Gerar código exibido no editor" |
| title="O menu pop-up Gerar código permite definir os métodos do acessor"></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 escolha <code>HelloController</code> para retornar para a classe <code>HelloController</code>. Observe que o identificador de erro anterior desapareceu, mas a classe <code>Nome</code> existe agora.</li> |
| <li>Exclua o método <code>doSubmitAction()</code> e remova os comentários do método <a href="http://static.springsource.org/spring/docs/3.0.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> |
| |
| Como indicado acima, o <code>comando</code> é reconvertido como um objeto <code>Name</code>. Uma instância de <code>ModelAndView</code> é criada, e a visualização 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 sobe o nome <code>helloMessage</code>.</li> |
| |
| <li>Corrija os erros de importação clicando com o botão direito do mouse no editor e escolhendo Corrigir importações (Ctrl-Shift-I; ⌘-Shift-I no Mac). |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/fix-imports70.png" |
| class="margin-around b-all" alt="Caixa de diálogo Corrigir todas as importações" |
| title="Pressione Ctrl-Shift-I para corrigir as importações do seu arquivo"> |
| <p class="notes"><strong>Observação.</strong> Confirme se <strong><tt>org.springframework.validation.BindException</tt></strong> e <strong><tt>org.springframework.web.servlet.ModelAndView</tt></strong> estão selecionados na caixa de diálogo Corrigir todas as importações.</p></li> |
| |
| <li>Clique em OK. A instrução de importação seguinte é adicionada ao início do arquivo: |
| |
| <pre class="examplecode">importe <a href="http://static.springsource.org/spring/docs/3.0.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 visualização retornados por um manipulador, a serem resolvidos por um <code>DispatcherServlet</code>. A visualização pode tomar a forma de um nome de visualização do <code>String</code>, que precisará ser resolvido por um objeto <code>ViewResolver</code>, como alternativa, um objeto <code>Visualização</code> pode ser especificado diretamente. O modelo é um <code>Mapa</code>, que permite o uso de vários objetos, classificados por nome". |
| |
| <br><br> |
| Note 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 escolha Corrigir importações (Ctrl-Shift-I; ⌘-Shift-I no Mac). A instrução a seguir é adicionada ao início do arquivo: |
| |
| <pre class="examplecode">import service.HelloService;</pre> |
| |
| Todos os erros devem 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"> |
| <bean name="helloService" class="service.HelloService" /></pre> |
| |
| <div class="tips">O suporte a Spring no IDE inclui auto-completar de código nos arquivos de configuração XML para classes Java, assim como referências de bean. Para chamar o autocompletar de código, pressione Ctrl-Espaço quando estiver trabalhando no editor: |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/code-completion.png" |
| alt="Auto-completar de código chamado ao pressionar Ctrl-Espaço" |
| title="Auto-completar de código chamado ao pressionar Ctrl-Espaço" |
| class="b-all margin-around"></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"> |
| <bean class="controller.HelloController" p:helloService-ref="helloService"/></pre></li> |
| </ol> |
| |
| |
| <h2 id="view">Implementando as visualizações</h2> |
| |
| <p>Para implementar a visualização 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 um usuário insira 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 escolha Novo > JSP. O assistente para Novo arquivo JSF se abre. Chame o arquivo de <strong>helloView</strong>.</li> |
| |
| <li>Clique em Terminar. A nova página JSP é criada na pasta <code>jsp</code> e é aberta no editor.</li> |
| |
| <li>No editor, altere o título do arquivo para <code>Olá</code> e altere a mensagem de saída para recuperar o <code>helloMessage</code> do objeto <code>ModelandView</code> criado em <code>HelloController</code>. |
| |
| |
| <pre class="examplecode"> |
| <head> |
| <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> |
| <title><strong>Hello</strong></title> |
| </head> |
| <body> |
| <h1><strong>${helloMessage}</strong></h1> |
| </body> |
| </pre></li> |
| |
| <li>Crie outra página JSP da mesma maneira <a href="#create-jsp">como acima</a>, mas nomeie-o de <code>nameView</code>.</li> |
| |
| <li>No editor, adicione a declaração da biblioteca de marcações do Spring a seguir a <code>nameView.JSP</code>. |
| |
| <pre class="examplecode"><%@taglib uri="http://www.springframework.org/tags" prefix="spring" %></pre> |
| |
| Isso importa a <a href="http://static.springframework.org/spring/docs/2.5.x/reference/spring.tld.html">biblioteca de marcas Spring</a>, que contém marcas úteis durante a implementação de visualizações como páginas JSP. |
| |
| <li>Altere o conteúdo das marcas <code><title></code> e <code><h1></code> para que se leia: <code>Indique seu nome</code>.</li> |
| |
| <li>Insira o código a seguir abaixo das marcações <code><h1></code>: |
| |
| <pre class="examplecode"> |
| <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> |
| </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 marca de vinculação fornece um status de e valor de vinculação, que você usa como o nome e o valor do campo de entrada. Dessa forma, quando o formulário é 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, você define <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> como mostrado acima, o caminho para o bean se torna: <code>name.value</code>. Como você lembra, 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 do aplicativo. Atualmente, o ponto de entrada do projeto ainda é <code>index.htm</code> que, como 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 escolha Propriedades. A caixa de diálogo Propriedades do projeto é exibida. Em Categorias, selecione Executar. No campo URL relativa, 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 pela definição do bean seguinte em <code>dispatcher-servlet.xml</code>: |
| |
| <pre class="examplecode"><bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/></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, tal como <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 escolha Executar. Isso compila, implanta e executa o projeto. Seu navegador padrão se abre exibindo <code>hello.htm</code> como o <code>nameView</code> do projeto: |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/name-view.png" |
| alt="nameView exibido em um navegador" |
| title="nameView é exibido em um navegador" |
| class="b-all margin-around"> |
| |
| <br> |
| Indique seu nome no campo de texto e clique Enter. O <code>helloView</code> é exibido com uma mensagem de saudação: |
| |
| <br> |
| <img src="../../../images_www/articles/71/web/spring/hello-view.png" |
| alt="helloView exibido em um navegador" |
| title="helloView é exibido em um navegador" |
| class="b-all margin-around"></li> |
| </ol> |
| |
| |
| <div class="feedback-box"> |
| <a href="/about/contact_form.html?to=3&subject=Feedback:%20Introduction%20to%20Spring">Envie-nos seus comentários</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 um aplicativo da Web MVC simples no NetBeans IDE utilizando o Spring Framework e apresentou-lhe a interface do IDE para o desenvolvimento de aplicativos da Web.</p> |
| |
| <p>Você é encorajado a continuar a aprender sobre o Spring Framework trabalhando em outros tutoriais do NetBeans IDE, tal como <a href="http://sites.google.com/site/springmvcnetbeans/step-by-step/">Desenvolvendo um aplicativo Spring Framework MVC passo a passo utilizando o NetBeans e o GlassFish</a>. Esse é o <a href="http://static.springframework.org/docs/Spring-MVC-step-by-step/">tutorial oficial do Spring Framework</a> por Thomas Risberg que foi adaptado para NetBeans IDE por Arulazi Dhesiaseelan.</p> |
| |
| <p>Muitos dos recursos de módulo do Spring NetBeans também podem ser aplicados a aplicativos 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 para um Web Framework</a> Um guia básico que descreve como adicionar suporte instalando um plug-in de framework da Web usando a Central de atualizações do NetBeans .</li> |
| |
| <li><a href="../../docs/web/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> |
