O framework Spring, é um dos frameworks Java mais conhecido e utilizado. Esse framework implementa um grande número de funções, como injeção de dependência, persistência de dados e uma implementação para o padrão MVC para a criação de aplicações WEB.

O framework Spring começou a ser desenvolvido em 2002 e hoje está na versão 4, que foi lançado em dezembro de 2013.

Este artigo tem o objetivo de apresentar a criação de uma aplicação web simples com o Spring MVC, será mostrado como configurar um projeto Java web com o framework, e como desenvolver uma aplicação com algumas operações básicas como exemplo.

Desenvolvendo a Primeira Aplicação com o Spring MVC

Para mostrar como desenvolver uma aplicação com o Spring MVC, será implementado um formulário para uma classe POJO. A classe criada será a Cliente, com os atributos: nome, CPF, RG, endereço, descrição, telefone, data de nascimento, profissão e salário. A Listagem 1 mostra o código dessa classe que tem, além dos atributos, os métodos get e set.

Para a execução desse projeto serão utilizados o Java 7 e o servidor Tomcat 7, mas o Spring 4 já está preparado para executar no Java 8. Por isso, a aplicação deve funcionar em qualquer versão do Java e do Tomcat.

package com.devmedia.model;
 
import java.util.Date;
 
public class Cliente {
     
     private String nome;
     private String cpf;
     private String rg;
     private String telefone;
     private String endereco;
     private String descricao;
     private String profissao;
     private Date dataNascimento;
     private float salario;
     
     public String getNome() {
          return nome;
     }
     
     public void setNome(String nome) {
          this.nome = nome;
     }
     
     public String getCpf() {
          return cpf;
     }
     
     public void setCpf(String cpf) {
          this.cpf = cpf;
     }
     
     public String getTelefone() {
          return telefone;
     }
     
     public void setTelefone(String telefone) {
          this.telefone = telefone;
     }
     
     public String getEndereco() {
          return endereco;
     }
     
     public void setEndereco(String endereco) {
          this.endereco = endereco;
     }
     
     public String getDescricao() {
          return descricao;
     }
     
     public void setDescricao(String descricao) {
          this.descricao = descricao;
     }
 
     public String getRg() {
          return rg;
     }
 
     public void setRg(String rg) {
          this.rg = rg;
     }
 
     public Date getDataNascimento() {
          return dataNascimento;
     }
 
     public void setDataNascimento(Date dataNascimento) {
          this.dataNascimento = dataNascimento;
     }
 
     public float getSalario() {
          return salario;
     }
 
     public void setSalario(float salario) {
          this.salario = salario;
     }
 
     public String getProfissao() {
          return profissao;
     }
 
     public void setProfissao(String profissao) {
          this.profissao = profissao;
     }
 
}
Listagem 1. Implementação da classe Cliente

A aplicação terá, além da tela de formulário, uma tela que exibe os detalhes do cliente cadastrado no formulário, e uma tela que lista todos os clientes já cadastrados na aplicação.

O primeiro passo para criar a aplicação é configurar o projeto no Eclipse, utilizando o Maven. A Listagem 2 mostra como configurar as dependências necessárias para a criação da aplicação, que utilizará a última versão do Spring MVC, a versão 4.1.1.

<dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-webmvc</artifactId>
     <version>4.1.1.RELEASE</version>
</dependency>
<dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>servlet-api</artifactId>
     <version>2.5</version>
</dependency>
<dependency>
     <groupId>javax.servlet</groupId>
     <artifactId>jstl</artifactId>
     <version>1.2</version>
</dependency>
Listagem 2. Configurando o Spring MVC no projeto

Depois de configurar o maven, é necessário configurar a aplicação para utilizar o Spring MVC. A Listagem 3 mostra como configurar o arquivo web.xml. É necessário registrar o DispatcherServlet do Spring MVC e colocá-lo como parâmetro, onde estarão as configurações desse servlet, que neste exemplo está no arquivo /WEB-INF/springapp-servlet.xml. A tag load-on-startup indica que o servlet deve ser iniciado assim que a aplicação for carregada.

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
    version="3.0">

      
     <servlet>
       <servlet-name>appServlet</servlet-name>
       <servlet-class>org.springframework.web.servlet
       .DispatcherServlet</servlet-class>
       <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/springapp-servlet.xml<
        /param-value>
       </init-param>
       <load-on-startup>1</load-on-startup>
    </servlet>
      
    <servlet-mapping>
       <servlet-name>appServlet</servlet-name>
       <url-pattern>/</url-pattern>
    </servlet-mapping>

    <welcome-file-list>
       <welcome-file></welcome-file>
    </welcome-file-list>    

</web-app>
Listagem 3. Configuração do arquivo web.xml

A Listagem 4 mostra como configurar o arquivo springapp-servlet.xml, que é configurado onde estarão os controllers da aplicação. No caso deste exemplo, os controllers estarão no pacote com.devmedia.controller. Neste arquivo também é configurado onde estarão os arquivos de visão, os JSP, que neste exemplo está na pasta /WEB-INF/pages.

<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="
   http://www.springframework.org/schema/beans     
   http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
   http://www.springframework.org/schema/context 
   http://www.springframework.org/schema/context/spring-context-4.0.xsd">

   <context:component-scan base-package="com.devmedia.controller" />

   <bean
      class="org.springframework.web.servlet.view.InternalResourceViewResolver">
      <property name="prefix">
         <value>/WEB-INF/pages/</value>
      </property>
      <property name="suffix">
         <value>.jsp</value>
      </property>
    </bean>
Listagem 4. Configuração do arquivo springapp-servlet.xml

Depois da configuração do Spring são criados os controladores da aplicação. No Spring MVC, para criar um controller é utilizada a anotação @Controller e em cada método é feito um mapeamento para a URL que o controlador será chamado, com a anotação @RequestMapping. A Listagem 5 mostra o código da classe ClienteController.

;

Na anotação @RequestMapping é definido o método http que o controller executará, no caso do método cliente é listarClientes (método GET) e no caso do método adicionarCliente (método POST) o atributo value define qual vai ser a URL de acesso ao método do controller: no método cliente o endereço é /cliente; no método adicionarCliente o endereço é /addCliente; e no método listarClientes o endereço é /listaClientes.

package com.devmedia.controller;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import org.springframework.stereotype.Controller;
import org.springframework.ui.ModelMap;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import com.devmedia.model.Cliente;

@Controller
public class ClienteController {

 @RequestMapping(value = "/cliente", method = RequestMethod.GET) 
 public ModelAndView cliente() {
  return new ModelAndView("cliente", "command", new Cliente());
 }

 @RequestMapping(value = "/addCliente", method = RequestMethod.POST)
 public String adicionarCliente(
  @ModelAttribute("SpringWeb") Cliente cliente, ModelMap model, 
  HttpServletRequest request) {
        
   SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
        

   model.addAttribute("nome", cliente.getNome());
   model.addAttribute("cpf", cliente.getCpf());
   model.addAttribute("descricao", cliente.getDescricao());
   model.addAttribute("telefone", cliente.getTelefone());
   model.addAttribute("endereco", cliente.getEndereco());
   model.addAttribute("rg", cliente.getRg());
   model.addAttribute("salario", cliente.getSalario());
   model.addAttribute("dataNascimento", sdf.format(cliente
   .getDataNascimento()));
   model.addAttribute("profissao", cliente.getProfissao());
        

   List<Cliente> clientes = (List<Cliente>) 
   request.getSession().getAttribute("clientes");
   if (clientes == null) {
      clientes = new ArrayList<Cliente>();
   } 
   clientes.add(cliente);
   request.getSession().setAttribute("clientes", clientes);
        
   return "exibeCliente";
}
    
    @RequestMapping(value = "/listaClientes", method = RequestMethod.GET)
    public String listarClientes(
  @ModelAttribute("SpringWeb") ModelMap model, HttpServletRequest request) {
        
    List<Cliente> clientes = (List<Cliente>) 
    request.getAttribute("clientes");
        
    model.addAttribute("clientes", clientes);   
        
        
    return "listaClientes";
   }

}
Listagem 5. Controller ClienteController

O método cliente é responsável por encaminhar a requisição para a tela do formulário de cadastro do cliente. O método retorna um objeto da classe ModelAndView: o primeiro parâmetro - JSP - indica que a requisição será enviada; o segundo - “command” - representa o nome do objeto do tipo Cliente, que é o nome que o formulário da view usará e que foi passado como o terceiro parâmetro.

O método adicionarCliente recupera os dados passados como parâmetro do formulário de cadastro de cliente e os coloca na resposta, para que os dados do cliente possam ser escritos na próxima tela. O retorno do método (exibeCliente) significa que depois desse método a requisição será tratada pelo arquivo exibeCliente.jsp. Esse método também adiciona o cliente cadastrado a uma lista de clientes, que está na seção do usuário.

O campo data de nascimento é do tipo java.util.Date, por isso, para exibir a data com o padrão correto (“dd/MM/yyyy”) é preciso formatar o campo. Isto foi feito com classe SimpleDateFormat e a data formatada, e convertida para o tipo String foi passada para a view. Isso pode ser feito também diretamente na view, assim será mostrado como fazer isso quando for mostrado o código da tela listaCliente.jsp.

O método listarClientes recupera a lista de clientes que está na seção do usuário e a coloca na resposta para a view. Assim, a view que for renderizar a lista de clientes pode montar uma tabela com todos os dados que estão nesta lista. O retorno listaClientes indica que a resposta será criada na view listaClientes.jsp

A Listagem 6 mostra a criação da view cliente.jsp, que cria um formulário para o cadastro de um cliente. A view tem um formulário que envia os dados para o endereço /cliente/addCliente, que será tratado pelo método adicionarCliente do controlador ClienteController. A tela tem um campo de texto para o cadastro dos campos nome, CPF, RG, endereço, telefone e descrição, Salário, data de nascimento e profissão.

A tela tem também um link em que o usuário pode ir direto para a tela de listagem dos clientes cadastrados.

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
<html>
<head>
    <title>Cadastro de Cliente</title>
</head>
<body>

<h2>Formulário de Cadastro de Cliente</h2>
<form:form method="POST" action="/cliente/addCliente">
   <table>
    <tr>
        <td><form:label path="nome">Nome><
        /form:label></td>
        <td><form:input path="nome" /></td>
    </tr>
    <tr>
        <td><form:label path="cpf">CPF:<
        /form:label></td>
        <td><form:input path="cpf" /></td>
    </tr>
    <tr>
        <td><form:label path="rg">RG:<
        /form:label></td>
        <td><form:input path="rg" /></td>
    </tr>    
    <tr>
        <td><form:label path="endereco">Endereço:<
        /form:label></td>
        <td><form:textarea path="endereco" /></td>
    </tr>
    <tr>
        <td><form:label path="salario">Salário:<
        /form:label></td>
        <td><form:input path="salario" /></td>
    </tr>        
    <tr>
        <td><form:label path="telefone">Telefone:<
        /form:label></td>
        <td><form:textarea path="telefone" /></td>
    </tr>
    <tr>
        <td><form:label path="profissao">Profissão:<
        /form:label></td>
        <td><form:textarea path="profissao" /></td>
    </tr>    
    <tr>
        <td><form:label path="descricao">Descrição<
        /form:label></td>
        <td><form:textarea path="descricao" /></td>
    </tr>
     <tr>
        <td><form:label path="dataNascimento">
        Data de Nascimento:<
        /form:label></td>
        <td><form:input path="dataNascimento" /></td>
    </tr>
    <tr>
        <td colspan="2">
            <input type="submit" value="Submit"/>
        </td>
    </tr>
</table>  
</form:form>
<a href="/cliente/listaClientes">Lista</a>

</body>
</html>
Listagem 6. View cliente.jsp que cria o formulário de cadastro de cliente

A Listagem 7 mostra a criação da view exibeCliente.jsp, que exibe os dados do cliente cadastrado. Essa view tem uma tabela que exibe todos os dados inseridos no formulário da tela anterior. Os dados são acessados pelos nomes que foram inseridos no model ainda no controllor ClienteController.

Além da tabela, essa view tem também dois links: um que leva o usuário novamente para a tela de cadastro, para que ele possa cadastrar mais um cliente; ou para uma tela de listagem, onde ele pode visualizar todos os clientes cadastrados na aplicação.

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<html>
<head>
    <title>Exibe Detalhes do Cliente</title>
</head>
<body>

<h2>Detalhes do Cliente Cadastrado</h2>
   <table>
    <tr>
        <td>Nome:</td>
        <td>$</td>
    </tr>
    <tr>
        <td>CPF:</td>
        <td>$</td>
    </tr>
    <tr>
        <td>RG:</td>
        <td>$</td>
    </tr>    
    <tr>
        <td>Salário:</td>
        <td>$</td>
    </tr>    
    <tr>
        <td>Endereço:</td>
        <td>$</td>
    </tr>
    <tr>
        <td>Profissão:</td>
        <td>$</td>
    </tr>    
    <tr>
        <td>Telefone:</td>
        <td>$</td>
    </tr>
    <tr>
        <td>Descrição:</td>
        <td>$</td>
    </tr>
    <tr>
        <td>Data de Nascimento:</td>
        <td>$</td>
    </tr>    
</table>  
<a href="/cliente/cliente">Cadastro</a>
<a href="/cliente/listaClientes">Lista</a>

</body>
</html>
Listagem 7. View exibeCliente.jsp que exibe os dados do cliente cadastrado

Conforme mostra a Listagem 8, a view listaClientes.jsp mostra todos os clientes cadastrados na aplicação. Para isso, é acessado o atributo clientes que está na sessão do usuário. Primeiro é verificado se a lista clientes está vazia, se não estiver, é criada uma tabela onde são exibidos os atributos nome, cpf, telefone, endereço e descrição de todos os clientes cadastrados na aplicação.

Além da tabela, essa view tem também um link para a view cliente.jsp, que é a tela que contém o formulário para o cadastro de clientes.

Assim como aconteceu na tela exibeCliente, onde foi necessário fazer a conversão da data de nascimento do cliente, nesta tela também será necessário fazer isso. Para exibir a data no formato correto foi utilizada a tag fmt:formatDate que formata uma data e a exibe no padrão desejado.

<%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<%@taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
<html>
<head>
    <title>Lista de Clientes Cadastrados</title>
</head>
<body>
    <h2>Lista de Clientes Cadastrados</h2>
 
    <c:if test="${not empty clientes}">
        <table>
            <tr>
                <td>Nome</td>
                <td>CPF</td>
                <td>Telefone</td>
                <td>Endereço</td>
                <td>Descrição</td>
                <td>Profissão</td>
                <td>RG</td>
                <td>Salário</td>
                <td>Data de Nascimento</td>
                
            </tr>
 
        
            <c:forEach var="listValue" items="$">
                
                <tr>
                    <td>${listValue.nome}</td>
                    <td>${listValue.cpf}</td>
                    <td>${listValue.telefone}</td>
                    <td>${listValue.endereco}</td>
                    <td>${listValue.descricao}</td>
                    <td>${listValue.profissao}</td>
                    <td>${listValue.rg}</td>
                    <td>${listValue.salario}</td>
                    <td><fmt:formatDate pattern="dd/MM/yyyy" 
                    value="${listValue.dataNascimento}" /></td>
                </tr>
            </c:forEach>
        
        </table>
 
    </c:if>
    <a href="/cliente/cliente">Cadastro</a>
    
</body>
</html>
Listagem 8. View listaClientes.jsp que lista todos os clientes cadastrados

Para mostrar a aplicação que foi desenvolvida, a Figura 1 mostra em um browser a tela com o formulário de cadastro de cliente. A Figura 2 mostra a tela que exibe os dados de uma pessoa cadastrada no formulário e a Figura 3 mostra a tela que exibe a tabela com todas as pessoas cadastradas na aplicação.

Tela para o cadastro de clientes
Figura 1. Tela para o cadastro de clientes
Tela para a exibição dos dados do cliente cadastrado
Figura 2. Tela para a exibição dos dados do cliente cadastrado

O Spring é um dos frameworks mais conhecidos da plataforma Java. O Spring MVC, que é a implementação do padrão Model View Controller, é um dos frameworks mais utilizados para a criação de aplicações Web.

Tela que exibe todos os clientes cadastrados na aplicação
Figura 3. Tela que exibe todos os clientes cadastrados na aplicação

Este artigo mostrou como configurar e como implementar uma aplicação simples utilizando os principais conceitos do framework Spring MVC.

Espero que tenham gostado do artigo e que ele seja útil. Até a próxima!


Saiu na DevMedia!

  • Usabilidade e experiência do usuário em aplicativos sensíveis ao contexto: Este artigo trata de questões de usabilidade em aplicativos sensíveis ao contexto, tendo como principal objetivo o aprimoramento da experiência do usuário, exemplificando e conceituando algumas questões que devem ser consideradas.
  • Delphi: Cadastro Orientado a Objetos com FireDAC: Neste curso você aprenderá a criar CRUD em Delphi com uma entidade. Trabalhar com manipulação de dados (inserir, editar, deletar e buscar) em Delphi é fundamental para desenvolvermos a maioria das aplicações é de suma importância no desenvolvimento de software.
  • ASP.NET Web API: Criando uma API RESTful 1:N: Neste curso veremos como desenvolver um web service RESTful em C# utilizando o ASP.NET Web API. Neste serviço implementaremos um cadastro de Cursos e Aulas, que possuem um relacionamento do tipo 1:N (um curso tem muitas aulas, enquanto uma aula pertence a um curso).

Saiba mais sobre Java ;)

  • Carreira Programador Java: esse Guia de Referência você encontrará o conteúdo que precisa para iniciar seus estudos sobre a tecnologia Java, base para o desenvolvimento de aplicações desktop, web e mobile/embarcadas.
  • Guia Completo de Spring Framework: Neste Guia de Referência você encontrará o conteúdo que precisa para aprender a desenvolver aplicações utilizando o Spring Framework e seus subprojetos.
  • Guia Completo de Java: Neste Guia de Referência você encontrará todo o conteúdo que precisa para começar a programar com a linguagem Java, a sua caixa de ferramentas base para criar aplicações com Java.