Introdução ao Spring Web MVC

Este documento mostra como construir uma aplicação Web MVC simples usando o Spring Framework. A aplicação permite que um usuário indique seu nome em um campo de texto, e ao clicar em OK, o nome é retornado e exibido em uma segunda página com uma saudação de boas-vindas.

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.

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

  • Auto-completar de código. Chamado nos arquivos de configuração Spring XML para classes Java assim como referências de bean.
  • Navegação. Hyperlink de classes e propriedades Java mencionadas nas definições de bean Spring, assim como hyperlink para outras referências de bean Spring.
  • Refatoração. Renomeação de referências a classes Java nos arquivos de configuração Spring XML.

Para obter mais informações sobre o Spring Framework, visite http://www.springsource.org/. Para obter uma explicação detalhada de como os artefatos do Spring Framework se comportam e interagem com outros objetos em um aplicativo, consulte a Documentação de referência do Spring Framework oficial ou consulte a Documentação da API do Spring Framework.

Conteúdo

O conteúdo desta página se aplica ao IDE NetBeans 6.9, 7.0 e 7.1

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

Software ou recurso Versão necessária
NetBeans IDE 6.8, 6.9, 7.0, 7.1, Java
Java Development Kit (JDK) versão 6
Servidor GlassFish Código-fonte aberto edição 3.x

Observações:

  • A instalação Java do IDE permite, como opção, baixar e registrar o servidor GlassFish com o IDE.
  • Se você precisar comparar seu projeto com uma solução que funciona, baixe o aplicativo de amostra.

Configurando um novo projeto com suporte a Spring Web MVC

Criando um projeto de esqueleto Spring Web MVC

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

  1. 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.
  2. Em Nome do projeto, digite HelloSpring. Clique em Próximo.
  3. 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 JSR-299 neste tutorial.

    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.
  4. Na Etapa 4, o painel Frameworks, selecione Spring Web MVC.
     Spring Web MVC exibido no painel Frameworks

    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.

  5. Clique na aba Configuração e observe que o assistente permite especificar o nome e o mapeamento do servlet Spring Dispatcher.
    Opções de configuração do Spring
  6. 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: dispatcher-servlet.xml, applicationContext.xml, redirect.jsp e index.jsp.
  7. Na janela Projetos, expanda o novo nó Bibliotecas do projeto e observe que JARs do Spring estão incluídos no classpath do projeto.
    JARs do Spring listados no nó Bibliotecas do projeto

Executando o projeto de esqueleto

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

  1. Clique no botão Executar projeto (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 CONSTRUÇÃO BEM-SUCEDIDA.
    Janela Saída exibindo informações durante a execução do projeto
    O navegador padrão do IDE é iniciado e você vê o conteúdo da visualização da página de boas-vindas (/WEB-INF/jsp/index.jsp).
    Saída da página de boas-vindas exibida no navegador

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.

Para entender o que acabou de acontecer, comece examinando o descritor de deployment 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 escolha Editar. O ponto de entrada padrão do aplicativo é redirect.jsp:

<welcome-file-list>
    <welcome-file>redirect.jsp</welcome-file>
</welcome-file-list>

Em redirect.jsp, existe uma instrução de redirecionamento que aponta todas as solicitações para index.htm:

<% response.sendRedirect("index.htm"); %>

No descritor de deployment, note que todas as requisições de padrões de URL que correspondem a *.htm são mapeadas para DispatcherServlet do Spring.

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
    <servlet-name>dispatcher</servlet-name>
    <url-pattern>*.htm</url-pattern>
</servlet-mapping>

O nome completamente qualificado do servlet dispatcher, conforme mostrado acima, é org.springframework.web.servlet.DispatcherServlet. 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 spring-webmvc-3.0.0.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 aba no editor. Observe o código seguinte.

<bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> <property name="mappings"> <props> <prop key="/index.htm">indexController</prop> </props> </property> </bean> <bean id="viewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver" p:prefix="/WEB-INF/jsp/" p:suffix=".jsp" /> <bean name="indexController" class="org.springframework.web.servlet.mvc.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 por 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 tempo de execução procura a definição de um bean chamado indexController, que é convenientemente fornecido pelo projeto de esqueleto. Observe que indexController estende ParameterizableViewController. Essa é uma outra classe fornecida pelo Spring, que simplesmente retorna uma visualização. Acima, observe que p:viewName="index" especifica o nome da visualização lógica, que é resolvida por meio de viewResolver colocando-se o prefixo /WEB-INF/jsp/ e o sufixo .jsp. 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 (/WEB-INF/jsp/index.jsp).

Visão geral do aplicativo

O aplicativo criado é composto de duas páginas JSP (que se chamam visualizações na terminologia MVC). 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.

As visualizações são gerenciadas por um controlador, 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 modelo). Esse controlador do aplicativo se chama HelloController.

Em uma aplicação Web complexa, a lógica comercial não é contida diretamente no controlador. Em vez disso, outra entidade, denominada serviço, é 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 HelloService.

Implementando um serviço

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

  1. Clique no botão Novo arquivo ( botão Novo arquivo ) 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 para Nova classe Java exibido, digite HelloService para Nome da classe e digite service para Nome do pacote a fim de criar um novo pacote para a classe.
  4. Clique em Terminar. O IDE cria a nova classe e a abre no editor.

A classe HelloService realiza um serviço muito simples. Ela pega um nome como parâmetro, prepara e retorna uma String que inclui o nome. No editor, crie o seguinte método sayHello() para a classe (alterações em negrito).

public class HelloService {

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

Implementando o controlador e o modelo

Você pode usar um SimpleFormController para manipular dados do usuário e determinar qual visualização retornar.

  1. Abra o assistente para Novo arquivo pressionando Ctrl-N (⌘-N no Mac). Em Categorias, selecione Spring Framework em Tipos de arquivos e Controlador de formulário simplificado.
    Assistente Novo arquivo: categoria Spring Framework
    O NetBeans IDE fornece modelos para vários artefatos do Spring, incluindo o arquivo de configuração do Spring XML, o AbstractController e o SimpleFormController.
  2. Clique em Próximo.
  3. Chame a classe de HelloController e crie um novo pacote para ela, digitando controller no campo de texto Pacote. Clique em Terminar. O IDE cria a nova classe e a abre no editor.
  4. 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).
    Trecho de código realçado no editor
    Pressionar Ctrl-/ (&#8984-/ no Mac) alterna os comentários no editor.
  5. Faças as alterações a seguir (alterações em negrito).
    public HelloController() {
        setCommandClass(Name.class);
        setCommandName("name");
        setSuccessView("helloView");
        setFormView("nameView");
    }

    Definir FormView 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 SuccessView da mesma forma permite que você defina o nome da visualização que deve ser exibida durante um envio bem sucedido. Quando configura CommandName, 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 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 pra Name no método setCommandClass():

    O editor exibindo um erro para setCommandClass()

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

  6. 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.
  7. Indique Name para o Nome da classe, e para Pacote, selecione controller na lista suspensa.
  8. Clique em Terminar. A classe Nome é criada e aberta no editor.
  9. Para a classe Nome, crie um campo denominado valor e, em seguida, crie os métodos do acessor (por exemplo, os métodos getter e setter) para esse campo. Inicie declarando o campo valor:
    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, escolha 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 escolha Inserir código (ou pressione Alt-Insert; Ctrl-I no Mac). No menu pop-up, escolha Getter e Setter.
    O menu pop-up Gerar código exibido no editor
  10. Na caixa de diálogo exibida, selecione a opção value : Stringe clique em OK. Os métodos getValue() e setValue() são adicionados à classe Name:
    public String getValue() {
        return value;
    }
    
    public void setValue(String value) {
        this.value = value;
    }
  11. Pressione Ctrl-Tab e escolha HelloController para retornar para a classe HelloController. Observe que o identificador de erro anterior desapareceu, mas a classe Nome existe agora.
  12. Exclua o método doSubmitAction() e remova os comentários do método onSubmit(). O método onSubmit() permite que você crie seu próprio ModelAndView, que é o necessário aqui. Faça as seguintes alterações:
    @Override
    protected ModelAndView onSubmit(
                HttpServletRequest request,
                HttpServletResponse response,
                Object command,
                BindException errors) throws Exception {
    
            Name name = (Name) command;
            ModelAndView mv = new ModelAndView(getSuccessView());
            mv.addObject("helloMessage", helloService.sayHello(name.getValue()));
            return mv;
    }
    Como indicado acima, o comando é reconvertido como um objeto Name. Uma instância de ModelAndView é criada, e a visualização 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 sobe o nome helloMessage.
  13. 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).
    Caixa de diálogo Corrigir todas as importações

    Observação. Confirme se org.springframework.validation.BindException e org.springframework.web.servlet.ModelAndView estão selecionados na caixa de diálogo Corrigir todas as importações.

  14. Clique em OK. A instrução de importação seguinte é adicionada ao início do arquivo:
    importe org.springframework.web.servlet.ModelAndView;
    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 DispatcherServlet. A visualização pode tomar a forma de um nome de visualização do String, que precisará ser resolvido por um objeto ViewResolver, como alternativa, um objeto Visualização pode ser especificado diretamente. O modelo é um Mapa, que permite o uso de vários objetos, classificados por nome".

    Note 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().
  15. No HelloController, declare um campo privado chamado HelloService:
    private HelloService helloService;
    Em seguida, crie um método setter público para o campo:
    public void setHelloService(HelloService helloService) {
        this.helloService = helloService;
    }
    Finalmente, clique com o botão direito do mouse no editor e escolha Corrigir importações (Ctrl-Shift-I; ⌘-Shift-I no Mac). A instrução a seguir é adicionada ao início do arquivo:
    import service.HelloService;
    Todos os erros devem ser corrigidos agora.
  16. Registre HelloService em applicationContext.xml. Abra applicationContext.xml no editor e insira a seguinte declaração de bean:
    <bean name="helloService" class="service.HelloService" />
    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:
    Auto-completar de código chamado ao pressionar Ctrl-Espaço
  17. Registre HelloController em dispatcher-servlet.xml. Abra dispatcher-servlet.xml no editor e insira a seguinte declaração de bean:
    <bean class="controller.HelloController" p:helloService-ref="helloService"/>

Implementando as visualizações

Para implementar a visualização 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 um usuário insira 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 escolha Novo > JSP. O assistente para Novo arquivo JSF se abre. Chame o arquivo de helloView.
  2. Clique em Terminar. A nova página JSP é criada na pasta jsp e é aberta no editor.
  3. No editor, altere o título do arquivo para Olá e altere a mensagem de saída para recuperar o helloMessage do objeto ModelandView criado em HelloController.
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Hello</title>
    </head>
    <body>
        <h1>${helloMessage}</h1>
    </body>
    
  4. Crie outra página JSP da mesma maneira como acima, mas nomeie-o de nameView.
  5. No editor, adicione a declaração da biblioteca de marcações do Spring a seguir a nameView.JSP.
    <%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
    Isso importa a biblioteca de marcas Spring, que contém marcas úteis durante a implementação de visualizações como páginas JSP.
  6. Altere o conteúdo das marcas <title> e <h1> para que se leia: Indique seu nome.
  7. Insira o código a seguir abaixo das marcações <h1>:
    <spring:nestedPath path="name">
        <form action="" method="post">
            Name:
            <spring:bind path="value">
                <input type="text" name="${status.expression}" value="${status.value}">
            </spring:bind>
            <input type="submit" value="OK">
        </form>
    </spring:nestedPath>
    
    spring:bind permite que você vincule uma propriedade de bean. A 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 (controller.Name) possui uma propriedade value, portanto, você define path como value.

    spring:nestedPath permite que você anexe um caminho especificado a um bean. Sendo assim, quando usado com spring:bind como mostrado acima, o caminho para o bean se torna: name.value. Como você lembra, o nome do comando de HelloController é name. Portanto, esse caminho se refere à propriedade value de um bean chamado name no escopo da página.
  8. Altere o ponto de entrada relativo do aplicativo. Atualmente, o ponto de entrada do projeto ainda é index.htm que, como descrito em 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 escolha Propriedades. A caixa de diálogo Propriedades do projeto é exibida. Em Categorias, selecione Executar. No campo URL relativa, 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 pela definição do bean seguinte em dispatcher-servlet.xml:
    <bean class="org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"/>
    Esse bean é responsável por criar automaticamente um mapeamento de URL para todos os controladores registrados no arquivo. Ele pega o nome de classe totalmente qualificado do controlador (em nosso caso, controller.HelloController) e retira o nome do pacote e o sufixo Controller, em seguida, usa o resultado como um mapeamento de URL. Portanto, para HelloController, ele cria um mapeamento hello.htm. Entretanto, essa mágica não funciona para controladores que estão incluídos no Spring Framework, tal como ParameterizableViewController. Eles requerem mapeamento explícito.
  9. 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 hello.htm como o nameView do projeto:
    nameView exibido em um navegador
    Indique seu nome no campo de texto e clique Enter. O helloView é exibido com uma mensagem de saudação:
    helloView exibido em um navegador

Consulte também

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.

Você é encorajado a continuar a aprender sobre o Spring Framework trabalhando em outros tutoriais do NetBeans IDE, tal como Desenvolvendo um aplicativo Spring Framework MVC passo a passo utilizando o NetBeans e o GlassFish. Esse é o tutorial oficial do Spring Framework por Thomas Risberg que foi adaptado para NetBeans IDE por Arulazi Dhesiaseelan.

Muitos dos recursos de módulo do Spring NetBeans também podem ser aplicados a aplicativos Spring framework não baseados na Web.

Para outros tutoriais relacionados, consulte os seguintes recursos:

get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo