TOC

Aplicativo CRUD de inicialização com o Thymeleaf

Aplicativo CRUD de inicialização com o Thymeleaf

1. Visão geral

A implementação de camadasDAO que fornecem funcionalidade CRUD em entidadesJPA pode ser uma tarefa repetitiva e demorada que queremos evitar na maioria dos casos. Felizmente,Spring Boot facilita a criação de aplicativos CRUD por meio de uma camada de repositórios CRUD baseados em JPA.

In this tutorial, we’ll learn how to develop a CRUD web application with Spring Boot and Thymeleaf.

Leitura adicional:

Parâmetros de solicitação de primavera com Thymeleaf

Aprenda a usar parâmetros de solicitação com Spring e Thymeleaf.

Read more →

Alterando o diretório de modelos Thymeleaf na inicialização do Spring

Aprenda sobre os locais dos modelos Thymeleaf.

Read more →

2. As dependências do Maven

Nesse caso, contaremos comspring-boot-starter-parent para gerenciamento de dependência simples, controle de versão e configuração de plug-in. Como resultado, não precisamos especificar as versões das dependências do projeto em nosso arquivopom.xml, exceto para substituir a versão Java: 


    org.springframework.boot
    spring-boot-starter-parent
    2.0.6.RELEASE


    
        org.springframework.boot
        spring-boot-starter-web
    
    
        org.springframework.boot
        spring-boot-starter-thymeleaf
    
    
        org.springframework.boot
        spring-boot-starter-data-jpa
    
    
        com.h2database
        h2
    


    1.8

Precisamos substituir a propriedade<java.version> porque a versão Java padrão quespring-boot-starter-parent define é 1.6.

3. A Camada de Domínio

Com todas as dependências do projeto já implementadas, vamos implementar uma camada de domínio ingênua.

Para simplificar, esta camada incluirá uma única classe que será responsável por modelarUser entidades: 

@Entity
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @NotBlank(message = "Name is mandatory")
    private String name;

    @NotBlank(message = "Email is mandatory")
    private String email;

    // standard constructors / setters / getters / toString
}

Vamos ter em mente que anotamos a classe com a anotação@Entity. Therefore, the JPA implementation, which is Hibernate, in this case, will be able to perform CRUD operations on the domain entities. Para um guia introdutório ao Hibernate, visite nosso tutorial emHibernate 5 with Spring.

Além disso, restringimos os camposnameeemail com a restrição@NotBlank. Isso implica que podemos usar o Hibernate Validator para validar os campos restritos antes de persistir ou atualizar uma entidade no banco de dados.

Para obter o básico sobre isso, verifiqueour associated tutorial on Bean Validation.

4. A camada de repositório

Neste ponto, nosso aplicativo Web de amostra não faz nada. Mas isso está prestes a mudar.

Spring Data JPAallows us to implement JPA-based repositories (a fancy name for the DAO pattern implementation) with minimal fuss.

Spring Data JPA é um componente-chave dospring-boot-starter-data-jpa do Spring Boot que torna mais fácil adicionar a funcionalidade CRUD por meio de uma camada poderosa de abstração colocada no topo de uma implementação JPA. Essa camada de abstração nos permite acessar a camada de persistência sem precisar fornecer nossas próprias implementações do DAO do zero.

Para fornecer ao nosso aplicativo a funcionalidade CRUD básica em objetosUser, tudo o que precisamos fazer é estender a interfaceCrudRepository: 

@Repository
public interface UserRepository extends CrudRepository {}

E é isso! Apenas estendendo a interfaceCrudRepository, Spring Data JPA fornecerá implementações para os métodos CRUD do repositório para nós.

5. A camada do controlador

Thanks to the layer of abstraction that spring-boot-starter-data-jpa places on top of the underlying JPA implementation, we can easily add some CRUD functionality to our web application through a basic web tier.

Em nosso caso, uma única classe de controlador será suficiente para lidar com as solicitações GET e POST HTTP e, em seguida, mapeá-las para chamadas para nossa implementaçãoUserRepository.

A classe do controlador depende de alguns dos principais recursos do Spring MVC. Para obter um guia detalhado sobre Spring MVC, verifique nossoSpring MVC tutorial.

Vamos começar com os métodosshowSignUpForm()eaddUser() do controlador.

O primeiro exibirá o formulário de inscrição do usuário, enquanto o último persistirá em uma nova entidade no banco de dados após a validação dos campos restritos.

Se a entidade não passar na validação, o formulário de inscrição será exibido novamente. Caso contrário, depois que a entidade for salva, a lista de entidades persistidas será atualizada na visualização correspondente: 

@Controller
public class UserController {

    @GetMapping("/signup")
    public String showSignUpForm(User user) {
        return "add-user";
    }

    @PostMapping("/adduser")
    public String addUser(@Valid User user, BindingResult result, Model model) {
        if (result.hasErrors()) {
            return "add-user";
        }

        userRepository.save(user);
        model.addAttribute("users", userRepository.findAll());
        return "index";
    }

    // additional CRUD methods
}

Dentro doUserController we também terá o métodoshowUpdateForm() que é responsável por buscar a entidadeUser que corresponde aoid fornecido do banco de dados.

Se a entidade existir, ela será passada como um atributo de modelo para a visualização do formulário de atualização, portanto, o formulário pode ser preenchido com os valores dos camposnameeemail: 

@GetMapping("/edit/{id}")
public String showUpdateForm(@PathVariable("id") long id, Model model) {
    User user = userRepository.findById(id)
      .orElseThrow(() -> new IllegalArgumentException("Invalid user Id:" + id));

    model.addAttribute("user", user);
    return "update-user";
}

Finalmente, temos os métodosupdateUser()edeleteUser() dentro da classeUserController.

O primeiro persistirá a entidade atualizada no banco de dados, enquanto o último removerá a entidade especificada.

Nos dois casos, a lista de entidades persistidas será atualizada de acordo: 

@PostMapping("/update/{id}")
public String updateUser(@PathVariable("id") long id, @Valid User user,
  BindingResult result, Model model) {
    if (result.hasErrors()) {
        user.setId(id);
        return "update-user";
    }

    userRepository.save(user);
    model.addAttribute("users", userRepository.findAll());
    return "index";
}

@GetMapping("/delete/{id}")
public String deleteUser(@PathVariable("id") long id, Model model) {
    User user = userRepository.findById(id)
      .orElseThrow(() -> new IllegalArgumentException("Invalid user Id:" + id));
    userRepository.delete(user);
    model.addAttribute("users", userRepository.findAll());
    return "index";
}

6. A Camada de Visualização

Neste ponto, implementamos uma classe de controlador funcional que realiza operações CRUD em entidadesUser. Even so, there’s still a missing component in this schema: the view layer.

Na pastasrc/main/resources/templates, precisamos criar os modelos HTML necessários para exibir o formulário de inscrição, o formulário de atualização e renderizar a lista de entidadesUser persistentes,

Conforme declarado na introdução, usaremos o Thymeleaf como o mecanismo de modelo subjacente para analisar os arquivos de modelo.

Esta é a seção relevante do arquivoadd-user.html:

Notice how we’ve used the @\{/adduser} URL expression to specify the form’s action attribute and the $\{} variable expressions for embedding dynamic content in the template, such as the values of the name and email fields and the post-validation errors.

Semelhante aadd-user.html, é assim que o modeloupdate-user.html se parece:

Por fim, temos o arquivoindex.html que exibe a lista de entidades persistentes junto com os links para edição e remoção das existentes: 


    
No users yet!

        

            
Users

            

                
                    

                        Name
                        Email
                        Edit
                        Delete
                    

                
                
                

                    
                    
                    Edit
                    Delete
                

            
        

    

    
Add a new user

Para simplificar, os modelos parecem bastante esqueléticos e fornecem apenas a funcionalidade necessária, sem adicionarcosmetics desnecessários.

Para dar aos modelos uma aparência melhorada e atraente sem gastar muito tempo em HTML / CSS, podemos usar facilmente um kit de interface do usuárioTwitter Bootstrap gratuito, comoShards.

7. Executando o aplicativo

Finalmente, vamos definir o ponto de entrada do aplicativo. Como a maioria dos aplicativos Spring Boot, podemos fazer isso com um métodomain() simples e antigo: 

@SpringBootApplication
public class Application {

    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

Agora, vamos clicar em “Executar” em nosso IDE, abrir nosso navegador e apontar parahttp://localhost:8080.

Se a compilação foi compilada com sucessowe should see a basic CRUD user dashboard with links for adding new entities and for editing and removing existing ones.

8. Conclusão

Neste tutorial, aprendemos como criar um aplicativo Web CRUD básico com Spring Boot e Thymeleaf.

Como de costume, todos os exemplos de código mostrados no artigo estão disponíveis emon GitHub.

Related