| // |
| // 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; &#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; &#8984-2 no Mac). Você pode exibir a estrutura do modelo na janela Projetos (Ctrl-1; &#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; &#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-/ (&#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-/ (&#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. |