logo

TechCodeview

Database Spring Boot H2

Cos'è il database in memoria

Il database in memoria si basa sulla memoria di sistema anziché sullo spazio su disco per l'archiviazione dei dati. Perché l'accesso alla memoria è più veloce dell'accesso al disco. Utilizziamo il database in memoria quando non è necessario rendere persistenti i dati. Il database in memoria è un database incorporato. I database in memoria sono volatili, per impostazione predefinita, e tutti i dati archiviati vengono persi quando riavviiamo l'applicazione.

I database in memoria ampiamente utilizzati sono H2, HSQLDB (Database HyperSQL) , E Derby dell'Apache. Crea automaticamente la configurazione.

Persistenza e database in memoria

Il database persistente mantiene i dati nella memoria fisica. I dati saranno disponibili anche se il server del database viene rimbalzato. Alcuni popolari database di persistenza lo sono Oracolo, MySQL , Postgres , eccetera.

Nel caso del database in memoria, archivio dati in memoria di sistema . Ha perso i dati quando il programma è stato chiuso. È utile per POCO s (Proof of Concepts), non per un'applicazione di produzione. Il database in memoria ampiamente utilizzato è H2.

Cos'è il database H2

H2 è un integrato, open source, E in memoria Banca dati. È un sistema di gestione di database relazionali scritto in Giava . È un cliente/server applicazione. Viene generalmente utilizzato in test unitari . Memorizza i dati in memoria, non persiste i dati su disco.

Vantaggi

  • Configurazione zero
  • È facile da usare.
  • È leggero e veloce.
  • Fornisce una configurazione semplice per passare da un database reale a un database in memoria.
  • Supporta l'API SQL e JDBC standard.
  • Fornisce una console web da mantenere nel database.

Configura il database H2

Se vogliamo utilizzare il database H2 in un'applicazione dobbiamo aggiungere la seguente dipendenza nel file pom.xml:

 com.h2database h2 runtime

Dopo aver aggiunto la dipendenza, dobbiamo configurare URL dell'origine dati, nome della classe del driver, nome utente, E parola d'ordine della banca dati H2. Spring Boot fornisce un modo semplice per configurare queste proprietà proprietà.applicazione file.

 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

Nel spring.datasource.url proprietà, mem è il nome di un database in memoria e testdb è il nome dello schema fornito da H2, per impostazione predefinita. Possiamo anche definire il nostro schema e il nostro database. Il nome utente predefinito è SU e la password vuota denota un vuoto parola d'ordine. Se vogliamo cambiare nome utente e password, possiamo sovrascrivere questi valori.

Persistenza dei dati nel database H2

Se vogliamo rendere persistenti i dati nel database H2, dovremmo archiviarli in un file. Per ottenere lo stesso risultato, dobbiamo modificare la proprietà dell'URL dell'origine dati.

gestione delle eccezioni in Java 
 #persist the data spring.datasource.url=jdbc:h2:file:/data/sampledata spring.datasource.url=jdbc:h2:C:/data/sampledata

Nella proprietà di cui sopra, il dati campione è un nome di file.

Crea schema e popola i dati

Possiamo definire lo schema creando un file SQL file nel risorsa cartella (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 );

Possiamo popolare i dati nella tabella creando un file SQL file nel risorsa cartella (src/main/resource).

dati.sql 

 INSERT INTO CITY VALUES (11, 'Delhi', 110001); INSERT INTO CITY VALUES (12, 'Kanpur', 208001); INSERT INTO CITY VALUES (13, 'Lucknow', 226001);

Spring Boot raccoglie automaticamente il file dati.sql file ed eseguirlo sul database H2 durante l'avvio dell'applicazione.

Consolle H2

Per impostazione predefinita, la visualizzazione della console del database H2 è disabilitata. Prima di accedere al database H2, dobbiamo abilitarlo utilizzando la seguente proprietà.

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

Una volta abilitata la console H2, ora possiamo accedere alla console H2 nel browser richiamando l'URL http://localhost:8080/h2-console. La figura seguente mostra la vista della console del database H2.

Database Spring Boot H2

Nello screenshot sopra, abbiamo definito il nostro database denominato javatpoint .

Esempio Spring Boot H2

Configuriamo un'applicazione Spring Boot con il database H2.

Passo 1: Apri Spring Inizializr http://start.spring.io .

Passo 2: Seleziona la versione Spring Boot 2.3.0.M1.

Passo 2: Fornire il Gruppo nome. Abbiamo fornito com.javatpoint.

Passaggio 3: Fornire il Artefatto Id. Abbiamo fornito spring-boot-h2-database-esempio.

c++ converte int in stringa

Passaggio 5: Aggiungi le dipendenze Spring Web, Spring Data JPA, E Banca dati H2.

Passaggio 6: Clicca sul creare pulsante. Quando facciamo clic sul pulsante Genera, avvolge il progetto in un file Vaso file e lo scarica nel sistema locale.

Database Spring Boot H2

Passaggio 7: Estratto il file Jar e incollarlo nell'area di lavoro STS.

Passaggio 8: Importare la cartella del progetto in STS.

File -> Importa -> Progetti Maven esistenti -> Sfoglia -> Seleziona la cartella spring-boot-h2-database-example -> Fine

L'importazione richiede del tempo.

Passaggio 9: Crea un pacchetto con il nome com.javatpoint.model nella cartella src/principale/java.

Passaggio 10: Creare una classe modello nel pacchetto com.javatpoint.model. Abbiamo creato una classe modello con il nome Alunno. Nella classe Libri, abbiamo fatto quanto segue:

  • Definire quattro variabili ID, età, nome, E
  • Genera getter e setter.
    Fare clic con il tasto destro sul file -> Sorgente -> Genera getter e setter.
  • Contrassegna la classe come Entità utilizzando l'annotazione @Entità.
  • Contrassegna la classe come Tavolo nome utilizzando l'annotazione @Tavolo.
  • Definire ciascuna variabile come Colonna utilizzando l'annotazione @Colonna.

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

Passaggio 11: Crea un pacchetto con il nome com.javatpoint.controller nella cartella src/principale/java.

Passaggio 12: Crea una classe Controller nel pacchetto com.javatpoint.controller . Abbiamo creato una classe controller con il nome StudentController . Nella classe StudentController, abbiamo fatto quanto segue:

  • Contrassegna la classe come RestController utilizzando l'annotazione @RestController.
  • Cablare automaticamente il ServizioStudenti classe utilizzando l'annotazione @Autowired .
  • Definire i seguenti metodi:
      getAllStudent():Restituisce un elenco di tutti gli studenti.
    • getStudente():Restituisce i dettagli dello studente che abbiamo specificato nella variabile del percorso. Abbiamo passato id come argomento utilizzando l'annotazione @PathVariable. L'annotazione indica che un parametro del metodo deve essere associato a una variabile del modello URI.eliminaStudente():Elimina uno studente specifico che abbiamo specificato nella variabile del percorso.salvaStudente():Salva i dettagli dello studente. L'annotazione @RequestBody indica che un parametro del metodo deve essere associato al corpo della richiesta web.

StudentController.java

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

Passaggio 13: Crea un pacchetto con il nome com.javatpoint.service nella cartella src/principale/java.

download delle m

Passaggio 14: Creare un Servizio classe. Abbiamo creato una classe di servizio con il nome ServizioStudenti nel pacchetto 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); } }

Passaggio 15: Crea un pacchetto con il nome com.javatpoint.repository nella cartella src/principale/java.

Passaggio 16: Creare un Deposito interfaccia. Abbiamo creato un'interfaccia repository con il nome Repository degli studenti nel pacchetto com.javatpoint.repository. Estende il Deposito Crud interfaccia.

StudentRepository.java 

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

Ora configureremo l'origine dati URL, nome della classe del driver, nome utente, E parola d'ordine, nel proprietà.applicazione file.

Passaggio 17: Apri il proprietà.applicazione file e configurare le seguenti proprietà.

proprietà.applicazione 

 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

Nota: non dimenticare di abilitare la console H2.

Dopo aver creato tutte le classi e i pacchetti, la directory del progetto è simile alla seguente.

Database Spring Boot H2

Ora eseguiremo l'applicazione.

Passaggio 18: Aprire SpringBootH2DatabaseExampleApplication.java file ed eseguirlo come applicazione Java.

SpringBootH2DatabaseExampleApplication.java

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

Nel passaggio successivo utilizzeremo il rest client Postino per aver inviato il INVIARE E OTTENERE richiesta . Se Postman non è installato nel tuo sistema, procedi nel seguente modo:

Passaggio 19: Apri il Postino e fai quanto segue:

  • Seleziona il INVIARE
  • Richiamare l'URL http://localhost:8080/student.
  • Seleziona il Corpo
  • Seleziona il tipo di contenuto JSON (applicazione/json).
  • Inserisci i dati. Abbiamo inserito nel body i seguenti dati:
 { 'id': '001', 'age': '23', 'name': 'Amit', 'email': '[email protected]' }
  • Clicca sul Inviare

Quando la richiesta viene eseguita con successo, mostra il file Stato:200 OK . Significa che il record è stato inserito con successo nel database.

Allo stesso modo, abbiamo inserito i seguenti dati.

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

Accediamo alla console H2 per vedere i dati.

Passaggio 20: Aprire il browser e richiamare l'URL http://localhost:8080/h2-console. Clicca sul Collegare pulsante, come mostrato di seguito.

Database Spring Boot H2

Dopo aver cliccato su Collegare pulsante, vediamo il Alunno tabella nel database, come mostrato di seguito.

Database Spring Boot H2

Passaggio 21: Clicca sul Alunno tabella e quindi fare clic su Correre pulsante. La tabella mostra i dati che abbiamo inserito nel body.

Database Spring Boot H2

Passaggio 22: Apri il Postino e invia un OTTENERE richiesta. Restituisce i dati che abbiamo inserito nel database.

Database Spring Boot H2

Inviamo un OTTENERE richiesta con l'URL http://localhost:8080/student/{id}. Abbiamo invocato l'URL http://localhost:8080/student/3. Restituisce i dettagli dello studente il cui ID è 3.

Database Spring Boot H2

Allo stesso modo, possiamo anche inviare un file ELIMINARE richiesta. Supponiamo di voler eliminare il record di uno studente il cui ID è 2.

Per eliminare la scheda di uno studente, inviare un ELIMINARE richiesta con l'URL http://localhost:8080/student/2. Vediamo che lo studente il cui ID è 2 è stato cancellato dal database.

Database Spring Boot H2
Scarica il progetto di esempio del database H2