Introdução ao Spring Framework

Este documento, retirado do site netbeans.org, 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 é um framework popular de aplicativo de código-fonte que pode facilitar o desenvolvimento de J2EE. 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 aplicações Web.

O IDE fornece suporte interno para Spring Framework 2.5. As bibliotecas do framework são empacotadas com o IDE e são 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 Spring Web MVC DispatcherServlet. A biblioteca JSTL é registrada automaticamente. 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.springframework.org. Para obter uma explicação detalhada de como os artefatos do Spring Framework se comportam e interagem com outros objetos em um aplicativo, visite a Documentação de referência do Spring Framework oficial, ou consulte a API do Spring Framework.

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

Software ou recurso Versão necessária
NetBeans IDE Java versão 6.1 ou 6.5
Java Development Kit (JDK) versão 5 ou 6
Servidor da aplicação GlassFish
ou
Contêiner do servlet Tomcat
V2 ou V3

versão 6.x

Observações:

  • A instalação Web e Java EE permite que você instale opcionalmente o servidor de aplicações GlassFish (V2 ou V3) e o contêiner do servlet Apache Tomcat 6.0.18. Você deve instalar um deles (ou registrar outro servidor no IDE) para poder trabalhar neste tutorial.
  • 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) no menu Arquivo do IDE. Em Categorias, selecione Web Java. (Se estiver usando o NetBeans 6.1, selecione Web.) 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 configurações, selecione o servidor com o qual pretende trabalhar na lista suspensa Servidor. Deixe todas as outras configurações como padrão e clique em Próximo.
  4. Na Etapa 4, o painel Frameworks, selecione Spring Web MVC 2.5:

    Quando você seleciona Spring Web MVC 2.5, observe que é possível configurar o nome e o mapeamento do servlet do emissor do Spring na aba Configuração. Se você clica na aba Bibliotecas, observe que as bibliotecas JSTL são por padrão adicionadas ao classpath durante a criação do projeto.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). Você pode ver a estrutura do modelo na janela Projetos (Ctrl-1). Observe também que quatro arquivos se abrem por padrão no editor de código-fonte do IDE: dispatcher-servlet.xml, applicationContext.xml, redirect.jsp e index.jsp.

Executando o projeto de esqueleto

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

  1. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha Executar projeto. O IDE inicia automaticamente seu servidor, caso ele ainda não esteja sendo executado, constrói e implanta o aplicativo nele. O aplicativo é executado por meio dos dados de configuração contidos no dispatcher-servlet.xml. Observe qualquer saída exibida na janela Saída do IDE (Janela > Saída). A saída gerada termina com a mensagem CONSTRUÇÃO BEM-SUCEDIDA:

    O navegador padrão do IDE é iniciado, e você ve o conteúdo da visualização da página de boas-vindas (/WEB-INF/jsp/index.jsp):


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, observe que todas as solicitações de padrões de URL que correspondem a *.htm são mapeados 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>

A classe do servlet dispatcher, como mostrado acima, é org.springframework.web.servlet.DispatcherServlet. Essa classe é contida nas bibliotecas do Spring, que foram adicionadas ao classpath do projeto quando o projeto foi criado. Para verificar isso, na janela Projetos, faça uma busca a partir do nó Bibliotecas:

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 de código-fonte. Observe o código seguinte:

<bean id="urlMapping">
    <property name="mappings">
        <props>
            <prop key="/index.htm">indexController</prop>
        </props>
    </property>
</bean>

<bean id="viewResolver"

      p:prefix="/WEB-INF/jsp/"
      p:suffix=".jsp" />

<bean name="indexController"

      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 arquivo WAR 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 Spring Web 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, chamada serviço, é usada pelo controlador sempre que ele precisa realizar a lógica comercial. Em nosso aplicativo, a lógica comercial é a computação da mensagem hello, 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. Na janela Projetos, clique com o botão direito do mouse no nó do projeto e escolha Novo > Classe Java.
  2. No assistente para Nova classe Java exibido, indique HelloService para Nome da classe, e digite service para Nome do pacote a fim de criar um novo pacote para a classe. Clique em Terminar. O IDE cria a nova classe e abre no editor de código-fonte. Observe também que a janela Projetos se atualiza automaticamente para refletir as alterações.

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 de código-fonte, crie o seguinte método sayHello() para a classe (alterações em negrito):

public class HelloService {

    public 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 arquivo, selecione Controlador de formulário simples. Clique em Próximo.
  2. 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 abre no editor de código-fonte.
  3. Especifique as propriedades do controlador, removendo o comentário dos métodos setter exibidos por padrão no modelo da classe. Faças as alterações seguintes (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():

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

  4. 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. Indique Name para o Nome da classe, e para Pacote, selecione controller na lista suspensa. Clique em Terminar. A classe Name é criada e aberta no editor de código-fonte.
  5. Para a classe Name, crie um campo chamado value, em seguida, crie os métodos do assessor para esse campo. Digite o seguinte (alterações em negrito):
    public class Name {
    
        private String value;

    O IDE pode criar métodos do assessor para você. No Editor de código-fonte, clique com o botão direito do mouse em value e escolha Inserir código (ou pressione Alt-Insert; Ctrl-I no Mac) para abrir o menu pop-up Gerar código. Em seguida, escolha Getter e setter.

  6. 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;
    }
  7. Clique de volta em HelloController no editor de código-fonte e observe que o emblema do erro anterior desapareceu porque você criou a classe Name. 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(Object command) 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.

  8. Corrija os erros de importação, clicando com o botão direito do mouse no editor de código-fonte e escolhendo Corrigir importações (Ctrl-Shift-I; ⌘-Shift-I on Mac). A instrução de importação seguinte é adicionada ao início do arquivo:
    import org.springframework.web.servlet.ModelAndView;

    Entretanto, nem todos os erros são corrigidos, pois a classe ainda não pode identificar a classe HelloService, nem usa seu método sayHello().

  9. 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 novamente no editor de código-fonte e escolha Corrigir importações. Observe que a instrução seguinte é adicionada ao início do arquivo:

    import service.HelloService;

    Todos os erros devem ser corrigidos agora.

  10. Registre HelloService em applicationContext.xml. Abra applicationContext.xml no editor de código-fonte e indique a seguinte declaração de bean:
    <bean name="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 auto-completar de código, pressione Ctrl-Espaço quando estiver trabalhando no editor de código-fonte:

  1. Registre HelloController em dispatcher-servlet.xml. Abra dispatcher-servlet.xml no editor de código-fonte e indique a seguinte declaração de bean:
    <bean p:helloService-ref="helloService"/>

Implementando as visualizações

Para implementar a visualização desse projeto, você precisa criar duas classes 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 WEB-INF > jsp e escolha Novo > JSP. O assistente para Novo arquivo JSF se abre. Chame o arquivo de helloView. Clique em Terminar. O novo arquivo JSP é criado na pasta jsp e aberto no editor de código-fonte.
  2. No editor de código-fonte, altere o título do arquivo para Hello, e altere a mensagem de saída para recuperar o helloMessage do objeto ModelandView que é criado em HelloController:
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Hello</title>
    </head>
    <body>
        <h2>${helloMessage}</h2>
    </body>
    
  3. Crie outro arquivo JSP da mesma maneira como acima, mas chame-o de nameView.
  4. No editor de código-fonte, adicione a declaração da biblioteca de marcas seguinte 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.

  5. Altere o conteúdo das marcas <title> e <h2> para que se leia: Indique seu nome.
  6. Insira o código seguinte abaixo das marcas h2:
    <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.

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

    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.

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

    Indique seu nome no campo de texto e clique Enter. O helloView é exibido com uma mensagem de saudação:

Consulte também

Isso inclui a Introdução ao Spring Framework no NetBeans IDE. Este documento demonstrou como construir um aplicativo Web MVC simples no NetBeans IDE usando o Spring Framework, e apresentou-lhe à interface do IDE para desenvolver aplicações Web.

Você é encorajado a continuar a aprender sobre o Spring Framework, trabalhando em outros tutoriais no NetBeans IDE, tal como Developing a Spring Framework MVC Application Step-by-Step using NetBeans and GlassFish (Desenvolvendo um aplicativo Spring Framework MVC passo a passo usando NetBeans e 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:

Fonte: http://netbeans.org/kb/61/web/quickstart-webapps-spring_pt_BR.html