English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية

SpringBoot H2数据库

Was ist eine in-Memory-Datenbank

in-Memory-Datenbanken sind abhängig vom System-Speicher und nicht vom Speicherplatz für Daten auf der Festplatte. Da der Zugriff auf den Speicher schneller ist als der Zugriff auf die Festplatte. Wenn wir keine dauerhafte Speicherung der Daten benötigen, verwenden wir in-Memory-Datenbanken. In-Memory-Datenbanken sind eingebettete Datenbanken. Standardmäßig sind in-Memory-Datenbanken nicht persistent, wenn wir die Anwendung neu starten, gehen alle gespeicherten Daten verloren.

breit verwendete in-Memory-Datenbanken sind H2, HSQLDB (HyperSQL-Datenbank) ,und Apache Derby. es erstellt automatisch die Konfiguration.

persistente und in-Memory-Datenbanken

persistente Datenbanken speichern Daten dauerhaft im physischen Speicher. Selbst wenn der Datenbankserver abstürzt, sind die Daten weiterhin verfügbar. Einige beliebte persistente Datenbanken sind Oracle, MySQL, Postgres,u. a.

In Bezug auf 内存数据库,数据存储在 系统内存中。程序关闭时丢失了数据。它对 POC (概念证明)很有帮助,而不对生产应用程序有用。广泛使用的内存数据库是 H2.

什么是H2数据库

H2 嵌入式,开源und 内存数据库。它是用 Java 编写的关系数据库管理系统。这是一个 客户端/服务器应用程序。它通常用于 单元测试。它将数据存储在内存中,而不是将数据持久存储在磁盘上。

优点

零配置 易于使用。 轻巧,快速。 它提供了简单的配置,可以在真实数据库和内存数据库之间切换。 它支持标准的SQL和JDBC API。 它提供了一个可在数据库中维护的Web控制台。

配置H2数据库

如果要在应用程序中使用H2数据库,则需要在pom.xml文件中添加以下依赖项:

<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>

添加依赖项后,我们需要配置H2数据库的 数据源URL,驱动程序类名称,用户名und Passwort。 Spring Boot提供了一种简单的方法来配置 application.properties 文件中的这些属性。

spring.datasource.url=jdbc:h2:mem:testdb
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialekt

spring.datasource.url 属性中, mem 是内存数据库的名称,而 testdb 是内存数据库的名称。默认情况下,H2提供的架构。我们还可以定义自己的架构和数据库。默认用户名是 sa ,空白密码表示 密码。如果要更改用户名和密码,可以覆盖这些值。

将数据保留在H2数据库中

如果要将数据保留在在H2数据库中,我们应该将数据存储在一个文件中。为此,我们需要更改数据源的 URL 属性。

#保存数据
spring.datasource.url=jdbc:h2:file:/data/sampledata
spring.datasource.url=jdbc:h2:C:/data/sampledata

在上面的属性中, sampledata 是一个文件名。

创建Schema构并填充数据

我们可以定义通过在 resource 文件夹(src)中创建 SQL 文件创建架构/main/resource)。

schema.sql

DROP TABLE if EXISTS CITY;
CREATE TABLE CITY (
City_code int AUTO_INCREMENT PRIMARY KEY,
city_name VARCHAR(50) NOT null,
city_pincode INT(8) NOT null,
);

we can create a resource folder (src/main/resource) to create a SQL file to fill the data in the table.

data.sql

INSERT INTO CITY VALUES ('Delhi', 110001);
INSERT INTO CITY VALUES ('Kanpur', 208001);
INSERT INTO CITY VALUES ('Lucknow', 226001);

Spring Boot automatically picks up data.sql file and run it against H2database runs it.

H2console is disabled

By default, H2database console view. When accessing H2database, we must enable the following properties to enable it.

# Aktivieren Sie H2
consolespring.h2.console.enabled=true

Before enabling H2console, now we can access it by calling the URL http://localhost:8080/h2-console in the browser.2Console. The following figure shows how to access H2database console.

In the above screenshot, we defined a console view named w3codebox database.

Spring Boot H2Beispiel

Let's set up a Spring Boot.

Schritt1: Open Spring Initializr http://start.spring.io .

Schritt2: Select Spring Boot version 2.3.0.M1.

Schritt2: provide GroupName. We provide com.w3codebox.

Schritt3: provide Artifact ID. We provide spring-boot-h2-database-example.

Schritt5: Add dependencies Spring Web, Spring Data JPA ,und H2database.

Schritt6: Klicken Sie auf Generate (Generate) button. When we click the 'Generate' button, it wraps the project in Jar the file and download it to the local system.

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

Step8Step: Importproject folder to STS.

File-> Import-> Existing Maven project-> Browse-> Select folder spring-boot-h2-database-example-> Completed

Importing takes some time.

Schritt9: src/main/the name in the java folder com.w3codebox.model .

Schritt10: package com.w3in the codebox.model. We created a class named The Student class. In the 'Book' class, we performed the following operations:

Define four variables id, age, nameund Generate Getter and Setters.
右键单击文件-> Source-> Generate Getters and Setters。
使用注解 @Entity,将类标记为 Entity . 使用注解 @Table将该类标记为 Table 名称。 通过使用注解 @Column 将每个变量定义为 Column .

Student.java

package com.w3codebox.model;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
//将类标记为实体
@Entity
//定义类名为表名
@Table
public class Student 
{
    //将id标记为主键
    @Id
    //将id定义为列名
    @Column
    private int id;
    //将name定义为列名
    @Column
    private String name;
    //将年龄age为列名
    @Column
    private int age;
    //将email定义为列名
    @Column
    private String email;
    public int getId() 
    {
    return id;
    }
    public void setId(int id) 
    {
    this.id = id;
    }
    public String getName() 
    {
    return name;
    }
    public void setName(String name) 
    {
    this.name = name;
    }
    public int getAge() 
    {
    return age;
    }
    public void setAge(int age) 
    {
    this.age = age;
    }
    public String getEmail() 
    {
    return email;
    }
    public void setEmail(String email) 
    {
    this.email = email;
    }
}

Schritt11: im Ordner src/main/java erstellt wurde, einen Namen com.w3codebox.controller Paket.  

Schritt12: 在包   com.w3codebox.controller 中创建一个Controller类。我们已经创建了名称为   StudentController 的控制器类。在StudentController类中,我们完成了以下操作:使用注解 @RestController将类标记为 RestController . 使用注解 @Autowired 自动注解 StudentService 类。 定义以下方法: getAllStudent(): Es gibt eine Liste aller Studenten zurück. getStudent(): Es gibt die detaillierten Informationen des Studenten zurück, den wir im Pfadvariable angegeben haben. Durch die Verwendung der Annotation @PathVariable haben wir id als Parameter übergeben. Die Annotation zeigt an, dass der Methodenparameter an den URI-Template-Variable gebunden werden soll. deleteStudent(): Es löscht den spezifischen Studenten, den wir im Pfadvariable angegeben haben. saveStudent(): Es speichert die detaillierten Informationen der Studenten. Die Annotation @RequestBody zeigt an, dass der Methodenparameter an den Textkörper der Webanfrage gebunden werden soll.

StudentController.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.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.w3codebox.model.Student;
import com.w3codebox.service.StudentService;
//Erstellen von RestController
@RestController
public class StudentController 
{
    //Automatische Assembly der Klasse StudentService
    @Autowired
    StudentService studentService;
    //Erstellen Sie ein GET-Mapping, um alle Studentendetails aus der Datenbank abzurufen
    @GetMapping("/student)
    private List<Student> getAllStudent() 
    {
        return studentService.getAllStudent();
    }
    //Erstellen Sie eine GET-Mapping, um spezifische Studentendetails abzurufen
    @GetMapping("/student/{id}")
    private Student getStudent(@PathVariable("id") int id) 
    {
        return studentService.getStudentById(id);
    }
    //创建删除映射,删除特定的学生
    @DeleteMapping("/student/{id}")
    private void deleteStudent(@PathVariable("id") int id) 
    {
        studentService.delete(id);
    }
    //创建在数据库中发布学生详细信息的post映射
    @PostMapping("/student)
    private int saveStudent(@RequestBody Student student) 
    {
    studentService.saveOrUpdate(student);
    return student.getId();
    }
}

Schritt13: im Ordner   src/main/java中创建名称为 com.w3codebox.service Paket.

Schritt14: eine   Service 类。我们在包   com.w3codebox.service。

StudentService.java 中创建了名为   StudentService 的服务类。

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.Student;
import com.w3codebox.repository.StudentRepository;
@Service
public class StudentService 
{
    @Autowired
    StudentRepository studentRepository;
    //获取所有学生记录
    public List<Student> getAllStudent() 
    {
    List<Student> students = new ArrayList<Student>();
    studentRepository.findAll().forEach(student -> students.add(student));
    return students;
    }
    //获取特定记录
    public Student getStudentById(int id) 
    {
    return studentRepository.findById(id).get();
    }
    public void saveOrUpdate(Student student) 
    {
    studentRepository.save(student);
    }
    //Löschen eines bestimmten Eintrags
    public void delete(int id) 
    {
    studentRepository.deleteById(id);
    }
}

Schritt15: im Ordner   src/main/java erstellt wurde, einen Namen com.w3codebox.repository Paket.

Schritt16: eine  SpeicherSchnittstelle. Wir im Paket   com.w3in codebox.repository erstellt wurde, einen Namen StudentRepository die Speicherinterface. es erweitert   Crud Repository Schnittstelle.

StudentRepository.java

package com.w3codebox.repository;
import org.springframework.data.repository.CrudRepository;
import com.w3codebox.model.Student;
public interface StudentRepository extends CrudRepository<Student, Integer>
{
}
 

Jetzt werden wir in   application.properties Konfigurieren Sie den Datenquelle in der Datei.   URL, Treiberklassenname, Benutzernameund  Passwort.

Schritt17: Öffnen   application.properties Erstellen Sie eine Datei und konfigurieren Sie die folgenden Eigenschaften.

application.properties

spring.datasource.url=jdbc:h2:mem:w3codebox
spring.datasource.driverClassName=org.h2.Driver
spring.datasource.username=sa
spring.datasource.password=
spring.jpa.database-platform=org.hibernate.dialect.H2Dialekt
# Aktivieren Sie H2
consolespring.h2.console.enabled=true
Achtung: Vergessen Sie nicht, H zu aktivieren2Konsoleneingabe.

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

Jetzt werden wir die Anwendung ausführen.

Schritt18: Öffnen   SpringBootH2DatabaseExampleApplication.java Datei als Java-Anwendung ausführen.

SpringBootH2DatabaseExampleApplication.java

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

In dem nächsten Schritt werden wir den Rest der Client-  PostmanSenden   POST und   GET Anfrage  . Führen Sie folgende Schritte aus, wenn Postman in Ihrem System nicht installiert ist:

von https://www.getpostman.com/downloads/oder im Browser https://bit.ly/1HCOCwF, um das Google Chrome-Add-on hinzuzufügen. Starten Sie Postman undRegistrierung. Erstellen Sie einen Benutzernamen. Wir haben einen Namen w3codebox von den Benutzern, und klickten auf Submit

Schritt19: Öffnen  Postmanund führen Sie folgende Aktionen aus:

Auswählen POST Aufruf URL http: //localhost: 8080/student. AuswählenKörper Inhaltstyp auswählen JSON(anwendung/json). Daten einfügen. Wir haben folgende Daten im Text eingefügt:
{
    "id": "00"1",
    "age": ""23",
    "name": "Amit",
    "email": "[email protected]"
}
KlickenSenden

Nachdem die Anfrage erfolgreich ausgeführt wurde, wird angezeigt  Status: 200 OK Dies bedeutet, dass der Eintrag erfolgreich in die Datenbank eingefügt wurde.

Ähnlich haben wir folgende Daten eingefügt.

{"id": "002","age": ""24","name": "Vadik","email": "[email protected]"
} 
{
    "id": "00"3",
    "age": ""21",
    "name": "Prateek",
    "email": "[email protected]"
} 
{
    "id": "00"4",
    "age": ""25",
    "name": "Harsh"
    "email": "[email protected]"
} 
{
    "id": "00"5",
    "age": ""24",
    "name": "Swarit",
    "email": "[email protected]"
}

Lassen Sie uns H2Konsoleneingaben, um die Daten anzuzeigen.

Schritt20: Öffnen Sie den Browser und rufen Sie die URL http://localhost:8080/h2-console. Klicken Sie auf   Verbinden Knopf, wie folgt.

Klicken Sie auf  VerbindungNach dem Klicken auf den Knopf, werden wir im Datenbank sehen  StudentTabelle, wie folgt.

Schritt21: Klicken Sie auf  StudentTabelle, dann klicken Sie auf  AusführenKnopf. Diese Tabelle zeigt die Daten, die wir in den Text eingefügt haben.

Schritt22: Postman öffnen und senden   GET Anfrage. Es gibt zurück die Daten, die wir in die Datenbank eingefügt haben.

Lassen Sie uns die URL http: //localhost: 8080/student/{id} gesendet   GET Anfrage. Wir haben die URL http://localhost:8080/student/3. Es gibt zurück ID3der Studenteninformationen.

Gleichzeitig können wir auch   Löschen Anfrage. Angenommen, wir möchten das Protokoll mit der ID2des Studentenprotokolls.

Um ein Studentenprotokoll zu löschen, senden Sie eine Anfrage mit der URL http://localhost:8080/student/des   DELETE Anfrage. Wir sehen, dass die ID   2 der Student wurde aus der Datenbank gelöscht。