Wat is de in-memory database

In-memory database is afhankelijk van systeemgeheugen in tegenstelling tot schijfruimte voor de opslag van gegevens. Omdat geheugentoegang sneller is dan schijftoegang. We gebruiken de in-memory database als we de gegevens niet hoeven te bewaren. De in-memory database is een ingebedde database. De databases in het geheugen zijn standaard vluchtig en alle opgeslagen gegevens gaan verloren wanneer we de applicatie opnieuw opstarten.

De veelgebruikte in-memory databases zijn dat wel H2, HSQLDB (HyperSQL-database) , En Apache-derby. Het creëert de configuratie automatisch.

Persistentie versus database in het geheugen

De persistente database bewaart de gegevens in het fysieke geheugen. De gegevens zullen beschikbaar zijn, zelfs als de databaseserver wordt teruggestuurd. Sommige populaire persistentiedatabases zijn dat wel Orakel, MySQL , Postgres , enz.

In het geval van de database in het geheugen, gegevensopslag in de systeemgeheugen . Het verloor de gegevens toen het programma werd gesloten. Het is nuttig voor KLEIN s (Proof of Concepts), niet voor een productietoepassing. De veelgebruikte in-memory database is H2.

Wat is de H2-database

H2 is een ingebedde, open source, En in het geheugen database. Het is een relationeel databasebeheersysteem waarin is geschreven Java . Het is een client server sollicitatie. Het wordt over het algemeen gebruikt in testen van een eenheid . Het slaat gegevens op in het geheugen en bewaart de gegevens niet op schijf.

Voordelen

• Nul configuratie
• Het is gemakkelijk te gebruiken.
• Het is lichtgewicht en snel.
• Het biedt een eenvoudige configuratie om te schakelen tussen een echte database en een in-memory database.
• Het ondersteunt standaard SQL- en JDBC-API.
• Het biedt een webconsole die in de database kan worden onderhouden.

Configureer H2-database

Als we de H2-database in een applicatie willen gebruiken, moeten we de volgende afhankelijkheid toevoegen aan het pom.xml-bestand:

 com.h2database h2 runtime 

Nadat we de afhankelijkheid hebben toegevoegd, moeten we configureren URL van gegevensbron, naam van stuurprogrammaklasse, gebruikersnaam, En wachtwoord van de H2-database. Spring Boot biedt een eenvoudige manier om deze eigenschappen in te configureren applicatie.eigenschappen bestand.

 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 

In de lente.datasource.url eigendom, mem is de naam van een in-memory database en testdb is de naam van het schema dat H2 standaard levert. We kunnen ook ons ​​eigen schema en database definiëren. De standaard gebruikersnaam is op en het lege wachtwoord staat voor een leeg wachtwoord. Als we de gebruikersnaam en het wachtwoord willen wijzigen, kunnen we deze waarden overschrijven.

Bewaar de gegevens in H2 Database

Als we de gegevens in de H2-database willen bewaren, moeten we de gegevens in een bestand opslaan. Om hetzelfde te bereiken, moeten we de gegevensbron-URL-eigenschap wijzigen.

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

In het bovenstaande pand is de voorbeeldgegevens is een bestandsnaam.

Maak een schema en vul gegevens in

We kunnen een schema definiëren door een SQL bestand in de bron map (src/main/resource).

Java-programma's

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 kunnen gegevens in de tabel invullen door een SQL bestand in de bron map (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 pikt automatisch de data.sql bestand en voer het uit op de H2-database tijdens het opstarten van de applicatie.

H2-console

Standaard is de consoleweergave van de H2-database uitgeschakeld. Voordat we toegang krijgen tot de H2-database, moeten we deze inschakelen met behulp van de volgende eigenschap.

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

Nadat we de H2-console hebben ingeschakeld, hebben we nu toegang tot de H2-console in de browser door de URL http://localhost:8080/h2-console aan te roepen. De volgende afbeelding toont de consoleweergave van de H2-database.

In de bovenstaande schermafbeelding hebben we onze eigen database gedefinieerd, genaamd Javapunt .

Veerlaars H2 voorbeeld

Laten we een Spring Boot-applicatie opzetten met de H2-database.

Stap 1: Open Spring Initializr http://start.spring.io.

Stap 2: Selecteer de Spring Boot-versie 2.3.0.M1.

Stap 2: Lever de Groep naam. Wij hebben voorzien com.javatpoint.

Stap 3: Lever de Artefact ID kaart. Wij hebben voorzien spring-boot-h2-database-voorbeeld.

Stap 5: Voeg de afhankelijkheden toe Spring Web, Spring Data JPA, En H2-database.

Stap 6: Klik op de Genereer knop. Wanneer we op de knop Genereren klikken, wordt het project in een Kan bestand en downloadt het naar het lokale systeem.

Stap 7: Extract het Jar-bestand en plak het in de STS-werkruimte.

Stap 8: Importeren de projectmap in STS.

Bestand -> Importeren -> Bestaande Maven-projecten -> Bladeren -> Selecteer de map spring-boot-h2-database-example -> Voltooien

Het importeren duurt enige tijd.

Stap 9: Maak een pakket met de naam com.javatpoint.model in de map src/main/java.

Stap 10: Maak een modelklasse in het pakket com.javatpoint.model. We hebben een modelklasse gemaakt met de naam Student. In de klas Boeken hebben we het volgende gedaan:

'kruskal's algoritme'

• Definieer vier variabelen ID, leeftijd, naam, En
• Genereer getters en setters.
  Klik met de rechtermuisknop op het bestand -> Bron -> Getters en Setters genereren.
• Markeer de klasse als Entiteit door gebruik te maken van de annotatie @Entiteit.
• Markeer de klasse als Tafel naam met behulp van de annotatie @Tafel.
• Definieer elke variabele als Kolom door gebruik te maken van de annotatie @Kolom.

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

Stap 11: Maak een pakket met de naam com.javatpoint.controller in de map src/main/java.

Stap 12: Maak een Controller-klasse in het pakket com.javatpoint.controller . We hebben een controllerklasse gemaakt met de naam StudentController . In de klasse StudentController hebben we het volgende gedaan:

• Markeer de klasse als RestController door gebruik te maken van de annotatie @RestController.
• Autowire de StudentenService klasse met behulp van de annotatie @Autobedraad .
• Definieer de volgende methoden:
  getAllStudent():Er wordt een lijst met alle studenten geretourneerd.
getStudent():Het retourneert een studentdetail dat we hebben opgegeven in de padvariabele. We hebben id als argument doorgegeven door de annotatie @PathVariable te gebruiken. De annotatie geeft aan dat een methodeparameter moet worden gebonden aan een URI-sjabloonvariabele.verwijderStudent():Het verwijdert een specifieke leerling die we hebben opgegeven in de padvariabele.saveStudent():Het slaat de studentgegevens op. De annotatie @RequestBody geeft aan dat een methodeparameter aan de hoofdtekst van het webverzoek moet worden gebonden.

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

Stap 13: Maak een pakket met de naam com.javatpoint.service in de map src/main/java.

Stap 14: Maak een Dienst klas. We hebben een serviceklasse gemaakt met de naam StudentenService in het pakket com.javatpoint.service.

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

Stap 15: Maak een pakket met de naam com.javatpoint.repository in de map src/main/java.

Stap 16: Maak een Opslagplaats koppel. We hebben een repository-interface gemaakt met de naam StudentenRepository in het pakket com.javatpoint.repository. Het verlengt de Ruwe opslagplaats koppel.

StudentRepository.java

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

Nu gaan we de gegevensbron configureren URL, naam van de stuurprogrammaklasse, gebruikersnaam, En wachtwoord, in de applicatie.eigenschappen bestand.

Stap 17: Open de applicatie.eigenschappen bestand en configureer de volgende eigenschappen.

applicatie.eigenschappen

 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 

Opmerking: Vergeet niet de H2-console in te schakelen.

Nadat alle klassen en pakketten zijn gemaakt, ziet de projectmap er als volgt uit.

Nu zullen we de applicatie uitvoeren.

Stap 18: Open SpringBootH2DatabaseExampleApplication.java bestand en voer het uit als Java-toepassing.

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

In de volgende stap zullen we de restclient gebruiken Postbode voor het versturen van de NA En KRIJGEN verzoek . Als de Postman niet op uw systeem is geïnstalleerd, volgt u de onderstaande stappen:

• Download de postbode van https://www.getpostman.com/downloads/ of voeg de Google Chrome-extensie toe in de browser https://bit.ly/1HCOCwF .
• Lanceer de postbode en Aanmelden . Creëer een gebruikersnaam. We hebben een gebruiker met de naam aangemaakt Javapunt en klikte op Indienen

Stap 19: Open de Postbode en doe het volgende:

• Selecteer de NA
• Roep de URL http://localhost:8080/student aan.
• Selecteer de Lichaam
• Selecteer het inhoudstype JSON (applicatie/json).
• Voer de gegevens in. We hebben de volgende gegevens in de body ingevoegd:

 { 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' } 

• Klik op de Versturen

Wanneer het verzoek succesvol is uitgevoerd, wordt het weergegeven Status: 200 OK . Dit betekent dat het record met succes in de database is ingevoegd.

Op dezelfde manier hebben we de volgende gegevens ingevoegd.

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

Laten we naar de H2-console gaan om de gegevens te bekijken.

Stap 20: Open de browser en roep de URL http://localhost:8080/h2-console op. Klik op de Aansluiten knop, zoals hieronder weergegeven.

Na het klikken op de Aansluiten knop, we zien de Student tabel in de database, zoals hieronder weergegeven.

Stap 21: Klik op de Student tabel en klik vervolgens op de Loop knop. De tabel toont de gegevens die we in de hoofdtekst hebben ingevoegd.

Stap 22: Open de postbode en stuur een KRIJGEN verzoek. Het retourneert de gegevens die we in de database hebben ingevoegd.

Laten we een sturen KRIJGEN verzoek met de URL http://localhost:8080/student/{id}. We hebben de URL http://localhost:8080/student/3 aangeroepen. Het retourneert het detail van de student wiens ID 3 is.

Op dezelfde manier kunnen we ook een VERWIJDEREN verzoek. Stel dat we een leerlingrecord met ID 2 willen verwijderen.

Om een ​​leerlingrecord te verwijderen, stuurt u een VERWIJDEREN verzoek met de URL http://localhost:8080/student/2. We zien dat de leerling wiens id is 2 is uit de database verwijderd.