Was ist die In-Memory-Datenbank?
In-Memory-Datenbanken sind zum Speichern von Daten auf den Systemspeicher und nicht auf Festplattenspeicher angewiesen. Weil der Speicherzugriff schneller ist als der Festplattenzugriff. Wir verwenden die In-Memory-Datenbank, wenn wir die Daten nicht dauerhaft speichern müssen. Die In-Memory-Datenbank ist eine eingebettete Datenbank. Die In-Memory-Datenbanken sind standardmäßig flüchtig und alle gespeicherten Daten gehen verloren, wenn wir die Anwendung neu starten.
Die weit verbreiteten In-Memory-Datenbanken sind H2, HSQLDB (HyperSQL-Datenbank) , Und Apache Derby. Die Konfiguration wird automatisch erstellt.
Persistenz vs. In-Memory-Datenbank
Die persistente Datenbank speichert die Daten im physischen Speicher. Die Daten sind auch dann verfügbar, wenn der Datenbankserver zurückgesendet wird. Einige beliebte Persistenzdatenbanken sind Orakel, MySQL , Postgres , usw.
Im Fall der In-Memory-Datenbank, Datenspeicher im Systemspeicher . Beim Schließen des Programms gehen die Daten verloren. Es ist hilfreich für WENIG s (Proof of Concepts), nicht für eine Produktionsanwendung. Die weit verbreitete In-Memory-Datenbank ist H2.
Was ist die H2-Datenbank?
H2 ist ein eingebettet, Open-Source, Und in Erinnerung Datenbank. Es handelt sich um ein geschriebenes relationales Datenbankverwaltungssystem Java . es ist ein Kundenserver Anwendung. Es wird im Allgemeinen verwendet in Unit-Tests . Es speichert Daten im Speicher und speichert sie nicht auf der Festplatte.
Vorteile
- Nullkonfiguration
- Es ist einfach zu bedienen.
- Es ist leicht und schnell.
- Es bietet eine einfache Konfiguration zum Wechseln zwischen einer echten Datenbank und einer In-Memory-Datenbank.
- Es unterstützt die Standard-SQL- und JDBC-API.
- Es bietet eine Webkonsole zur Verwaltung der Datenbank.
Konfigurieren Sie die H2-Datenbank
Wenn wir die H2-Datenbank in einer Anwendung verwenden möchten, müssen wir die folgende Abhängigkeit in der Datei pom.xml hinzufügen:
com.h2database h2 runtime
Nachdem wir die Abhängigkeit hinzugefügt haben, müssen wir sie konfigurieren Datenquellen-URL, Name der Treiberklasse, Benutzername, Und Passwort der H2-Datenbank. Spring Boot bietet eine einfache Möglichkeit, diese Eigenschaften zu konfigurieren application.properties Datei.
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.H2Dialect
Im spring.datasource.url Eigentum, mem ist der Name einer In-Memory-Datenbank und testdb ist der Name des Schemas, das H2 standardmäßig bereitstellt. Wir können auch unser eigenes Schema und unsere eigene Datenbank definieren. Der Standardbenutzername ist An und das leere Passwort bezeichnet ein leer Passwort. Wenn wir den Benutzernamen und das Passwort ändern möchten, können wir diese Werte überschreiben.
Behalten Sie die Daten in der H2-Datenbank bei
Wenn wir die Daten in der H2-Datenbank beibehalten möchten, sollten wir die Daten in einer Datei speichern. Um dasselbe zu erreichen, müssen wir die URL-Eigenschaft der Datenquelle ändern.
#persist the data spring.datasource.url=jdbc:h2:file:/data/sampledata spring.datasource.url=jdbc:h2:C:/data/sampledata
In der oben genannten Eigenschaft ist die Beispieldaten ist ein Dateiname.
Erstellen Sie ein Schema und füllen Sie Daten auf
Wir können ein Schema definieren, indem wir ein erstellen SQL Datei in der Ressource Ordner (src/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 );
Wir können die Tabelle mit Daten füllen, indem wir eine erstellen SQL Datei in der Ressource Ordner (src/main/resource).
data.sql
INSERT INTO CITY VALUES (11, 'Delhi', 110001); INSERT INTO CITY VALUES (12, 'Kanpur', 208001); INSERT INTO CITY VALUES (13, 'Lucknow', 226001);
Spring Boot übernimmt das automatisch data.sql Datei und führen Sie sie während des Anwendungsstarts gegen die H2-Datenbank aus.
H2-Konsole
Standardmäßig ist die Konsolenansicht der H2-Datenbank deaktiviert. Bevor wir auf die H2-Datenbank zugreifen können, müssen wir sie mithilfe der folgenden Eigenschaft aktivieren.
#enabling the H2 console spring.h2.console.enabled=true
Nachdem wir die H2-Konsole aktiviert haben, können wir nun im Browser auf die H2-Konsole zugreifen, indem wir die URL http://localhost:8080/h2-console aufrufen. Die folgende Abbildung zeigt die Konsolenansicht der H2-Datenbank.
Im obigen Screenshot haben wir unsere eigene Datenbank mit dem Namen definiert javatpoint .
Beispiel für Spring Boot H2
Lassen Sie uns eine Spring Boot-Anwendung mit der H2-Datenbank einrichten.
Schritt 1: Öffnen Sie Spring Initializr http://start.spring.io .
Schritt 2: Wählen Sie die Spring Boot-Version aus 2.3.0.M1.
Schritt 2: Das ____ bereitstellen Gruppe Name. Wir haben zur Verfügung gestellt com.javatpoint.
Schritt 3: Das ____ bereitstellen Artefakt Ausweis. Wir haben zur Verfügung gestellt Spring-Boot-H2-Datenbank-Beispiel.
Schritt 5: Fügen Sie die Abhängigkeiten hinzu Spring Web, Spring Data JPA, Und H2-Datenbank.
Schritt 6: Klick auf das Generieren Taste. Wenn wir auf die Schaltfläche „Generieren“ klicken, wird das Projekt in eine Datei umhüllt Krug Datei und lädt sie auf das lokale System herunter.
Schritt 7: Extrakt Öffnen Sie die Jar-Datei und fügen Sie sie in den STS-Arbeitsbereich ein.
Schritt 8: Importieren den Projektordner in STS.
Datei -> Importieren -> Vorhandene Maven-Projekte -> Durchsuchen -> Wählen Sie den Ordner spring-boot-h2-database-example -> Fertig stellen
Der Import dauert einige Zeit.
Schritt 9: Erstellen Sie ein Paket mit dem Namen com.javatpoint.model im Ordner src/main/java.
Schritt 10: Erstellen Sie eine Modellklasse im Paket com.javatpoint.model. Wir haben eine Modellklasse mit dem Namen erstellt Student. Im Bücherkurs haben wir Folgendes getan:
- Definieren Sie vier Variablen ID, Alter, Name, Und
- Generieren Sie Getter und Setter.
Klicken Sie mit der rechten Maustaste auf die Datei -> Quelle -> Getter und Setter generieren. - Markieren Sie die Klasse als Juristische Person durch Verwendung der Anmerkung @Juristische Person.
- Markieren Sie die Klasse als Tisch Namen mithilfe der Anmerkung @Tisch.
- Definieren Sie jede Variable als Spalte durch Verwendung der Anmerkung @Spalte.
Student.java
package com.javatpoint.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 Student { //mark id as primary key @Id //defining id as column name @Column private int id; //defining name as column name @Column private String name; //defining age as column name @Column private int age; //defining email as column name @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; } } Schritt 11: Erstellen Sie ein Paket mit dem Namen com.javatpoint.controller im Ordner src/main/java.
Schritt 12: Erstellen Sie eine Controller-Klasse im Paket com.javatpoint.controller . Wir haben eine Controller-Klasse mit dem Namen erstellt StudentController . In der StudentController-Klasse haben wir Folgendes getan:
- Markieren Sie die Klasse als RestController durch Verwendung der Anmerkung @RestController.
- Autowire die StudierendenService Klasse mithilfe der Annotation @Autowired .
- Definieren Sie die folgenden Methoden:
getAllStudent(): Es wird eine Liste aller Schüler zurückgegeben.
StudentController.java
package com.javatpoint.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.javatpoint.model.Student; import com.javatpoint.service.StudentService; //creating RestController @RestController public class StudentController { //autowired the StudentService class @Autowired StudentService studentService; //creating a get mapping that retrieves all the students detail from the database @GetMapping('/student') private List getAllStudent() { return studentService.getAllStudent(); } //creating a get mapping that retrieves the detail of a specific student @GetMapping('/student/{id}') private Student getStudent(@PathVariable('id') int id) { return studentService.getStudentById(id); } //creating a delete mapping that deletes a specific student @DeleteMapping('/student/{id}') private void deleteStudent(@PathVariable('id') int id) { studentService.delete(id); } //creating post mapping that post the student detail in the database @PostMapping('/student') private int saveStudent(@RequestBody Student student) { studentService.saveOrUpdate(student); return student.getId(); } } Schritt 13: Erstellen Sie ein Paket mit dem Namen com.javatpoint.service im Ordner src/main/java.
Schritt 14: Ein ... kreieren Service Klasse. Wir haben eine Serviceklasse mit dem Namen erstellt StudierendenService im Paket com.javatpoint.service.
StudentService.java
package com.javatpoint.service; import java.util.ArrayList; import java.util.List; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.javatpoint.model.Student; import com.javatpoint.repository.StudentRepository; @Service public class StudentService { @Autowired StudentRepository studentRepository; //getting all student records public List getAllStudent() { List students = new ArrayList(); studentRepository.findAll().forEach(student -> students.add(student)); return students; } //getting a specific record public Student getStudentById(int id) { return studentRepository.findById(id).get(); } public void saveOrUpdate(Student student) { studentRepository.save(student); } //deleting a specific record public void delete(int id) { studentRepository.deleteById(id); } } Schritt 15: Erstellen Sie ein Paket mit dem Namen com.javatpoint.repository im Ordner src/main/java.
Schritt 16: Ein ... kreieren Repository Schnittstelle. Wir haben eine Repository-Schnittstelle mit dem Namen erstellt StudentRepository im Paket com.javatpoint.repository. Es erweitert die Crud-Repository Schnittstelle.
StudentRepository.java
package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.Student; public interface StudentRepository extends CrudRepository { } Jetzt konfigurieren wir die Datenquelle URL, Treiberklassenname, Benutzername, Und Passwort, im application.properties Datei.
Schritt 17: Öffne das application.properties Datei und konfigurieren Sie die folgenden Eigenschaften.
application.properties
spring.datasource.url=jdbc:h2:mem:javatpoint spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password= spring.jpa.database-platform=org.hibernate.dialect.H2Dialect #enabling the H2 console spring.h2.console.enabled=true
Hinweis: Vergessen Sie nicht, die H2-Konsole zu aktivieren.
Nachdem alle Klassen und Pakete erstellt wurden, sieht das Projektverzeichnis wie folgt aus.
Jetzt führen wir die Anwendung aus.
Schritt 18: Offen SpringBootH2DatabaseExampleApplication.java Datei und führen Sie sie als Java-Anwendung aus.
SpringBootH2DatabaseExampleApplication.java
schönstes Lächeln der Welt
package com.javatpoint; 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); } } Im nächsten Schritt verwenden wir den Rest-Client Briefträger für den Versand POST Und ERHALTEN Anfrage . Wenn der Postman nicht in Ihrem System installiert ist, führen Sie die folgenden Schritte aus:
- Laden Sie den Postman herunter von https://www.getpostman.com/downloads/ oder fügen Sie die Google Chrome-Erweiterung im Browser hinzu https://bit.ly/1HCOCwF .
- Starten Sie den Postboten und Melden Sie sich an . Einen Benutzernamen erstellen. Wir haben einen Benutzer mit dem Namen erstellt javatpoint und geklickt Einreichen
Schritt 19: Öffne das Briefträger und machen Sie Folgendes:
- Wähle aus POST
- Rufen Sie die URL http://localhost:8080/student auf.
- Wähle aus Körper
- Wählen Sie den Inhaltstyp aus JSON (application/json).
- Geben Sie die Daten ein. Wir haben folgende Daten in den Body eingefügt:
{ 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' } - Klick auf das Schicken
Wenn die Anfrage erfolgreich ausgeführt wurde, wird Folgendes angezeigt Status: 200 OK . Dies bedeutet, dass der Datensatz erfolgreich in die Datenbank eingefügt wurde.
Ebenso haben wir die folgenden Daten eingefügt.
{ 'id': '002', 'age': '24', 'name': 'Vadik', 'email': '[email protected]' } { 'id': '003', 'age': '21', 'name': 'Prateek', 'email': '[email protected]' } { 'id': '004', 'age': '25', 'name': 'Harsh', 'email': '[email protected]' } { 'id': '005', 'age': '24', 'name': 'Swarit', 'email': '[email protected]' } Lassen Sie uns auf die H2-Konsole zugreifen, um die Daten anzuzeigen.
Schritt 20: Öffnen Sie den Browser und rufen Sie die URL http://localhost:8080/h2-console auf. Klick auf das Verbinden Klicken Sie auf die Schaltfläche, wie unten gezeigt.
Nach dem Klicken auf Verbinden Knopf, wir sehen das Student Tabelle in der Datenbank, wie unten gezeigt.
Schritt 21: Klick auf das Student Tabelle und klicken Sie dann auf Laufen Taste. Die Tabelle zeigt die Daten, die wir in den Körper eingefügt haben.
Schritt 22: Öffnen Sie den Postboten und senden Sie eine ERHALTEN Anfrage. Es gibt die Daten zurück, die wir in die Datenbank eingefügt haben.
Lassen Sie uns eine senden ERHALTEN Anfrage mit der URL http://localhost:8080/student/{id}. Wir haben die URL http://localhost:8080/student/3 aufgerufen. Es werden die Details des Schülers zurückgegeben, dessen ID 3 ist.
Ebenso können wir auch eine senden LÖSCHEN Anfrage. Angenommen, wir möchten einen Studentendatensatz löschen, dessen ID 2 ist.
Um einen Studentendatensatz zu löschen, senden Sie eine LÖSCHEN Anfrage mit der URL http://localhost:8080/student/2. Wir sehen, dass der Student, dessen ID ist 2 wurde aus der Datenbank gelöscht.
Laden Sie das H2-Datenbank-Beispielprojekt herunter