SpringBoot CRUD

Cosa sono le operazioni CRUD?

CRUD Rappresenta Creare, Leggere/Ricerca, Aggiornare和 Eliminare. Queste sono le quattro funzioni fondamentali di memorizzazione persistente.

Le operazioni CRUD possono essere definite come convenzioni dell'interfaccia utente, che permettono di visualizzare, cercare e modificare informazioni attraverso moduli e report basati su computer. CRUD è orientato ai dati e Verbo d'azione HTTPL'uso standardizzato. HTTP ha alcuni verbi importanti.

POST: Creare nuove risorse GET: Leggere risorse PUT: Aggiornare risorse esistenti DELETE: Eliminare risorse

Nel database, ogni operazione è direttamente mappata a una serie di comandi. Tuttavia, il loro rapporto con l'API RESTful è un po' più complesso.

Operazioni CRUD standard

Operazione di creazione: Esegue una query INSERT per creare un nuovo record. Operazione di lettura: Leggerà i record della tabella in base ai parametri di input. Operazione di aggiornamento: Esegue una query di aggiornamento sulla tabella. Si basa sui parametri di input. Operazione di eliminazione: Eliminerà la riga specificata della tabella. Si basa anche sui parametri di input.

Il funzionamento delle operazioni CRUD

Le operazioni CRUD sono la base più dinamica dei siti web. Pertanto, dovremmo considerare CRUD E HTTP Verbo d'azioneDistinguerli

Supponiamo che vogliamo CreareUn nuovo record, dovremmo utilizzare il verbo di operazione HTTP And perform the following operations: Per AggiornareUn record, dovremmo utilizzare PUT Verbo. Allo stesso modo, se si desidera EliminareSe si desidera creare un record, si dovrebbe utilizzare DELETE Verbo. Attraverso le operazioni CRUD, gli utenti e gli amministratori hanno il diritto di cercare, creare, modificare e eliminare record online.

Abbiamo molte opzioni per eseguire operazioni CRUD. Una delle scelte più efficaci è creare un set di procedure memorizzate in SQL per eseguire le operazioni.

Le operazioni CRUD rappresentano tutte le funzionalità principali implementate nelle applicazioni di database relazionali. Ogni lettera di CRUD può essere mappata a una statement SQL e un metodo HTTP.

Spring Boot CrudRepository

Spring Boot fornisce un'interfaccia chiamata CrudRepository interfaccia che contiene metodi per operazioni CRUD. Si trova nel pacchetto org.springframework.data.repository definito. 存储库interfaccia. Fornisce operazioni Crud generali sul repository. Se si desidera utilizzare CrudRepository nell'applicazione, è necessario creare un'interfaccia e estendere CrudRepository .

sintassi

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

Dove

T è il tipo di dominio gestito dal repository. ID è il tipo di ID dell'entità gestita dal repository.

Ad esempio:

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

Nell'esempio sopra, abbiamo creato un'interfaccia chiamata StudentRepository è l'interfaccia, che estende CrudRepository. Tra cui Student è il repository da gestire, mentre Integer è il tipo di ID definito nel repository Student.

Spring inizializza JpaRepository

JpaRepository fornisce metodi relativi a JPA, come refresh, contesto di persistenza e cancellazione in blocco di una registrazione. Si trova nel pacchetto Definito in org.springframework.data.jpa.repository. JpaRepository estende CrudRepository 和 PagingAndSortingRepository.

Ad esempio:

public interface BookDAO extends JpaRepository　
{
}

Perché utilizzare queste interfacce?

Queste interfacce permettono a Spring di trovare l'interfaccia del repository e di creare un oggetto proxy per questo. Fornisce metodi che ci permettono di eseguire alcune operazioni comuni. Possiamo anche definire metodi personalizzati.

CrudRepository con JpaRepository

Esempio di operazioni CRUD di Spring Boot

Configuriamo un'applicazione Spring Boot e eseguiamo operazioni CRUD.

Passaggio 1: Aprire Spring Initializr http://start.spring.io .

Passaggio 2: Scegliere la versione di Spring Boot 2.3.0.M1.

Passaggio 2: GroupNome. Forniamo com.w3codebox.

Passaggio 3: Fornire Artifact ID. Forniamo spring-boot-crud-operation.

Passaggio 5: Aggiungere dipendenze Spring Web, Spring Data JPA,和 Database H2.

Passaggio 6: click Generate (Generato) pulsante. Quando clicchiamo sul pulsante "Genera", specificherà il pacchetto in Jar File e scaricalo sul sistema locale.

Passaggio 7: Estrai File Jar e incollarlo nella zona di lavoro di STS.

Passaggio 8: TrascinareImportare la cartella del progetto in STS.

File->Import->Progetto Maven esistente->Esplora->Seleziona la cartella spring-boot-crud-operation->Completa

L'importazione richiede un po' di tempo.

Passaggio 9: Creare una cartella con il nome com.w3codebox.model Pacchetto del programma. Cartella src/main/java.

Passaggio 10: Nel pacchetto Creare la classe in com.w3codebox.model. Abbiamo creato un nome Classe Books. Nella classe "Libri", abbiamo eseguito le seguenti operazioni:

Definire quattro variabili bookid, bookname, author,和 Generare Getter e Setter.
Fare clic con il tasto destro sul file-> Sorgente-> Generare Getters e Setters. Utilizzo delle annotazioni @EntityMarchia la classe comeEntity. Utilizzo delle annotazioni @TableMarcare la classe come Table il nome. utilizzando gli annotazioni @Column Definire ogni variabile 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;
}
}

步骤11: 在 Crea una cartella denominata src/main/java com.w3codebox.controller 的包。

Passo 12: Nel pacchetto Creare una classe Controller in com.w3codebox.controller. Abbiamo creato un nome Classe del controller BooksController. Nella classe BooksController, abbiamo completato le seguenti operazioni:

Utilizzo delle annotazioni @RestControllerMarchia la classe come RestController . Utilizzo delle annotazioni @Autowired Annotazione automatica BooksService Classe. Definire i seguenti metodi: getAllBooks(): 。Restituirà l'elenco di tutti i libri. getBooks(): Restituirà i dettagli del libro specificato nel variabile di percorso. Utilizzando l'annotazione @PathVariable, abbiamo trasmesso bookid come parametro. L'annotazione indica che il parametro del metodo deve essere vincolato al variabile di modello URI. deleteeBook(): Eliminerà il libro specifico indicato nel variabile di percorso. saveBook(): Salvare i dettagli dettagliati dei libri. L'annotazione @RequestBody indica che i parametri del metodo devono essere vincolati al corpo della richiesta web. update(): Questa方法是更新一条记录。Dobbiamo specificare il record da aggiornare nel corpo della richiesta per raggiungere lo stesso obiettivo. Per questo motivo, abbiamo utilizzato l'annotazione @RequestBody.

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;
//将类标记为　Controller
@RestController
public　class　BooksController　
{
　　　　//自动装配BooksService类
　　　　@Autowired
　　　　BooksService　booksService;
　　　　//创建从数据库检索所有图书详细信息的get映射
　　　　@GetMapping("/book")
　　　　private　List<Books>　getAllBooks()　
　　　　{
　　　　return　booksService.getAllBooks();
　　　　}
　　　　//创建检索特定书籍详细信息的get映射
　　　　@GetMapping("/book/{bookid}")
　　　　private　Books　getBooks(@PathVariable("bookid")　int　bookid)　
　　　　{
　　　　return　booksService.getBooksById(bookid);
　　　　}
　　　　//创建删除映射，删除指定的书
　　　　@DeleteMapping("/book/{bookid}")
　　　　private　void　deleteBook(@PathVariable("bookid")　int　bookid)　
　　　　{
　　　　booksService.delete(bookid);
　　　　}
　　　　//创建在数据库中发布书籍详细信息的post映射
　　　　@PostMapping("/books")
　　　　private　int　saveBook(@RequestBody　Books　books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return　books.getBookid();
　　　　}
　　　　//创建更新图书详细信息的put映射
　　　　@PutMapping("/books")
　　　　private　Books　update(@RequestBody　Books　books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books;
　　　　}
}

步骤13: nella cartella creare un file chiamato com.w3codebox.service 的包。

步骤14: 创建一个 Service 包 com.w3codebox.service中创建了一个名为 BooksService 的服务类。

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;
//Definizione della logica di business
@Service
public class BooksService　
{
　　　　@Autowired
　　　　BooksRepository booksRepository;
　　　　//Utilizzo del metodo findAll() di cruddrepository per ottenere tutti i record dei libri
　　　　public List<Books> getAllBooks()　
　　　　{
　　　　List<Books> books = new ArrayList<Books>();
　　　　booksRepository.findAll().forEach(books1 -> books.add(books1));
　　　　return books;
　　　　}
　　　　//Recupero di un record specifico utilizzando il metodo findById() di cruddrepository
　　　　public Books getBooksById(int id)　
　　　　{
　　　　return booksRepository.findById(id).get();
　　　　}
　　　　//Utilizzo del metodo save() di CrudRepository per salvare un record specifico
　　　　public void saveOrUpdate(Books books)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
　　　　//Utilizzo del metodo deleteById() di CrudRepository per eliminare un record specifico
　　　　public void delete(int id)　
　　　　{
　　　　booksRepository.deleteById(id);
　　　　}
　　　　//Aggiornamento dei record
　　　　public void update(Books books, int bookid)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
}

Passaggio 15: nella cartella creare un file chiamato com.w3codebox.repository 的包。

第16步: 创建一个 存储库界面。我们在包 com.w3codebox.repository中创建了一个名为 BooksRepository 的存储库接口。 它扩展了 Crud存储库界面。

BooksRepository.java

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

现在，我们将在 application.properties 文件中配置数据源 URL，驱动程序类名称，用户名和 密码.

步骤17: open application.properties 文件并配置以下属性。

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#启用H2控制台spring.h2.console.enabled=true

创建所有类和包之后，项目目录如下所示。

现在我们将运行该应用程序。

步骤18: open SpringBootCrudOperationApplication.java 文件并作为Java应用程序运行。

SpringBootCrudOperationApplication.java

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

In the next steps, we will use the rest client Postman. Therefore, make sure that the Postman application is already installed in your system. open PostmanStep 19:

選擇 And perform the following operations: POST 選擇Call the URL http://localhost:8080/books. Body Select content type JSON(application/json).

{
　　　　"price": "590"
　　　　Insert data. The following data has been inserted into the body:
　　　　"bookname": "Core and Advance Java",
　　　　"author": "R. Nageswara Rao",
}

點擊發送

"price": "800" After the request is successfully executed, it will display Status: 200 OK

. This means that the record has been successfully inserted into the database.

Similarly, we have inserted the following data.
}　
{
　　　　"bookid": "6321",
　　　　"bookname": "Data Structures and Algorithms in Java",
　　　　"author": "Robert Lafore",
　　　　{"bookid": "0982","bookname": "Programming with Java","author": "E. Balagurusamy","price": "350"
}　
{
　　　　"price": "590"
　　　　"bookid": "5433",
　　　　"bookname": "Effective Java",
　　　　"author": "Joshua Bloch",
}

"price": "670"

Let's access the H2 console to view the data. Step 20: Open the browser and call the URL http://localhost:8080/h2-console. Click Connect

click button, as shown below.button, we will see in the database Books table, as shown below.

Step 21: click Books table, and then click runbutton. This table displays the data we inserted into the body.

Step 22: open Postman, and sends the URL http://localhost:8080/books GET Request. It returns the data we inserted into the database.

我們以URL http://localhost:8080/book/{bookid}發送 GET 請求。我們指定了 bookid 6830 。它返回ID為6830的書的詳細信息。

同樣，我們也可以發送 DELETE 請求刪除記錄。假設我們要刪除ID為 5433 的圖書記錄。

選擇 DELETE 方法並調用URL http://localhost:8080/書/5433。再次在H2控制台中執行 Select 查詢。我們發現ID為 5433 的圖書已從數據庫中刪除。

類似地，我們也可以通過發送 PUT 請求來更新記錄。讓我們更新ID為 6321 的圖書的價格。

選擇 PUT 在請求正文中，粘貼要更新的記錄並進行更改。在本範例中，我們要更新ID為6321的書籍的記錄。在以下記錄中，我們更改了書籍的價格。

{
　　　　"bookid": "6321",
　　　　"bookname": "Data Structures and Algorithms in Java",
　　　　"author": "Robert Lafore",
　　　　"price": "500"
}

點擊發送

現在，移至H2控制台，查看更改是否已反應。我們看到這本書的價格已更改，如下所示。