SpringBoot Erstellen, Löschen, Ändern, Abrufen

Was sind CRUD-Operationen?

CRUD stellt dar Erstellen, Lesen/Abfragen, Aktualisierenund LöschenDiese sind die vier grundlegenden Funktionen der persistierenden Speicherung.

CRUD-Operationen können als Benutzerinterface-Verabredungen definiert werden, die es erlauben, Informationen über computergestützte Formulare und Berichte anzuzeigen, zu suchen und zu ändern. CRUD ist datenzentriert und ist HTTP-AktionsverbenStandardisierte Verwendung. HTTP hat einige wichtige Verben.

POST: Neue Ressourcen erstellen GET: Ressourcen lesen PUT: Bestehende Ressourcen aktualisieren DELETE: Ressourcen löschen

In der Datenbank werden jede dieser Operationen direkt auf eine Reihe von Befehlen abgebildet. Aber ihre Beziehung zu RESTful API ist etwas komplexer.

Standard-CRUD-Operationen

Erstellen-Operation: es führt ein INSERT-Statement aus, um neue Datensätze zu erstellen. Lesen-Operation: es liest die Datensätze der Tabelle basierend auf den Eingabeparametern. Aktualisieren-Operation: es führt ein Update-Statement auf der Tabelle aus. Es basiert auf den Eingabeparametern. Löschen-Operation: es wird die angegebene Zeile in der Tabelle löschen. Es basiert auch auf den Eingabeparametern.

funktionieren

CRUD-Operationen sind die Grundlage für dynamische Websites. Daher sollten wir CRUD und HTTP Handlungsverbenzu unterscheiden.

unterscheiden angenommen, dass wirErstellen POST ein neues Eintrag zu erstellen, sollten wir das HTTP-Operationenverben verwenden . Umein Eintrag, dann sollten wir PUT Verben. Ebenso, wenn wir LöschenDaten, dann sollte DELETE Verben. Durch CRUD-Operationen haben Benutzer und Administratoren das Recht, online Daten abzurufen, zu erstellen, zu bearbeiten und zu löschen.

Wir haben viele Optionen für CRUD-Operationen. Eine der effektivsten Optionen ist die Erstellung einer Gruppe von Prozeduren in SQL, um die Operationen auszuführen.

CRUD-Operationen beziehen sich auf alle Hauptfunktionen, die in einer relationellen Datenbankanwendung implementiert werden. Jedes Buchstabe von CRUD kann auf SQL-Anweisungen und HTTP-Methoden abgebildet werden.

Spring Boot CrudRepository

Spring Boot bietet eine Schnittstelle namens CrudRepository enthalten, die Methoden für CRUD-Operationen bereitstellen. Es befindet sich im Paket org.springframework.data.repository definiert. Es erweitert die Schnittstellen von Spring Data RepositoryOberfläche. Sie bietet auf dem Repository allgemeine CRUD-Operationen. Um CrudRepository in der Anwendung zu verwenden, muss eine Schnittstelle erstellt und erweitert werden CrudRepository .

Syntax

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

davon

T ist der Typ der Domäne für die Repository-Verwaltung. ID ist der Typ der Entitäts-ID für die Repository-Verwaltung.

Zum Beispiel:

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

im obigen Beispiel haben wir eine Anwendung erstellt, deren Name StudentRepository das Interface, das CrudRepository erweitert. In dem Student ist das zu verwaltende Repository, während Integer ist der ID-Typ im Student-Repository definiert.

Spring Initializr JpaRepository

JpaRepository bietet Methoden im Zusammenhang mit JPA, wie z.B. refresh, Persistence Context und das Löschen eines Eintrags in Batch. Es ist im Paket definiert in org.springframework.data.jpa.repository. JpaRepository erweitert CrudRepository und PagingAndSortingRepository。

Zum Beispiel:

public interface BookDAO extends JpaRepository　
{
}

Warum sollten diese Interfaces verwendet werden?

Diese Interfaces erlauben Spring, die Repository-Interfaces zu finden und dafür Proxy-Objekte zu erstellen。 Es bietet Methoden, die es uns ermöglichen, einige gängige Operationen auszuführen. Wir können auch benutzerdefinierte Methoden definieren.

CrudRepository und JpaRepository

Spring Boot CRUD-Operationenbeispiel

Lassen Sie uns eine Spring Boot-Anwendung einrichten und CRUD-Operationen ausführen。

步骤1: Öffnen Sie Spring Initializr http://start.spring.io 。

步骤2: Wählen Sie die Version von Spring Boot aus 2.3.0.M1.

步骤2: Gruppe名称。我们提供了 com.w3codebox.

步骤3: Provide Artifact ID. We provide spring-boot-crud-operation.

步骤5: Add dependencies Spring Web, Spring Data JPA,und H2database.

步骤6: 单击 Generate (Generated) button. When we click the "Generate" button, it will package the specifications in Jar Download the file to the local system.

步骤7: Extract Jar file and paste it into the STS workspace.

步骤8: ToProject folder import STS.

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

Importing may take some time.

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

步骤10: Im Paket com.w3Create the class in codebox.model. Wir haben eine Klasse namens Books class. In the "Book" class, we performed the following operations:

Define four variables bookid, bookname, author,und Generate Getter and Setters.
Right-click on the file-> Source-> Generate Getters and Setters. Verwenden Sie die Annotation @EntityMarkieren Sie die Klasse alsEntity. Verwenden Sie die Annotation @TableMark this class as Table Name. Using annotations @Column Each variable is defined 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;
}
}

步骤11: In src/main/In dem Ordner java eine Klasse namens com.w3codebox.controller Paket.

步骤12: Im Paket com.w3In codebox.controller eine Controller-Klasse erstellen. Wir haben eine Klasse namens BooksController-Kontrollklasse. In der Klasse BooksController haben wir die folgenden Aktionen durchgeführt:

Verwenden Sie die Annotation @RestControllerMarkieren Sie die Klasse als RestController . Verwenden Sie die Annotation @Autowired Automatische Annotation BooksService Klasse. Definieren Sie die folgenden Methoden: getAllBooks() 。Es gibt eine Liste aller Bücher zurück. getBooks() Es gibt die Details des Buches zurück, das wir im path-Variable angegeben haben. Durch die Verwendung der Annotation @PathVariable haben wir bookid als Parameter übergeben. Die Annotation zeigt an, dass der Methodenparameter mit dem URI-Template-Variablen verknüpft werden soll. deleteeBook() Es löscht das spezifische Buch, das wir im path-Variable angegeben haben. saveBook() Speichern Sie die Details des Buches. Die Annotation @RequestBody zeigt an, dass der Methodenparameter mit dem Textkörper der Webanfrage verknüpft werden soll. update(): Diese Methode aktualisiert einen Eintrag. Wir müssen den zu aktualisierenden Eintrag im Text angeben, um das gleiche Ziel zu erreichen. Um dies zu erreichen, haben wir die Annotation @RequestBody verwendet.

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;
//Markieren Sie die Klasse als Controller
@RestController
public class BooksController　
{
　　　　//Automatische Injektion der Klasse BooksService
　　　　@Autowired
　　　　BooksService booksService;
　　　　//Erstellen Sie das GET-Mapping, um alle detaillierten Informationen der Bücher aus der Datenbank abzurufen
　　　　@GetMapping("/book")
　　　　private List<Books> getAllBooks()　
　　　　{
　　　　return booksService.getAllBooks();
　　　　}
　　　　//Erstellen Sie das GET-Mapping zur Suche nach detaillierten Informationen eines bestimmten Buches
　　　　@GetMapping("/book/{bookid}")
　　　　private Books getBooks(@PathVariable("bookid") int bookid)　
　　　　{
　　　　return booksService.getBooksById(bookid);
　　　　}
　　　　//Erstellen Sie das Mapping zum Löschen, um das angegebene Buch zu löschen
　　　　@DeleteMapping("/book/{bookid}")
　　　　private void deleteBook(@PathVariable("bookid") int bookid)　
　　　　{
　　　　booksService.delete(bookid);
　　　　}
　　　　//Erstellen Sie das POST-Mapping, um detaillierte Informationen eines Buches in der Datenbank zu veröffentlichen
　　　　@PostMapping("/books")
　　　　private int saveBook(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books.getBookid();
　　　　}
　　　　//Erstellen Sie die PUT-Mapping zur Aktualisierung der detaillierten Informationen eines Buches
　　　　@PutMapping("/books")
　　　　private Books update(@RequestBody Books books)　
　　　　{
　　　　booksService.saveOrUpdate(books);
　　　　return books;
　　　　}
}

步骤13: im Ordner src/main/java erstellt wurde com.w3codebox.service Paket.

步骤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;
//定义业务逻辑
@Service
public class BooksService　
{
　　　　@Autowired
　　　　BooksRepository booksRepository;
　　　　//使用cruddrepository的findaAll()方法获取所有书籍记录
　　　　public List<Books> getAllBooks()　
　　　　{
　　　　List<Books> books = new ArrayList<Books>();
　　　　booksRepository.findAll().forEach(books1　-> books.add(books1));
　　　　return books;
　　　　}
　　　　//通过使用cruddrepository的findById()方法获取特定的记录
　　　　public Books getBooksById(int id)　
　　　　{
　　　　return booksRepository.findById(id).get();
　　　　}
　　　　//使用CrudRepository的save()方法保存特定记录
　　　　public void saveOrUpdate(Books books)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
　　　　//使用CrudRepository的deleteById()方法删除特定记录
　　　　public void delete(int id)　
　　　　{
　　　　booksRepository.deleteById(id);
　　　　}
　　　　//Datensatz aktualisieren
　　　　public void update(Books books, int bookid)　
　　　　{
　　　　booksRepository.save(books);
　　　　}
}

步骤15: im Ordner src/main/java erstellt wurde com.w3codebox.repository Paket.

der16Schritt: Erstellen Sie einen RepositoryInterface. Wir im Paket com.w3in codebox.repository erstellt wurde BooksRepository des Repository-Interface. es erweitert Crud-RepositoryInterface.

BooksRepository.java

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

Jetzt werden wir in application.properties in der Datei konfigurieren Datenquelle URL, Driver-Klassenname, Benutzernameund Passwort.

步骤17: 打开 application.properties Datei und konfigurieren Sie die folgenden Eigenschaften.

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#das Aktivieren des H2　consolespring.h2.console.enabled=true

Nachdem alle Klassen und Pakete erstellt wurden, sieht der Projektordner wie folgt aus.

Jetzt werden wir die Anwendung ausführen.

步骤18: 打开 SpringBootCrudOperationApplication.java Datei und als Java-Anwendung ausführen.

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);
}
}

步骤19: 打开 Postman并执行以下操作:

Wählen POST 调用URL http://localhost:8080/books。 WählenBody 选择内容类型 JSON(application/json)。 插入数据。我们已在主体中插入以下数据:

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

KlickenSenden

请求成功执行后，它会显示 状态: 200 OK 。这意味着记录已成功插入数据库中。

类似地，我们插入了以下数据。

{"bookid": "0982","bookname": "Programming with Java","author": "E. Balagurusamy","price": ""350"
}　
{
　　　　"bookid": "6321",
　　　　"bookname": "Data Structures and Algorithms in Java",
　　　　"author": "Robert Lafore",
　　　　"price": "590"
}　
{
　　　　"bookid": "5433",
　　　　"bookname": "Effective Java",
　　　　"author": "Joshua Bloch",
　　　　"price": "670"
}

让我们访问H2控制台以查看数据。

步骤20: 打开浏览器并调用URL http://localhost:8080/h2-console。单击 Connect 按钮，如下所示。

单击 连接按钮后，我们将在数据库中看到 Books 表，如下所示。

步骤21: 单击 Books 表，然后然后点击 运行按钮。该表显示了我们插入到正文中的数据。

步骤22: 打开 Postman，并发送URL为http://localhost:8080/books}} GET Anfrage. Es gibt zurück die Daten, die wir in die Datenbank eingefügt haben.

Wir senden die URL http://localhost:8080/book/{bookid} senden GET Anfrage. Wir haben bookid 6830 . Es gibt zurück ID6830 Details des Buches.

entsprechend auch senden DELETE Anfrage zum Löschen des Records. Angenommen, wir möchten das Record mit der ID 5433 Buch-Record.

Wählen DELETE Methode und rufen Sie die URL http://localhost:8080/Buch/5433. Wieder im H2im Konsolenfenster ausgeführt wird Select Abfrage. Wir finden, dass die ID 5433 Buch wurde aus der Datenbank gelöscht.

ähnlich wie auch durch Senden PUT Anfrage, um das Record zu aktualisieren. Lassen Sie uns das Record mit der ID 6321 Buchpreis.

Wählen PUT In der Anfrage-Überschrift fügen Sie das zu aktualisierende Record ein und ändern Sie es. In diesem Beispiel möchten wir das Record mit der ID6321Buch-Records. In den folgenden Records haben wir den Preis des Buches geändert.

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

KlickenSenden

Jetzt, wechseln Sie zu H2Konsolenausgabe, überprüfen Sie, ob die Änderungen bereits widergespiegelt wurden. Wir sehen, dass der Preis dieses Buches geändert wurde, wie folgt.