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 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 integrado ao Spring Framework 3.x e 2.5.6. As bibliotecas do framework são combinadas com o IDE e são automaticamente adicionadas 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 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 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 NetBeans IDE 7.2, 7.3 e 7.4

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

Software ou Recurso Versão Necessária
NetBeans IDE 7.2, 7.3, 7.4, Java EE
JDK (Java Development Kit) versão 6
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, faça download da aplicação de amostra.

Configurando um Novo Projeto com Suporte a Spring Web MVC

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

  5. Na Etapa 4, no painel Frameworks, selecione Spring Web MVC.
    Spring Web MVC exibido no painel Frameworks

    Ao selecionar o Spring Web MVC, observe que a biblioteca JSTL (JavaServer Pages Standard Tag Library) é adicionada ao classpath durante a criação do projeto por default. Desmarque essa opção (conforme indicado 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 do Spring 2.5 ao projeto, se preferir.

  6. Clique na guia 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
  7. 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.
  8. 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 Spring listados no nó das 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 em Executar Projeto (Botão Executar Projeto) 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.
    Janela de Saída exibindo 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).
    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:

<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 implantação, observe que todas as solicitaçõ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 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:

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

Visão Geral da Aplicação

A aplicação criada é composta de duas páginas JSP (que se chamam views na terminologia 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 (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 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).

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 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.
    Assistente de Novo Arquivo - categoria do 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 Finalizar. 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 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).
    Snippet do código realçado no editor
    Pressionar Ctrl-/ (&#8984-/ no Mac) alterna entre 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");
    }

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

    O editor exibindo um erro para setCommandClass()

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

  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.
  7. Digite Name para o Nome da Classe, e, para Pacote, selecione controller na lista drop-down.
  8. Clique em Finalizar. A classe Name é criada e aberta no editor.
  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:
    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.
    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 selecione HelloController para retornar à classe HelloController. Observe que o indicador de erro anterior desapareceu, mas a classe Name existe agora.
  12. Delete 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;
    }
    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.
  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).
    Caixa de diálogo Corrigir Todas as Importações

    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.

  14. Clique em OK. A instrução de importação a seguir será adicionada ao início do arquivo:
    import 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().
  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 selecione Corrigir Importações (Ctrl-Shift-I; ⌘-Shift-I no Mac). A instrução a seguir será adicionada ao início do arquivo:
    import service.HelloService;
    Todos os erros deverão 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 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:
    Funcionalidade autocompletar código chamada 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 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.
    <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 conforme acima, mas nomeie-a como nameView.
  5. No editor, adicione a declaração da biblioteca de tags do Spring a seguir a nameView.JSP.
    <%@taglib uri="http://www.springframework.org/tags" prefix="spring" %>
    Isso importa a biblioteca de tags do Spring, que contém tags úteis para a implementação de views como páginas JSP.
  6. Altere o conteúdo das tags <title> e <h1> para que se leia: Enter Your Name.
  7. Insira o código a seguir abaixo das tags <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 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.

    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.
  8. Altere o ponto de entrada relativo da aplicação. Atualmente, o ponto de entrada do projeto ainda é index.htm que, conforme 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 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:
    <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.
  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:
    nameView exibida em um browser
    Informe seu nome no campo de texto e clique Enter. O helloView é exibido com uma mensagem de saudação:
    helloView exibida em um browser

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 Desenvolvendo uma aplicação Spring Framework MVC passo a passo utilizando o NetBeans e o GlassFish Server. Esse é o 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:

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