logo

TechCodeview

Databáze Spring Boot H2

Co je to databáze v paměti

In-memory databáze spoléhá na systémovou paměť na rozdíl od diskového prostoru pro ukládání dat. Protože přístup k paměti je rychlejší než přístup k disku. In-memory databázi používáme, když nepotřebujeme uchovávat data. In-memory databáze je vestavěná databáze. Databáze v paměti jsou ve výchozím nastavení nestálé a všechna uložená data se při restartu aplikace ztratí.

Široce používané in-memory databáze jsou H2, HSQLDB (HyperSQL databáze) , a Apache Derby. Automaticky vytvoří konfiguraci.

Persistence vs. In-memory databáze

Trvalá databáze uchovává data ve fyzické paměti. Data budou k dispozici, i když je databázový server vrácen. Některé populární perzistentní databáze jsou Oracle, MySQL , Postgres , atd.

V případě databáze v paměti, úložiště dat v systémové paměti . Při ukončení programu došlo ke ztrátě dat. Je to užitečné pro MÁLO s (Proof of Concepts), nikoli pro produkční aplikaci. Široce používaná in-memory databáze je H2.

Co je databáze H2

H2 je vestavěný, open-source, a v paměti databáze. Jedná se o napsaný systém pro správu relačních databází Jáva . Je to a klient-server aplikace. Obecně se používá v testování jednotky . Ukládá data do paměti, neuchovává data na disku.

Výhody

  • Nulová konfigurace
  • Snadno se používá.
  • Je lehký a rychlý.
  • Poskytuje jednoduchou konfiguraci pro přepínání mezi skutečnou databází a databází v paměti.
  • Podporuje standardní SQL a JDBC API.
  • Poskytuje webovou konzoli pro správu v databázi.

Konfigurace databáze H2

Pokud chceme použít databázi H2 v aplikaci, musíme přidat následující závislost v souboru pom.xml:

 com.h2database h2 runtime

Po přidání závislosti musíme nakonfigurovat URL zdroje dat, název třídy ovladače, uživatelské jméno, a Heslo databáze H2. Spring Boot poskytuje snadný způsob, jak tyto vlastnosti nakonfigurovat aplikace.vlastnosti soubor.

 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

V spring.datasource.url vlastnictví, pam je název databáze v paměti a testdb je název schématu, které H2 standardně poskytuje. Můžeme také definovat vlastní schéma a databázi. Výchozí uživatelské jméno je na a prázdné heslo označuje an prázdný Heslo. Pokud chceme změnit uživatelské jméno a heslo, můžeme tyto hodnoty přepsat.

Zachovat data v databázi H2

Pokud chceme zachovat data v databázi H2, měli bychom data uložit do souboru. Abychom toho dosáhli, musíme změnit vlastnost URL zdroje dat.

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

Ve výše uvedené vlastnosti, vzorek dat je název souboru.

Vytvořte schéma a naplňte data

Schéma můžeme definovat vytvořením a SQL soubor v zdroj složka (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 );

Data v tabulce můžeme naplnit vytvořením a SQL soubor v zdroj složka (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 automaticky zvedne data.sql soubor a spusťte jej proti databázi H2 během spouštění aplikace.

Konzole H2

Ve výchozím nastavení je zobrazení konzoly databáze H2 zakázáno. Před přístupem k databázi H2 ji musíme povolit pomocí následující vlastnosti.

průchod předobjednávky 
 #enabling the H2 console spring.h2.console.enabled=true

Jakmile jsme povolili konzoli H2, nyní můžeme přistupovat ke konzole H2 v prohlížeči vyvoláním adresy URL http://localhost:8080/h2-console. Následující obrázek ukazuje konzolový pohled na databázi H2.

Databáze Spring Boot H2

Na výše uvedeném snímku obrazovky jsme definovali naši vlastní databázi s názvem javatpoint .

Příklad pružinové botičky H2

Pojďme nastavit aplikaci Spring Boot s databází H2.

Krok 1: Otevřete Spring Initializr http://start.spring.io .

Krok 2: Vyberte verzi Spring Boot 2.3.0.M1.

Krok 2: Poskytněte Skupina název. Poskytli jsme com.javatpoint.

Krok 3: Poskytněte Artefakt Id. Poskytli jsme spring-boot-h2-database-example.

Krok 5: Přidejte závislosti Spring Web, Spring Data JPA, a Databáze H2.

Krok 6: Klikněte na generovat knoflík. Když klikneme na tlačítko Generovat, zabalí projekt do a Sklenice soubor a stáhne jej do místního systému.

Databáze Spring Boot H2

Krok 7: Výpis soubor Jar a vložte jej do pracovního prostoru STS.

Krok 8: Import složku projektu do STS.

Soubor -> Import -> Existující projekty Maven -> Procházet -> Vyberte složku spring-boot-h2-database-example -> Dokončit

Import nějakou dobu trvá.

Krok 9: Vytvořte balíček s názvem com.javatpoint.model ve složce src/main/java.

Krok 10: Vytvořte třídu modelu v balíčku com.javatpoint.model. Vytvořili jsme třídu modelu s názvem Student. Ve třídě Knihy jsme provedli následující:

  • Definujte čtyři proměnné id, věk, jméno, a
  • Generujte getry a setry.
    Klikněte pravým tlačítkem na soubor -> Zdroj -> Generovat gettry a setry.
  • Označte třídu jako Entita pomocí anotace @Entity.
  • Označte třídu jako Stůl název pomocí anotace @Stůl.
  • Definujte každou proměnnou jako Sloupec pomocí anotace @Sloupec.

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

Krok 11: Vytvořte balíček s názvem com.javatpoint.controller ve složce src/main/java.

Krok 12: Vytvořte v balíčku třídu Controller com.javatpoint.controller . Vytvořili jsme třídu řadiče s názvem StudentController . Ve třídě StudentController jsme provedli následující:

  • Označte třídu jako RestController pomocí anotace @RestController.
  • Autowire StudentService třídy pomocí anotace @Autowired .
  • Definujte následující metody:
      getAllStudent():Vrátí seznam všech studentů.
    • getStudent():Vrací detail studenta, který jsme zadali v proměnné path. Předali jsme id jako argument pomocí anotace @PathVariable. Anotace označuje, že parametr metody by měl být svázán s proměnnou šablony URI.deleteStudent():Smaže konkrétního studenta, kterého jsme uvedli v proměnné cesta.saveStudent():Ukládá detail studenta. Anotace @RequestBody označuje, že parametr metody by měl být svázán s tělem webového požadavku.

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

Krok 13: Vytvořte balíček s názvem com.javatpoint.service ve složce src/main/java.

bellfordův algoritmus

Krok 14: Vytvořit Servis třída. Vytvořili jsme třídu služeb s názvem StudentService v balíčku 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); } }

Krok 15: Vytvořte balíček s názvem com.javatpoint.repository ve složce src/main/java.

Krok 16: Vytvořit Úložiště rozhraní. Vytvořili jsme rozhraní úložiště s názvem StudentRepository v balíčku com.javatpoint.repository. Prodlužuje to Crud Repository rozhraní.

StudentRepository.java 

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

Nyní nakonfigurujeme zdroj dat URL, název třídy ovladače, uživatelské jméno, a Heslo, v aplikace.vlastnosti soubor.

Krok 17: Otevři aplikace.vlastnosti soubor a nakonfigurujte následující vlastnosti.

aplikace.vlastnosti 

 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

Poznámka: Nezapomeňte povolit konzoli H2.

Po vytvoření všech tříd a balíčků vypadá adresář projektu následovně.

Databáze Spring Boot H2

Nyní spustíme aplikaci.

Krok 18: OTEVŘENO SpringBootH2DatabaseExampleApplication.java soubor a spusťte jej jako aplikaci Java.

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

V dalším kroku použijeme klienta rest Listonoš za odeslání POŠTA a DOSTAT žádost . Pokud Postman není ve vašem systému nainstalován, postupujte takto:

  • Stáhněte si Pošťák z https://www.getpostman.com/downloads/ nebo si do prohlížeče přidejte rozšíření Google Chrome https://bit.ly/1HCOCwF .
  • Spusťte Postman and Přihlásit se . Vytvořit uživatelské jméno. Vytvořili jsme uživatele se jménem javatpoint a klikl na Předložit

Krok 19: Otevři Listonoš a proveďte následující:

  • Vybrat POŠTA
  • Vyvolejte adresu URL http://localhost:8080/student.
  • Vybrat Tělo
  • Vyberte typ obsahu JSON (aplikace/json).
  • Vložte data. Do těla jsme vložili následující údaje:
 { 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' }
  • Klikněte na Poslat

Když je požadavek úspěšně proveden, zobrazí se Stav: 200 OK . Znamená to, že záznam byl úspěšně vložen do databáze.

Podobně jsme vložili následující údaje.

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

Pojďme do konzole H2, abychom viděli data.

Krok 20: Otevřete prohlížeč a vyvolejte URL http://localhost:8080/h2-console. Klikněte na Připojit tlačítko, jak je znázorněno níže.

Databáze Spring Boot H2

Po kliknutí na Připojit tlačítko, vidíme Student tabulky v databázi, jak je uvedeno níže.

Databáze Spring Boot H2

Krok 21: Klikněte na Student tabulky a poté klikněte na Běh knoflík. V tabulce jsou uvedeny údaje, které jsme vložili do těla.

Databáze Spring Boot H2

Krok 22: Otevřete Pošťák a odešlete DOSTAT žádost. Vrací data, která jsme vložili do databáze.

Databáze Spring Boot H2

Pošleme a DOSTAT požadavek s adresou URL http://localhost:8080/student/{id}. Vyvolali jsme adresu URL http://localhost:8080/student/3. Vrátí detail studenta, jehož ID je 3.

Databáze Spring Boot H2

Podobně můžeme také poslat a VYMAZAT žádost. Předpokládejme, že chceme smazat záznam studenta, jehož ID je 2.

Chcete-li smazat záznam studenta, zašlete a VYMAZAT požadavek s adresou URL http://localhost:8080/student/2. Vidíme, že student, jehož id je 2 byl smazán z databáze.

Databáze Spring Boot H2
Stáhněte si příklad projektu databáze H2