logo

TechCodeview

Spring Boot H2 Database

Vad är in-memory-databasen

In-memory databas är beroende av systemminne i motsats till diskutrymme för lagring av data. Eftersom minnesåtkomst är snabbare än diskåtkomst. Vi använder in-memory-databasen när vi inte behöver bevara data. In-memory-databasen är en inbäddad databas. Databaserna i minnet är flyktiga, som standard, och all lagrad data går förlorad när vi startar om programmet.

De mycket använda minnesdatabaserna är H2, HSQLDB (HyperSQL-databas) , och Apache Derby. Den skapar konfigurationen automatiskt.

binärt sökträd

Persistens vs In-memory Database

Den beständiga databasen behåller data i det fysiska minnet. Data kommer att vara tillgänglig även om databasservern studsar. Några populära persistensdatabaser är Oracle, MySQL , Postgres , etc.

I fallet med minnesdatabas, datalagret i system minne . Den förlorade data när programmet stängdes. Det är till hjälp för LITEN s (Proof of Concepts), inte för en produktionsapplikation. Den allmänt använda in-memory databasen är H2.

Vad är H2-databasen

H2 är en inbäddad, öppen källkod, och i minne databas. Det är ett relationsdatabashanteringssystem skrivet i Java . Det är en klient-server Ansökan. Det används vanligtvis i enhetstestning . Den lagrar data i minnet, inte kvarstår data på disken.

Fördelar

  • Noll konfiguration
  • Det är lätt att använda.
  • Den är lätt och snabb.
  • Det ger enkel konfiguration för att växla mellan en riktig databas och en databas i minnet.
  • Den stöder standard SQL och JDBC API.
  • Det tillhandahåller en webbkonsol att underhålla i databasen.

Konfigurera H2 Database

Om vi ​​vill använda H2-databasen i en applikation måste vi lägga till följande beroende i filen pom.xml:

 com.h2database h2 runtime

Efter att ha lagt till beroendet måste vi konfigurera datakällans URL, förarklassnamn, användarnamn, och Lösenord av H2-databasen. Spring Boot ger ett enkelt sätt att konfigurera dessa egenskaper i applikationsegenskaper fil.

 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

I den spring.datasource.url fast egendom, mem är namnet på en minnesdatabas och testdb är namnet på schemat som H2 tillhandahåller, som standard. Vi kan också definiera vårt eget schema och databas. Standardanvändarnamnet är på och det tomma lösenordet anger en tömma Lösenord. Om vi ​​vill ändra användarnamn och lösenord kan vi åsidosätta dessa värden.

Behåll data i H2 Database

Om vi ​​vill bevara data i H2-databasen bör vi lagra data i en fil. För att uppnå samma sak måste vi ändra datakällans URL-egenskap.

 #persist the data spring.datasource.url=jdbc:h2:file:/data/sampledata spring.datasource.url=jdbc:h2:C:/data/sampledata

I ovanstående fastighet, den stickprov är ett filnamn.

Skapa schema och fyll i data

Vi kan definiera ett schema genom att skapa ett SQL fil i resurs mapp (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 );

Vi kan fylla i data i tabellen genom att skapa en SQL fil i resurs mapp (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 plockar automatiskt upp data.sql fil och kör den mot H2-databasen under programmets start.

H2 konsol

Som standard är konsolvyn för H2-databasen inaktiverad. Innan vi kommer åt H2-databasen måste vi aktivera den genom att använda följande egenskap.

 #enabling the H2 console spring.h2.console.enabled=true

När vi väl har aktiverat H2-konsolen kan vi nu komma åt H2-konsolen i webbläsaren genom att anropa URL:en http://localhost:8080/h2-console. Följande bild visar konsolvyn av H2-databasen.

Spring Boot H2 Database

I skärmdumpen ovan har vi definierat vår egen databas med namnet javatpoint .

Spring Boot H2 Exempel

Låt oss ställa in en Spring Boot-applikation med H2-databasen.

Steg 1: Öppna Spring Initializr http://start.spring.io .

Steg 2: Välj Spring Boot-versionen 2.3.0.M1.

Steg 2: Tillhandahålla Grupp namn. Vi har tillhandahållit com.javatpoint.

Steg 3: Tillhandahålla Artefakt Id. Vi har tillhandahållit spring-boot-h2-databas-exempel.

Steg 5: Lägg till beroenden Spring Web, Spring Data JPA , och H2 Databas.

Steg 6: Klicka på Generera knapp. När vi klickar på knappen Generera omsluter det projektet i en Burk filen och laddar ner den till det lokala systemet.

Spring Boot H2 Database

Steg 7: Extrahera Jar-filen och klistra in den i STS-arbetsytan.

Steg 8: Importera projektmappen till STS.

Arkiv -> Importera -> Befintliga Maven-projekt -> Bläddra -> Välj mappen spring-boot-h2-database-example -> Slutför

Det tar lite tid att importera.

Steg 9: Skapa ett paket med namnet com.javatpoint.model i mappen src/main/java.

Steg 10: Skapa en modellklass i paketet com.javatpoint.model. Vi har skapat modellklass med namnet Studerande. I bokklassen har vi gjort följande:

  • Definiera fyra variabler id, ålder, namn, och
  • Generera Getters och Setters.
    Högerklicka på filen -> Källa -> Generera Getters och Setters.
  • Markera klassen som Entitet genom att använda anteckningen @Entitet.
  • Markera klassen som Tabell namn med hjälp av anteckningen @Tabell.
  • Definiera varje variabel som Kolumn genom att använda anteckningen @Kolumn.

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

Steg 11: Skapa ett paket med namnet com.javatpoint.controller i mappen src/main/java.

Steg 12: Skapa en Controller-klass i paketet com.javatpoint.controller . Vi har skapat controllerklass med namnet StudentController . I StudentController-klassen har vi gjort följande:

  • Markera klassen som RestController genom att använda anteckningen @RestController.
  • Autowire den Studentservice klass genom att använda anteckningen @Autowired .
  • Definiera följande metoder:
      getAllStudent():Det returnerar en lista över alla studenter.
    • getStudent():Den returnerar en elevdetalj som vi har specificerat i sökvägsvariabeln. Vi har skickat id som ett argument genom att använda anteckningen @PathVariable. Anteckningen indikerar att en metodparameter ska vara bunden till en URI-mallvariabel.radera Student():Den tar bort en specifik elev som vi har specificerat i sökvägsvariabeln.saveStudent():Det sparar elevdetaljen. Anteckningen @RequestBody indikerar att en metodparameter ska vara bunden till webbbegäran.

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

Steg 13: Skapa ett paket med namnet com.javatpoint.service i mappen src/main/java.

Steg 14: Skapa en Service klass. Vi har skapat en serviceklass med namnet Studentservice i paketet 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); } }

Steg 15: Skapa ett paket med namnet com.javatpoint.repository i mappen src/main/java.

Steg 16: Skapa en Förvar gränssnitt. Vi har skapat ett förvarsgränssnitt med namnet StudentRepository i paketet com.javatpoint.repository. Det förlänger Crud Repository gränssnitt.

StudentRepository.java 

 package com.javatpoint.repository; import org.springframework.data.repository.CrudRepository; import com.javatpoint.model.Student; public interface StudentRepository extends CrudRepository { }

Nu kommer vi att konfigurera datakällan URL, förarklassnamn, användarnamn, och Lösenord, i applikationsegenskaper fil.

Steg 17: Öppna applikationsegenskaper fil och konfigurera följande egenskaper.

applikationsegenskaper 

 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

Obs: Glöm inte att aktivera H2-konsolen.

Efter att ha skapat alla klasser och paket ser projektkatalogen ut som följande.

Spring Boot H2 Database

Nu kör vi applikationen.

Steg 18: Öppen SpringBootH2DatabaseExampleApplication.java fil och kör den som Java Application.

SpringBootH2DatabaseExampleApplication.java 

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

I nästa steg kommer vi att använda rest client Brevbärare för att skicka POSTA och SKAFFA SIG begäran . Om Postman inte är installerad i ditt system, följ stegen nedan:

Steg 19: Öppna Brevbärare och gör följande:

  • Välj POSTA
  • Anropa URL:en http://localhost:8080/student.
  • Välj Kropp
  • Välj innehållstyp JSON (applikation/json).
  • Infoga data. Vi har infogat följande data i kroppen:
 { 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' }
  • Klicka på Skicka

När begäran har utförts, visar den Status: 200 OK . Det betyder att posten har infogats i databasen.

heapify sortera

På samma sätt har vi infogat följande data.

 { '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]' }

Låt oss komma åt H2-konsolen för att se data.

Steg 20: Öppna webbläsaren och anropa URL:en http://localhost:8080/h2-console. Klicka på Ansluta knappen, som visas nedan.

Spring Boot H2 Database

Efter att ha klickat på Ansluta knappen ser vi Studerande tabell i databasen, som visas nedan.

Spring Boot H2 Database

Steg 21: Klicka på Studerande tabell och klicka sedan på Springa knapp. Tabellen visar data som vi har infogat i kroppen.

Spring Boot H2 Database

Steg 22: Öppna brevbäraren och skicka en SKAFFA SIG begäran. Den returnerar data som vi har infogat i databasen.

Spring Boot H2 Database

Låt oss skicka en SKAFFA SIG begäran med webbadressen http://localhost:8080/student/{id}. Vi har åberopat webbadressen http://localhost:8080/student/3. Det returnerar informationen om eleven vars id är 3.

Spring Boot H2 Database

På samma sätt kan vi också skicka en RADERA begäran. Anta att vi vill radera en studentpost vars id är 2.

För att radera en studentpost, skicka en RADERA begäran med webbadressen http://localhost:8080/student/2. Vi ser att eleven vars id är 2 har raderats från databasen.

Spring Boot H2 Database
Ladda ner H2 Database Exempelprojekt