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.

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.

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.

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:

• Scarica il postino da https://www.getpostman.com/downloads/ oppure aggiungi l'estensione Google Chrome nel browser https://bit.ly/1HCOCwF .
• Avvia il postino e Iscrizione . Crea un nome utente. Abbiamo creato l'utente con il nome javatpoint e cliccato su Invia

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.

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

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

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

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.

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.