Introdução aos Formulários no Spring MVC

1. Visão geral

Neste artigo, discutiremos os formulários Spring e a ligação de dados a um controlador. Além disso, daremos uma olhada em uma das anotações principais emSpring MVC, ou seja, @ModelAttribute.

Claro, Spring MVC é um tópico complexo com muitas coisas que você precisa entender para usá-lo em todo o seu potencial, entãodefinitely dig deeper into the framework here.

Leitura adicional:

Explorando a biblioteca de tags de formulário do SpringMVC

Um tutorial rápido e direto sobre as várias tags fornecidas pelo Spring MVC para nos ajudar a criar e validar formulários.

Introdução ao uso do FreeMarker no Spring MVC

O FreeMarker é um mecanismo de modelo baseado em Java da Apache Software Foundation. Este tutorial ilustra como configurar o FreeMarker para uso no Spring MVC.

Introdução ao uso do Thymeleaf na primavera

Thymeleaf é uma linguagem de templates com excelente integração com o Spring. Este artigo fornece uma introdução ao uso do Thymeleaf em um aplicativo Spring MVC.

2. O Modelo

Primeiro - vamos definira simple entity que vamos exibir e vincular ao formulário:

public class Employee {
    private String name;
    private long id;
    private String contactNumber;

    // standard getters and setters
}

Este será o nosso objeto de suporte de formulário.

3. A vista

A seguir - vamos definirthe actual form e, claro, o arquivo HTML que o contém. Estaremos usando uma página onde um novo funcionário é criado / registrado:

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form"%>

    
    
    
        Welcome, Enter The Employee Details
        
             
                
                    Name
                    
                
                
                    Id
                    
                
                
                    
                      Contact Number

Primeiro - observe que estamos incluindo uma biblioteca de tags em nossa página JSP - o taglibform - para ajudar a definir nosso formulário.

Em seguida - a tag<form:form> desempenha um papel importante aqui; é muito semelhante à tag HTLM<form> regular, mas o atributomodelAttribute é a chave que especifica um nome do objeto de modelo que suporta este formulário:

Isso corresponderá a@ModelAttribute posteriormente no controlador.

Em seguida - cada campo de entrada está usando outra tag útil do taglib do Spring Form -form: prefix. Cada um desses campos especificaa path attribute - isso deve corresponder a um getter / setter do atributo de modelo (neste caso, a classe Employee). Quando a página é carregada, os campos de entrada são preenchidos pelo Spring, que chama o getter de cada campo associado a um campo de entrada. Quando o formulário é enviado, os setters são chamados para salvar os valores do formulário no objeto.

Finalmente - quandothe form is submitted, o manipulador POST no controlador é invocado e o formulário é automaticamente vinculado ao argumentoemployee que passamos.

4. O controlador

Agora, vamos dar uma olhada emthe Controller que vai lidar com o backend:

@Controller
public class EmployeeController {

    @RequestMapping(value = "/employee", method = RequestMethod.GET)
    public ModelAndView showForm() {
        return new ModelAndView("employeeHome", "employee", new Employee());
    }

    @RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
    public String submit(@Valid @ModelAttribute("employee")Employee employee,
      BindingResult result, ModelMap model) {
        if (result.hasErrors()) {
            return "error";
        }
        model.addAttribute("name", employee.getName());
        model.addAttribute("contactNumber", employee.getContactNumber());
        model.addAttribute("id", employee.getId());
        return "employeeView";
    }
}

O controlador define duas operações simples - o GET para exibir dados no formulário e o POST para a operação de criação, por meio do envio do formulário.

Observe também que se o objeto chamado "employee" não for adicionado ao modelo, o Spring reclamará quando tentarmos acessar o JSP porque o JSP será configurado para vincular o formulário ao atributo do modelo "employee":

java.lang.IllegalStateException:
  Neither BindingResult nor plain target object
    for bean name 'employee' available as request attribute
  at o.s.w.s.s.BindStatus.(BindStatus.java:141)

Para acessar nosso objeto de apoio de formulário, precisamos injetá-lo por meio da anotação@ModelAttribute.

Um `+ @ ModelAttribute +` em um argumento de método indica que o argumento será recuperado do modelo. Se não estiver presente no modelo, o argumento será instanciado primeiro e depois adicionado ao modelo.

5. Tratamento de erros de vinculação

Por padrão, o Spring MVC lança uma exceção quando ocorrem erros durante a ligação de solicitação. Isso geralmente não é o que queremos, em vez disso, devemos apresentar esses erros ao usuário. Vamos usar umBindingResult adicionando um como um argumento para o nosso método de controle:

public String submit(
  @Valid @ModelAttribute("employee") Employee employee,
  BindingResult result,
  ModelMap model)

O argumentoBindingResult precisa ser posicionado logo após o nosso objeto de apoio do formulário - é um dos raros casos em que a ordem dos argumentos do método importa. Caso contrário, encontraremos a seguinte exceção:

java.lang.IllegalStateException:
  Errors/BindingResult argument declared without preceding model attribute.
    Check your handler method signature!

Agora - uma exceção não é mais lançada; em vez disso, erros [.brush: .java; .gutter: .true] #será registrado noBindingResult que é passado para o métodosubmit. Neste ponto, podemos lidar com esses erros de várias maneiras - por exemplo, a operação pode ser cancelada: #

@RequestMapping(value = "/addEmployee", method = RequestMethod.POST)
public String submit(@Valid @ModelAttribute("employee")Employee employee,
  BindingResult result,  ModelMap model) {
    if (result.hasErrors()) {
        return "error";
    }

    //Do Something
    return "employeeView";
}

Observe como, caso o resultado contenha erros, estamos retornando outra visualização ao usuário para exibir esses erros corretamente. Vamos dar uma olhada nessa visualização -error.jsp:


    
    

    
        Please enter the correct details
        
            
                Retry

6. Exibindo um funcionário

Finalmente, além de criar um novo funcionário, também podemos simplesmente exibir um - aqui está o código de visualização rápida para isso:


    Submitted Employee Information
    
        
            Name :
            ${name}
        
        
            ID :
            ${id}
        
        
            Contact Number :
            ${contactNumber}

A página JSP está simplesmente usando expressões EL para exibir valores das propriedades do objeto Employee no modelo.

7. Testando o aplicativo

O aplicativo simples pode ser implantado - por exemplo, em um servidor Tomcat - e acessado localmente:

http://localhost:8080/spring-mvc-xml/employee

Esta é a visão que contém o formulário principal - antes da operação de envio:

Exemplo do Spring MVC Form - Enviar

Após o envio, os dados são exibidos:

Exemplo do Spring MVC Form - View

E é isso -a working example of a simple form with Spring MVC, with validation.

A implementação deste tutorial Spring MVC pode ser encontrada emthe GitHub project - este é um projeto baseado em Maven, portanto, deve ser fácil de importar e executar como está.

Por fim, como eu estava dizendo no início do artigo, você devedefinitely dig deeper into Spring MVC.

TOC

Introdução aos Formulários no Spring MVC