TechCodeview

Mi az a memórián belüli adatbázis

A memórián belüli adatbázis a rendszermemóriára támaszkodik, szemben az adatok tárolására szolgáló lemezterülettel. Mert a memória-hozzáférés gyorsabb, mint a lemezelérés. A memórián belüli adatbázist akkor használjuk, ha nem kell megőriznünk az adatokat. A memórián belüli adatbázis egy beágyazott adatbázis. A memóriában lévő adatbázisok alapértelmezés szerint változékonyak, és az alkalmazás újraindításakor minden tárolt adat elveszik.

A széles körben használt memórián belüli adatbázisok a H2, HSQLDB (HyperSQL adatbázis) , és Apache Derby. Ez automatikusan létrehozza a konfigurációt.

Perzisztencia vs. In-memory Database

Az állandó adatbázis megőrzi az adatokat a fizikai memóriában. Az adatok akkor is elérhetők lesznek, ha az adatbázis-kiszolgáló visszapattan. Néhány népszerű perzisztencia adatbázis Oracle, MySQL , Postgres , stb.

Abban az esetben, ha a memóriabeli adatbázis, adattár a rendszermemória . A program bezárásakor elvesztette az adatokat. Hasznos a KIS s (Proof of Concepts), nem termelési alkalmazáshoz. A széles körben használt memórián belüli adatbázis az H2.

Mi az a H2 adatbázis

H2 egy beágyazott, nyílt forráskódú, és emlékül adatbázis. Ez egy beírt relációs adatbázis-kezelő rendszer Jáva . Ez egy kliens/szerver Alkalmazás. Általában használják egységtesztelés . Az adatokat a memóriában tárolja, nem tárolja a lemezen.

Előnyök

• Nulla konfiguráció
• Könnyen használható.
• Könnyű és gyors.
• Egyszerű konfigurációt biztosít a valós adatbázis és a memóriában lévő adatbázis közötti váltáshoz.
• Támogatja a szabványos SQL és JDBC API-t.
• Az adatbázisban karbantartható webkonzolt biztosít.

Konfigurálja a H2 adatbázist

Ha H2 adatbázist szeretnénk használni egy alkalmazásban, a következő függőséget kell hozzáadnunk a pom.xml fájlhoz:

 com.h2database h2 runtime 

A függőség hozzáadása után konfigurálnunk kell adatforrás URL, illesztőprogram-osztály neve, felhasználónév, és Jelszó H2 adatbázisból. A Spring Boot egyszerű módot kínál ezeknek a tulajdonságoknak a konfigurálására alkalmazás.tulajdonságok fájlt.

 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 

Ban,-ben spring.datasource.url ingatlan, mem egy memóriában lévő adatbázis neve és testdb a séma neve, amelyet a H2 alapértelmezés szerint biztosít. Meghatározhatjuk saját sémánkat és adatbázisunkat is. Az alapértelmezett felhasználónév tovább és az üres jelszó an üres Jelszó. Ha módosítani szeretnénk a felhasználónevet és a jelszót, felülírhatjuk ezeket az értékeket.

Tartsa meg az adatokat a H2 adatbázisban

Ha meg akarjuk őrizni az adatokat a H2 adatbázisban, akkor az adatokat fájlban kell tárolnunk. Ennek eléréséhez módosítanunk kell az adatforrás URL-tulajdonságát.

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

A fenti ingatlanban a minta adat egy fájlnév.

Séma létrehozása és adatok feltöltése

Sémát úgy határozhatunk meg, hogy létrehozunk egy SQL fájl a forrás mappa (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 ); 

A táblázatba úgy tölthetjük fel az adatokat, hogy létrehozunk egy SQL fájl a forrás mappa (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); 

A Spring Boot automatikusan felveszi a data.sql fájlt, és futtassa a H2 adatbázissal az alkalmazás indításakor.

H2 konzol

Alapértelmezés szerint a H2 adatbázis konzolnézete le van tiltva. A H2 adatbázis elérése előtt engedélyeznünk kell azt a következő tulajdonság használatával.

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

Miután engedélyeztük a H2 konzolt, a böngészőben elérhetjük a H2 konzolt a http://localhost:8080/h2-console URL meghívásával. A következő ábra a H2 adatbázis konzolnézetét mutatja.

A fenti képernyőképen definiáltuk a saját adatbázisunkat javatpoint .

Spring Boot H2 példa

Állítsunk be egy Spring Boot alkalmazást a H2 adatbázissal.

1. lépés: Nyissa meg a Spring Initializr http://start.spring.io webhelyet.

2. lépés: Válassza ki a Spring Boot verziót 2.3.0.M1.

2. lépés: Adja meg a Csoport név. biztosítottuk com.javatpoint.

3. lépés: Adja meg a Műalkotás Id. biztosítottuk spring-boot-h2-database-example.

5. lépés: Adja hozzá a függőségeket Spring Web, Spring Data JPA, és H2 adatbázis.

6. lépés: Kattintson a generál gomb. Amikor a Generálás gombra kattintunk, a projektet a Befőttes üveg fájlt, és letölti a helyi rendszerre.

7. lépés: Kivonat a Jar fájlt, és illessze be az STS munkaterületre.

8. lépés: Importálás a projekt mappát az STS-be.

Fájl -> Importálás -> Meglévő Maven Projektek -> Tallózás -> Válassza ki a spring-boot-h2-database-example mappát -> Befejezés

Az importálás némi időt vesz igénybe.

9. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.model a mappában src/main/java.

10. lépés: Hozzon létre egy modellosztályt a csomagban com.javatpoint.model. A névvel modellosztályt hoztunk létre Diák. A Könyvek órán a következőket tettük:

• Határozzon meg négy változót azonosító, életkor, név, és
• Getterek és szetterek generálása.
  Kattintson a jobb gombbal a fájlra -> Forrás -> Getterek és beállítók generálása.
• Jelölje meg az osztályt mint Entitás az annotáció használatával @Entity.
• Jelölje meg az osztályt mint asztal nevet a megjegyzés használatával @Asztal.
• Minden változót definiáljon: Oszlop az annotáció használatával @Oszlop.

Diák.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; } } 

11. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.controller a mappában src/main/java.

java próbálja elkapni

12. lépés: Hozzon létre egy Controller osztályt a csomagban com.javatpoint.controller . A névvel vezérlő osztályt hoztunk létre StudentController . A StudentController osztályban a következőket tettük:

• Jelölje meg az osztályt mint RestController az annotáció használatával @RestController.
• Automatikus huzalozás a StudentService osztályt a megjegyzés használatával @Autowired .
• Határozza meg a következő módszereket:
  getAllStudent():Visszaadja az összes tanuló listáját.
getStudent():Egy tanulórészletet ad vissza, amelyet az elérési út változóban adtunk meg. Az id argumentumot a @PathVariable megjegyzés használatával adtuk át. A megjegyzés azt jelzi, hogy egy metódusparamétert egy URI-sablonváltozóhoz kell kötni.deleteStudent():Töröl egy adott tanulót, amelyet az elérési út változóban adtunk meg.SaveStudent():Megmenti a tanuló adatait. A @RequestBody megjegyzés azt jelzi, hogy egy metódusparamétert a webes kérelem törzséhez kell kötni.

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

13. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.service a mappában src/main/java.

14. lépés: Hozzon létre egy Szolgáltatás osztály. Létrehoztunk egy szolgáltatási osztályt a névvel StudentService a csomagban 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); } } 

15. lépés: Hozzon létre egy csomagot a névvel com.javatpoint.repository a mappában src/main/java.

16. lépés: Hozzon létre egy Adattár felület. Létrehoztunk egy adattár felületet a névvel StudentRepository a csomagban com.javatpoint.repository. Meghosszabbítja a Crud Repository felület.

StudentRepository.java

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

Most konfiguráljuk az adatforrást URL, illesztőprogram osztály neve, felhasználónév, és Jelszó, ban,-ben alkalmazás.tulajdonságok fájlt.

17. lépés: Nyissa meg a alkalmazás.tulajdonságok fájlt, és állítsa be a következő tulajdonságokat.

alkalmazás.tulajdonságok

 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 

Megjegyzés: Ne felejtse el engedélyezni a H2 konzolt.

Az összes osztály és csomag létrehozása után a projektkönyvtár a következőképpen néz ki.

Most futtatjuk az alkalmazást.

18. lépés: Nyisd ki SpringBootH2DatabaseExampleApplication.java fájlt, és futtassa Java alkalmazásként.

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

A következő lépésben pihenőklienst használunk Postás a küldésért POST és KAP kérés . Ha a Postman nincs telepítve a rendszerében, kövesse az alábbi lépéseket:

• Töltse le a Postást innen https://www.getpostman.com/downloads/ vagy adja hozzá a Google Chrome bővítményt a böngészőhöz https://bit.ly/1HCOCwF .
• Indítsa el a Postást és Regisztrálj . Hozzon létre egy felhasználónevet. Felhasználót hoztunk létre a következő névvel javatpoint és rákattintott Beküldés

19. lépés: Nyissa meg a Postás és tegye a következőket:

• Válaszd ki a POST
• Hívja meg a http://localhost:8080/student URL-t.
• Válaszd ki a Test
• Válassza ki a Tartalomtípust JSON (alkalmazás/json).
• Illessze be az adatokat. A következő adatokat illesztettük be a törzsbe:

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

• Kattintson a Küld

Amikor a kérés sikeresen végrehajtva, megjelenik a Állapot: 200 OK . Ez azt jelenti, hogy a rekord sikeresen bekerült az adatbázisba.

Hasonlóképpen a következő adatokat illesztettük be.

 { '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épjünk be a H2 konzolba az adatok megtekintéséhez.

20. lépés: Nyissa meg a böngészőt, és hívja meg a http://localhost:8080/h2-console URL-t. Kattintson a Csatlakozás gombot, az alábbiak szerint.

Miután rákattintott a Csatlakozás gombot, látjuk a Diák táblázatot az adatbázisban, az alábbiak szerint.

21. lépés: Kattintson a Diák táblázatot, majd kattintson a Fuss gomb. A táblázat azokat az adatokat mutatja, amelyeket beszúrtunk a törzsbe.

22. lépés: Nyissa meg a Postást, és küldje el a KAP kérés. Azokat az adatokat adja vissza, amelyeket beszúrtunk az adatbázisba.

Küldjünk a KAP kérés a http://localhost:8080/student/{id} URL-lel. Meghívtuk a http://localhost:8080/student/3 URL-t. A 3-as azonosítójú tanuló adatait adja vissza.

Hasonlóképpen küldhetünk a TÖRÖL kérés. Tegyük fel, hogy törölni akarunk egy tanulói rekordot, amelynek azonosítója 2.

Tanulói rekord törléséhez küldje el a TÖRÖL kérés a http://localhost:8080/student/2 URL-lel. Látjuk, hogy az a diák, akinek az azonosítója 2 törölve lett az adatbázisból.