SpringBoot CRUD

O que são operações CRUD?

As operações CRUD são a base mais dinâmica dos sites. Portanto, devemos entender Representa Criação, leitura/Recuperação, atualizaçãoe excluirEssas são as quatro funções básicas de armazenamento persistente.

Pode definir operações CRUD como convenções de interface do usuário, que permitem visualizar, pesquisar e modificar informações por meio de formulários e relatórios baseados em computador. CRUD é orientado a dados e é Verbos de ação HTTPUso padronizado. HTTP possui alguns verbos importantes.

POST: POST: criar novos recursos GET: ler recursos PUT: atualizar recursos existentes DELETE:

deletar recursos

em banco de dados, cada uma dessas operações é diretamente mapeada para uma série de comandos. No entanto, suas relações com RESTful API são um pouco mais complexas.

operações CRUD padrão Operação de criação: ela executa uma sentença INSERT para criar novos registros. Operação de leitura: ela lê registros da tabela com base em parâmetros de entrada. Operação de atualização: ela executa uma sentença de atualização na tabela. Ela é baseada em parâmetros de entrada. Operação de exclusão:

ela deletará a linha especificada da tabela. Ela também é baseada em parâmetros de entrada.

como operações CRUD funcionam As operações CRUD são a base mais dinâmica dos sites. Portanto, devemos entender CRUD e HTTPação verbo

distinguir supondo que quiséssemoscriar POST um novo registro, devemos usar o verbo de operação HTTP paraatualizar PUT verbo. Da mesma forma, se você quiser excluir um registro, devemos usar excluirpara excluir um registro, deve-se usar DELETE verbo. Através das operações CRUD, os usuários e administradores têm permissão para recuperar, criar, editar e excluir registros online.

Temos muitas opções para executar operações CRUD. Uma das opções mais eficazes é criar um conjunto de procedimentos armazenados em SQL para executar as operações.

As operações CRUD referem-se a todas as principais funcionalidades implementadas em aplicações de banco de dados relacionais. Cada letra do CRUD pode ser mapeada para uma sentença SQL e um método HTTP.

Spring Boot CrudRepository

Spring Boot oferece uma interface chamada CrudRepository a interface, que contém métodos para operações CRUD. Ela está no pacote org.springframework.data.repository definido. Ela estende a Spring Data repositóriointerface. Ela oferece operações Crud genéricas no repositório. Se você quiser usarCrudRepository em seu aplicativo, deve criar uma interface e estender CrudRepository .

sintaxe

public interface CrudRepository<T,ID> extends Repository<T,ID>

onde

T é o tipo de domínio gerenciado pelo repositório. ID é o tipo de ID da entidade gerenciada pelo repositório.

Por exemplo:

public interface StudentRepository extends CrudRepository<Student, Integer>
{
}

no exemplo acima, criamos um nome StudentRepository a interface, que estendeCrudRepository. Entre Student é o repositório a ser gerenciado, enquanto Integer é o tipo de ID definido no repositório Student.

Spring inicializa JpaRepository

JpaRepository fornece métodos relacionados ao JPA, como refresh, contexto de persistência e deleção em lote de um registro. Ele está no pacote definido em org.springframework.data.jpa.repository. JpaRepository estende CrudRepository e PagingAndSortingRepository.

Por exemplo:

public interface BookDAO extends JpaRepository　
{
}

Por que usar essas interfaces?

Essas interfaces permitem que o Spring encontre interfaces de repositório e crie objetos proxy para isso. Ele fornece métodos que nos permitem executar algumas operações comuns. Também podemos definir métodos personalizados.

CrudRepository e JpaRepository

Exemplo de operações CRUD do Spring Boot

Vamos configurar uma aplicação Spring Boot e executar operações CRUD.

passos1: Abra o Spring Initializr http://start.spring.io .

passos2: Escolha a versão do Spring Boot 2.3.0.M1.

passos2: GroupNome. Fornecemos com.w3codebox.

passos3: Provide Artifact ID. We provide spring-boot-crud-operation.

passos5: Add dependencies Spring Web, Spring Data JPA,e H2database.

passos6: clique Generate (Generate) button. When we click the 'Generate' button, it will package the specifications in Jar files and download them to the local system.

passos7: Extract Jar file and paste it into the STS workspace.

passos8: MoveProject folder import STS.

File-> Import-> Existing Maven project-> Browse-> Select folder spring-boot-crud-operation-> Complete

Importing may take some time.

passos9: Create a directory named com.w3codebox.model The package. Folder src/main/java.

passos10: No pacote com.w3Create the class in codebox.model. Criamos um nome Books class. In the 'Books' class, we performed the following operations:

Define four variables bookid, bookname, author,e Generate Getter and Setters.
Right-click on the file-> Source-> Generate Getters and Setters. Usar anotação @EntityMarcar a classe comoEntity. Usar anotação @TableMark this class as Table Name. using annotations @Column Define each variable as Column .

Books.java

package com.w3codebox.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
//mark class as an Entity　
@Entity
//defining class name as Table name
@Table
public class Books
{
//Defining book id as primary key
@Id
@Column
private int bookid;
@Column
private String bookname;
@Column
private String author;
@Column
private int price;
public int getBookid()　
{
return bookid;
}
public void setBookid(int bookid)　
{
this.bookid = bookid;
}
public String getBookname()
{
return bookname;
}
public void setBookname(String bookname)　
{
this.bookname = bookname;
}
public String getAuthor()　
{
return author;
}
public void setAuthor(String author)　
{
this.author = author;
}
public int getPrice()　
{
return price;
}
public void setPrice(int price)　
{
this.price = price;
}
}

passos11: Neste src/main/Crie um arquivo chamado com.w3codebox.controller pacote.

passos12: No pacote com.w3Criar uma classe Controller no codebox.controller. Criamos um nome Classe controladora BooksController. Nas operações realizadas na classe BooksController,

Usar anotação @RestControllerMarcar a classe como RestController . Usar anotação @Autowired Anotação automática BooksService Classe. Definir os seguintes métodos: getAllBooks(): 。Ele retorna a lista de todos os livros. getBooks(): Ele retorna os detalhes do livro especificado na variável de caminho. Usamos a anotação @PathVariable para passar o bookid como parâmetro. A anotação indica que o parâmetro do método deve ser ligado ao variável do template de URI. deleteeBook(): Ele deleta o livro específico especificado na variável de caminho. saveBook(): Salva os detalhes do livro. A anotação @RequestBody indica que os parâmetros do método devem ser ligados ao corpo da solicitação da Web. update(): Este método atualiza um registro. Devemos especificar o registro a ser atualizado no corpo da mensagem para alcançar o mesmo objetivo. Usamos a anotação @RequestBody para isso.

BooksController.java

package com.w3codebox.controller;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.w3codebox.model.Books;
import com.w3codebox.service.BooksService;
//Marcar a classe como Controller
@RestController
public class BooksController　
{
　　　　//Automapper da classe BooksService
　　　　@Autowired
　　　　BooksService booksService;
　　　　//Criar mapeamento GET para recherçar todos os detalhes dos livros no banco de dados
　　　　@GetMapping("/book")
　　　　private List<Books> getAllBooks()　
　　　　{
　　　　return booksService.getAllBooks();
　　　　}
　　　　//Criar mapeamento GET para recherçar detalhes específicos do livro
　　　　@GetMapping("/book/{bookid}")
　　　　private Books getBooks(@PathVariable("bookid") int bookid)　
　　　　{
　　　　return booksService.getBooksById(bookid);
　　　　}
　　　　//Criar mapeamento para deletar, deletar o livro especificado
　　　　@DeleteMapping("/book/{bookid}")
　　　　private void deleteBook(@PathVariable("bookid") int bookid)　
　　　　{
　　　　booksService.delete(bookid);
　　　　}
　　　　//Criar mapeamento POST para publicar detalhes do livro no banco de dados
　　　　@PostMapping("/books")
　　　　private int saveBook(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books.getBookid();
　　　　}
　　　　//Criar mapeamento PUT para atualizar detalhes do livro
　　　　@PutMapping("}}/books")
　　　　private Books update(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books;
　　　　}
}

passos13: na pasta src/main/em criação um arquivo chamado com.w3codebox.service pacote.

passos14: classe Service classe. Nós criamos uma com.w3foi criado um nomeado BooksService classe de serviço.

BooksService.java

package com.w3codebox.service;
import java.util.ArrayList;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.w3codebox.model.Books;
import com.w3codebox.repository.BooksRepository;
//Definir a lógica de negócios
@Service
public class BooksService　
{
　　　　@Autowired
　　　　BooksRepository booksRepository;
　　　　//Usar o método findaAll() do cruddrepository para obter todos os registros de livros
　　　　public List<Books> getAllBooks()　
　　　　{
　　　　List<Books> books = new ArrayList<Books>();
　　　　booksRepository.findAll().forEach(books1　-> books.add(books1));
　　　　return books;
　　　　}
　　　　//Obter o registro específico usando o método findById() do cruddrepository
　　　　public Books getBooksById(int id)　
　　　　{
　　　　return booksRepository.findById(id).get();
　　　　}
　　　　//Usar o método save() do CrudRepository para salvar o registro específico
　　　　public void saveOrUpdate(Books books)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
　　　　//Usar o método deleteById() do CrudRepository para excluir o registro específico
　　　　public void delete(int id)　
　　　　{
　　　　booksRepository.deleteById(id);
　　　　}
　　　　//atualizar o registro
　　　　public void update(Books books, int bookid)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
}

passos15: na pasta src/main/em criação um arquivo chamado com.w3codebox.repository pacote.

o16passo: crie um repositóriointerface. Nós criamos um pacote com.w3foi criado um chamado BooksRepository do repositório. ele estende a interface Repositório Crudinterface.

BooksRepository.java

package com.w3codebox.repository;
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.Books;
//repositório que estendeCrudRepository
public interface BooksRepository extends CrudRepository<Books, Integer>
{
}

Agora, vamos em application.properties configurar o provedor de dados no arquivo URL, nome da classe do driver, nome do usuárioe Senha.

passos17: abrir application.properties e configure as seguintes propriedades.

application.properties

spring.datasource.url=jdbc:h2:mem:books_data
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialect#ativando o H2　consolespring.h2.console.enabled=true

Após criar todas as classes e pacotes, a estrutura do diretório do projeto será como follows.

Agora, vamos executar o aplicativo.

passos18: abrir SpringBootCrudOperationApplication.java e arquivo e execute-o como um aplicativo Java.

SpringBootCrudOperationApplication.java

package com.w3codebox;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class SpringBootCrudOperationApplication　
{
public static void main(String[] args)　
{
SpringApplication.run(SpringBootCrudOperationApplication.class, args);
}
}

passos19: abrir Postmane executar as seguintes operações:

Selecione POST chamar o URL http://localhost:8080/livros. SelecioneCorpo escolher o tipo de conteúdo JSON(applicação/(json). inserir dados. Inserimos os seguintes dados no corpo:

{
　　　　"bookid": "5433",
　　　　"bookname": "Core and Advance Java",
　　　　"author": "R. Nageswara Rao",
　　　　"price": "800"
}

CliqueEnviar

Após a execução bem-sucedida da solicitação，ela mostrará estado: 200 OK 。 Isso significa que o registro foi inserido com sucesso no banco de dados.

Da mesma forma，inserimos os seguintes dados.

{"bookid": "0982","bookname": "Programming with Java","author": "E. Balagurusamy","price": ""350"
}　
{
　　　　"bookid": "6321",
　　　　"bookname": "Estruturas de Dados e Algoritmos em Java",
　　　　"author": "Robert Lafore",
　　　　"price": "590"
}　
{
　　　　"bookid": "5433",
　　　　"bookname": "Effective Java",
　　　　"author": "Joshua Bloch",
　　　　"price": "670"
}

Vamos acessar H2console para ver os dados.

passos20: abrir o navegador e chamar o URL http://localhost:8080/h2-console. Clique Conectar botão，como mostrado a seguir.

clique conectarbotão，veremos no banco de dados Livros tabela，como mostrado a seguir.

passos21: clique Livros tabela，e então clique em executarbotão. Esta tabela mostra os dados que inserimos no corpo do texto.

passos22: abrir Postman，e enviar o URL http://localhost:8080/books do GET Solicitação. Ele retorna os dados que inserimos no banco de dados.

Nós usamos a URL http://localhost:8080/book/{bookid} enviar GET Solicitação. Especificamos bookid 6830 . Ele retorna o ID683Detalhes do livro 0.

Da mesma forma, também podemos enviar DELETE Solicitação para excluir o registro. Suponhamos que queremos excluir o ID 5433 do registro do livro.

Selecione DELETE Método e chame a URL http://localhost:8080/Livro/5433. Novamente em H2Execute no console Select Consulta. Descobrimos que o ID 5433 O livro foi removido do banco de dados.

Da mesma forma, também podemos enviar PUT Solicitação para atualizar o registro. Vamos atualizar o ID 6321 o preço do livro.

Selecione PUT No corpo da solicitação, cole o registro a ser atualizado e faça as alterações. Neste exemplo, vamos atualizar o ID6321do registro do livro. Nos seguintes registros, alteramos o preço do livro.

{
　　　　"bookid": "6321",
　　　　"bookname": "Estruturas de Dados e Algoritmos em Java",
　　　　"author": "Robert Lafore",
　　　　"price": "500"
}

CliqueEnviar

Agora, vá para H2Console, verifique se as alterações foram refletidas. Vemos que o preço deste livro foi alterado, conforme mostrado a seguir.