CRUD com REST Spring-Boot e JPA

A meta de hoje é demonstrar um CRUD no Spring-boot. O Spring-boot é uma evolução do Spring e possui diversos pacotes de implementação incluindo JPA que faz parte da persistência do objeto relacional. No JPA os objetos da camada de modelo de banco de dados são tratados com o nome de Entities ou Entity.

Vamos inciar abrindo o Eclipse com suporte a Java, levando em consideração o JDK e Jre já instalados assim como as variáveis de ambiente.

Na caixa input de acesso rápido digite marketplace e deverá abrir uma janela.

Na caixa de entrada de texto digite STS e clique GO. Deverá aparecer um plugin String Tool Suite que vai nos ajudar a implementar o Spring-boot no Eclipse.

No meu caso o STS já está instalado. Se não estiver clique em Install e proceda com a instalação. O Eclipse deverá ser reiniciado ao término.


Com o Eclipse aberto novamente vamos clicar em File>>New>>Other e selecionar dentro da pasta Spring um projeto do tipo Spring Starter Project e clicar em next.

Deverá abri a janela abaixo:

Clique em next e na próxima janela selecione o projeto web:

Na janela seguinte clique em finish.


O projeto será criado. Na estrutura de arquivos deverá aparecer o seguinte:

O arquivo pom.xml é a alma do Maven. Através dele faremos a importação das libs necessárias. Para isso, serão adicionadas algumas dependências e o arquivo deverá ficar com o seguinte aspecto:

1. <?xml version="1.0" encoding="UTF-8"?>
2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://mvnrepository.com/artifact/mysql/mysql-connector-java http://maven.apache.org/xsd/maven-4.0.0.xsd">
4.     <modelVersion>4.0.0</modelVersion>
6.     <groupId>com.example</groupId>
7.     <artifactId>demo</artifactId>
8.     <version>0.0.1-SNAPSHOT</version>
9.     <packaging>jar</packaging>
11.     <name>demo</name>
12.     <description>Demo project for Spring Boot</description>
14.     <parent>
15.         <groupId>org.springframework.boot</groupId>
16.         <artifactId>spring-boot-starter-parent</artifactId>
17.         <version>1.4.1.RELEASE</version>
18.         <relativePath /> <!-- lookup parent from repository -->
19.     </parent>
21.     <properties>
22.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
23.         <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
24.         <java.version>1.8</java.version>
25.     </properties>
27.     <dependencies>
28.         <dependency>
29.             <groupId>org.springframework.boot</groupId>
30.             <artifactId>spring-boot-starter-jersey</artifactId>
31.         </dependency>
32.         <dependency>
33.             <groupId>org.springframework.boot</groupId>
34.             <artifactId>spring-boot-starter-web</artifactId>
35.         </dependency>
36.         <dependency>
37.             <groupId>org.springframework.boot</groupId>
38.             <artifactId>spring-boot-starter-web-services</artifactId>
39.         </dependency>
41.         <dependency>
42.             <groupId>org.springframework.boot</groupId>
43.             <artifactId>spring-boot-starter-test</artifactId>
44.             <scope>test</scope>
45.         </dependency>
46.         <dependency>
47.             <groupId>org.springframework.boot</groupId>
48.             <artifactId>spring-boot-starter-data-jpa</artifactId>
49.         </dependency>
50.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
51.         <dependency>
52.             <groupId>mysql</groupId>
53.             <artifactId>mysql-connector-java</artifactId>
54.             <version>5.1.6</version>
55.         </dependency>
56.     </dependencies>
58.     <build>
59.         <plugins>
60.             <plugin>
61.                 <groupId>org.springframework.boot</groupId>
62.                 <artifactId>spring-boot-maven-plugin</artifactId>
63.             </plugin>
64.         </plugins>
65.     </build>
68. </project>

Feito isso, clique com o direito sobre o projeto acesse Maven>>Update Project.

Veja a classe DemonstraAplication.java dentro do pacote exemplo.com.

Esta classe implementa uma chamada básica com o seguinte conteúdo:

1. package com.example;
3. import org.springframework.boot.SpringApplication;
4. import org.springframework.boot.autoconfigure.SpringBootApplication;
6. @SpringBootApplication
7. public class DemoApplication {
9.     public static void main(String[] args) {
10.         SpringApplication.run(DemoApplication.class, args);
11.     }
12. }

Vamos criar uma classe ClienteController.java dentro de um novo pacote com o nome com.example.controller com o seguinte conteúdo:

1. package com.example.controller;
3. import java.util.Collection;
5. import org.springframework.beans.factory.annotation.Autowired;
6. import org.springframework.http.HttpStatus;
7. import org.springframework.http.MediaType;
8. import org.springframework.http.ResponseEntity;
9. import org.springframework.web.bind.annotation.PathVariable;
10. import org.springframework.web.bind.annotation.RequestBody;
11. import org.springframework.web.bind.annotation.RequestMapping;
12. import org.springframework.web.bind.annotation.RequestMethod;
13. import org.springframework.web.bind.annotation.RestController;
15. import com.example.model.Cliente;
16. import com.example.service.ClienteService;
18. @RestController
19. public class ClienteController {
20.    
21.     @Autowired
22.     ClienteService clienteService;
23.    
25.     @RequestMapping(method=RequestMethod.POST, value="/clientes", consumes=MediaType.APPLICATION_JSON_VALUE)
26.     public ResponseEntity<Cliente> cadastrarCliente(@RequestBody Cliente cliente){
27.         Cliente clienteCadastrado = clienteService.cadastrar(cliente);
28.         return new ResponseEntity<Cliente>(clienteCadastrado, HttpStatus.CREATED);
29.     }
30.    
31.     @RequestMapping(method=RequestMethod.GET, value="/clientes", produces=MediaType.APPLICATION_JSON_VALUE)
32.     public ResponseEntity<Collection<Cliente>> buscarTodosClientes(){
33.         Collection<Cliente> clientesBuscados = clienteService.buscarTodos();
34.         return new ResponseEntity<>(clientesBuscados, HttpStatus.OK);
35.     }
37.     @RequestMapping(method=RequestMethod.DELETE, value="/clientes/{id}")
38.     public ResponseEntity<Cliente> excluirCliente(@PathVariable Integer id){
39.         Cliente clienteEncontrado = clienteService.buscarPorId(id);
40.         if(clienteEncontrado==null){
41.             return new ResponseEntity<>(HttpStatus.NOT_FOUND);
42.         }
43.         clienteService.excluir(clienteEncontrado);
44.         return new ResponseEntity<Cliente>(HttpStatus.OK);
45.     }
46.     @RequestMapping(method=RequestMethod.PUT, value="/clientes", consumes=MediaType.APPLICATION_JSON_VALUE)
47.     public ResponseEntity<Cliente> alterarCliente(@RequestBody Cliente cliente){
48.         Cliente clienteAlterado = clienteService.alterar(cliente);
49.         return new ResponseEntity<Cliente>(clienteAlterado, HttpStatus.OK);
50.     }
52.    
53. }

Vamos criar um pacote com.example.service com a classe ClienteService.java com o seguinte conteúdo:

1. package com.example.service;
3. import java.util.Collection;
4. import java.util.HashMap;
5. import java.util.Map;
7. import org.springframework.beans.factory.annotation.Autowired;
8. import org.springframework.stereotype.Service;
10. import com.example.model.Cliente;
11. import com.example.repository.ClienteRepository;
13. @Service
14. public class ClienteService {
16.     @Autowired
17.     ClienteRepository clienteRepository;
18.    
19.    
20.     public Cliente cadastrar(Cliente cliente){
21.         return clienteRepository.save(cliente);
22.     }
23.    
24.     public Collection<Cliente> buscarTodos(){
25.         return clienteRepository.findAll();
26.     }
27. 
    
28.     public void excluir(Cliente cliente){
29.         clienteRepository.delete(cliente);
30.     }
31. 
    
32.     public Cliente buscarPorId(Integer id) {
33.         return clienteRepository.findOne(id);
34.     }
35. 
    
36.     public Cliente alterar(Cliente cliente){
37.         return clienteRepository.save(cliente);
38.     }
39. }

Vamos criar o pacote com.example.model com o objeto Cliente.java com o seguinte conteúdo.

1. package com.example.model;
3. import javax.persistence.Entity;
4. import javax.persistence.GeneratedValue;
5. import javax.persistence.Id;
7. @Entity
8. public class Cliente {
10.     @Id
11.     @GeneratedValue
12.     private Integer id;
13.     private String nome;
14.     public Integer getId() {
15.         return id;
16.     }
17.     public void setId(Integer id) {
18.         this.id = id;
19.     }
20.     public String getNome() {
21.         return nome;
22.     }
23.     public void setNome(String nome) {
24.         this.nome = nome;
25.     }
26.    
27. }

Repare a @nnotation @Entity, é ela que define a classe como objeto e permite o acesso do service. Dentro do banco de dados a tabela precisa ter o mesmo nome da classe e as variáveis private precisam ter o mesmo nome que as colunas do banco de dados. Essa é a regra.

Vamos criar o arquivo ClienteRepository.java dentro do pacote com.example.repository com o seguinte conteúdo:

1. package com.example.repository;
3. import org.springframework.data.jpa.repository.JpaRepository;
4. import org.springframework.stereotype.Repository;
6. import com.example.model.Cliente;
8. @Repository
9. public interface ClienteRepository extends JpaRepository<Cliente, Integer>{
11. }

Agora vamos configurar o arquivo application.properties com os dados de acesso ao BD com o nome da database, usuário e senha:

1. server.port=${port:8081}
3. spring.datasource.url= jdbc:mysql://localhost:3306/db_cli
4. spring.datasource.username=root
5. spring.datasource.password=root123
6. spring.jpa.hibernate.ddl-auto=create-drop

Se o BD ainda não foi criado ainda, crie conforme o modelo Entity, com os mesmos nomes conforme já descrito.

Feito isso, todos os erros do projeto deverão desaparecer.

A estrutura deverá ficar da seguinte forma:

O sistema de arquivos já pode ser executado. Clique com o direito sobre o projeto em Run as>>Spring Boot App. A página poderá ser testada utilizando o Plugin do Chrome Postman. Depois de testar o projeto pode parar o servidor e vamos fazer uma alteração para entender um pouco o Hibernate. O Hibernate é nativo do Spring-boot.

Vamos alterar o arquivo ClienteRepository que na verdade é uma interface. Troque "public interface ClienteRepository" por "public class ClienteRepository" e salve o arquivo.

O Eclipse deverá mostrar um erro sublinhado em JpaRepository. Clique com o direito sobre a palavra para corrigir e escolha a opção "change extends to implements".

O Eclipse deverá mostrar um novo erro na palavra ClienteRepository. Clique com o direito sobre a palavra para corrigir e escolha a opção "add unimplemented methods".

A classe deverá exibir todos os métodos nativos do Hibernate que podem ser invocados pelo service, como: save(), delete(), listAll(), findOne(), getOne(), ...


Repare que em nenhum momento foram utilizados Beans. Essa implementação deverá se repetir para todas as tabelas do sistema. Este é um formato de implementação de Spring muito tradicional. O processo é muito simples e sistêmico. Isso é Java!!

Ainda existe a possibilidade de várias outras formas de implementação se for necessário, mas essa é uma das melhores. Um formato MVC de requisição com uma variante de interfaces em todas as camadas e um Dao herdado, utilizei de forma similar em um dos projetos Spring que trabalhei.

No caso do Spring tradicional com o Hibernate são gerados automaticamente arquivos *.hbm.xml que geram acesso automático ao BD através de uma serialização.


Em um post mais para frente vou abordar internacionalização e sessão de usuário.


Esta implementação especificamente foi retirada da viddeo aula High Tech Cursos:
https://www.youtube.com/watch?v=dg0aZbP8NAU&index=1&list=PLKvsMn7xWutbSELeX5j8CXF2Lxd2cj19J