¿Qué es la base de datos en memoria?

La base de datos en memoria depende de la memoria del sistema, a diferencia del espacio en disco, para el almacenamiento de datos. Porque el acceso a la memoria es más rápido que el acceso al disco. Usamos la base de datos en memoria cuando no necesitamos conservar los datos. La base de datos en memoria es una base de datos integrada. Las bases de datos en memoria son volátiles, por defecto, y todos los datos almacenados se pierden cuando reiniciamos la aplicación.

Las bases de datos en memoria más utilizadas son H2, HSQLDB (Base de datos HyperSQL) , y Derbi apache. Crea la configuración automáticamente.

Persistencia versus base de datos en memoria

La base de datos persistente conserva los datos en la memoria física. Los datos estarán disponibles incluso si el servidor de la base de datos rebota. Algunas bases de datos de persistencia populares son oráculo, mysql , Postgres , etc.

En el caso del base de datos en memoria, almacén de datos en el memoria del sistema . Perdió los datos cuando se cerró el programa. Es útil para POCO s (Prueba de conceptos), no para una aplicación de producción. La base de datos en memoria ampliamente utilizada es H2.

¿Qué es la base de datos H2?

H2 es un integrado, de código abierto, y en memoria base de datos. Es un sistema de gestión de bases de datos relacionales escrito en Java . Es un Servidor de cliente solicitud. Generalmente se utiliza en examen de la unidad . Almacena datos en la memoria, no persiste los datos en el disco.

Ventajas

• Configuración cero
• Es fácil de usar.
• Es ligero y rápido.
• Proporciona una configuración sencilla para cambiar entre una base de datos real y una base de datos en memoria.
• Admite SQL estándar y API JDBC.
• Proporciona una consola web para mantener la base de datos.

Configurar la base de datos H2

Si queremos utilizar la base de datos H2 en una aplicación, debemos agregar la siguiente dependencia en el archivo pom.xml:

 com.h2database h2 runtime 

Después de agregar la dependencia, necesitamos configurar URL de origen de datos, nombre de clase de conductor, nombre de usuario, y contraseña de la base de datos H2. Spring Boot proporciona una manera fácil de configurar estas propiedades en application.properties archivo.

 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 

En el primavera.fuente de datos.url propiedad, meme es el nombre de una base de datos en memoria y pruebadb es el nombre del esquema que proporciona H2, de forma predeterminada. También podemos definir nuestro propio esquema y base de datos. El nombre de usuario predeterminado es en y la contraseña en blanco denota una vacío contraseña. Si queremos cambiar el nombre de usuario y la contraseña, podemos anular estos valores.

Conservar los datos en la base de datos H2

Si queremos conservar los datos en la base de datos H2, debemos almacenarlos en un archivo. Para lograr lo mismo, necesitamos cambiar la propiedad URL de la fuente de datos.

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

En la propiedad anterior, el Data de muestra es un nombre de archivo.

Crear esquema y completar datos

Podemos definir el esquema creando un SQL archivo en el recurso carpeta (fuente/principal/recurso).

esquema.sql

d chanclas

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

Podemos completar datos en la tabla creando un SQL archivo en el recurso carpeta (fuente/principal/recurso).

datos.sql

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

Spring Boot recoge automáticamente el datos.sql y ejecútelo en la base de datos H2 durante el inicio de la aplicación.

Consola H2

De forma predeterminada, la vista de consola de la base de datos H2 está deshabilitada. Antes de acceder a la base de datos H2, debemos habilitarla usando la siguiente propiedad.

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

Una vez que hemos habilitado la consola H2, ahora podemos acceder a la consola H2 en el navegador invocando la URL http://localhost:8080/h2-console. La siguiente figura muestra la vista de consola de la base de datos H2.

En la captura de pantalla anterior, hemos definido nuestra propia base de datos llamada punto javat .

Ejemplo de arranque de primavera H2

Configuremos una aplicación Spring Boot con la base de datos H2.

Paso 1: Abra Spring Initializr http://start.spring.io.

Paso 2: Seleccione la versión Spring Boot 2.3.0.M1.

Paso 2: Proporcionar la Grupo nombre. Hemos proporcionado com.javatpoint.

convertir booleano a cadena

Paso 3: Proporcionar la Artefacto Identificación. Hemos proporcionado ejemplo-base-de-datos-spring-boot-h2.

Paso 5: Agregar las dependencias Spring Web, datos de primavera JPA, y Base de datos H2.

Paso 6: Clickea en el Generar botón. Cuando hacemos clic en el botón Generar, envuelve el proyecto en un Frasco archivo y lo descarga al sistema local.

Paso 7: Extracto el archivo Jar y péguelo en el espacio de trabajo STS.

Paso 8: Importar la carpeta del proyecto en STS.

Archivo -> Importar -> Proyectos Maven existentes -> Examinar -> Seleccione la carpeta spring-boot-h2-database-example -> Finalizar

La importación lleva algún tiempo.

Paso 9: Crea un paquete con el nombre com.javatpoint.model en la carpeta src/principal/java.

Paso 10: Crear una clase de modelo en el paquete. com.javatpoint.model. Hemos creado una clase de modelo con el nombre. Alumno. En la clase de Libros, hemos hecho lo siguiente:

• Definir cuatro variables identificación, edad, nombre, y
• Generar captadores y definidores.
  Haga clic derecho en el archivo -> Fuente -> Generar captadores y definidores.
• Marcar la clase como Entidad usando la anotación @Entidad.
• Marcar la clase como Mesa nombre usando la anotación @Mesa.
• Defina cada variable como Columna usando la anotación @Columna.

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

Paso 11: Crea un paquete con el nombre com.javatpoint.controller en la carpeta src/principal/java.

Paso 12: Crea una clase de controlador en el paquete. com.javatpoint.controller . Hemos creado una clase de controlador con el nombre. EstudianteControlador . En la clase StudentController, hemos hecho lo siguiente:

• Marcar la clase como Controlador de descanso usando la anotación @RestController.
• Autocablear el Servicio Estudiantil clase usando la anotación @autocableado .
• Defina los siguientes métodos:
  getAllStudent():Devuelve una lista de todos los estudiantes.
obtenerEstudiante():Devuelve un detalle del estudiante que hemos especificado en la variable de ruta. Hemos pasado id como argumento usando la anotación @PathVariable. La anotación indica que un parámetro de método debe estar vinculado a una variable de plantilla de URI.eliminarEstudiante():Elimina un estudiante específico que hemos especificado en la variable de ruta.guardarEstudiante():Guarda los detalles del estudiante. La anotación @RequestBody indica que un parámetro de método debe vincularse al cuerpo de la solicitud web.

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

Paso 13: Crea un paquete con el nombre com.javatpoint.servicio en la carpeta src/principal/java.

Paso 14: Crear un Servicio clase. Hemos creado una clase de servicio con el nombre Servicio Estudiantil en el paquete 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); } } 

Paso 15: Crea un paquete con el nombre com.javatpoint.repositorio en la carpeta src/principal/java.

Paso 16: Crear un Repositorio interfaz. Hemos creado una interfaz de repositorio con el nombre Repositorio de estudiantes en el paquete com.javatpoint.repositorio. Se extiende el Repositorio de basura interfaz.

StudentRepository.java

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

Ahora configuraremos la fuente de datos. URL, nombre de la clase de conductor, nombre de usuario, y contraseña, en el application.properties archivo.

matriz de estructura en lenguaje c

Paso 17: Abre el application.properties archivo y configure las siguientes propiedades.

application.properties

 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: No olvide habilitar la consola H2.

Después de crear todas las clases y paquetes, el directorio del proyecto tiene el siguiente aspecto.

Ahora ejecutaremos la aplicación.

Paso 18: Abierto SpringBootH2DatabaseExampleApplication.java archivo y ejecútelo como aplicación 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); } } 

En el siguiente paso, usaremos el cliente de descanso. Cartero por enviar el CORREO y CONSEGUIR pedido . Si Postman no está instalado en su sistema, siga los pasos a continuación:

• Descarga el cartero de https://www.getpostman.com/downloads/ o agregue la extensión de Google Chrome en el navegador https://bit.ly/1HCOCwF .
• Inicie el cartero y Inscribirse . Crear un nombre de usuario. Hemos creado un usuario con el nombre. punto javat y se hizo clic en Entregar

Paso 19: Abre el Cartero y haz lo siguiente:

• Selecciona el CORREO
• Invoque la URL http://localhost:8080/student.
• Selecciona el Cuerpo
• Seleccione el tipo de contenido JSON (aplicación/json).
• Inserte los datos. Hemos insertado los siguientes datos en el cuerpo:

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

• Clickea en el Enviar

Cuando la solicitud se ejecuta con éxito, muestra el Estado: 200 OK . Significa que el registro se ha insertado exitosamente en la base de datos.

Del mismo modo, hemos insertado los siguientes datos.

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

Accedamos a la consola H2 para ver los datos.

Paso 20: Abra el navegador e invoque la URL http://localhost:8080/h2-console. Clickea en el Conectar botón, como se muestra a continuación.

Después de hacer clic en el Conectar botón, vemos el Alumno tabla en la base de datos, como se muestra a continuación.

Paso 21: Clickea en el Alumno tabla y luego haga clic en el Correr botón. La tabla muestra los datos que hemos insertado en el cuerpo.

Paso 22: Abre el cartero y envía un CONSEGUIR pedido. Devuelve los datos que hemos insertado en la base de datos.

enviemos un CONSEGUIR solicitud con la URL http://localhost:8080/student/{id}. Hemos invocado la URL http://localhost:8080/student/3. Devuelve el detalle del estudiante cuyo id es 3.

Del mismo modo, también podemos enviar un BORRAR pedido. Supongamos que queremos eliminar un registro de estudiante cuya identificación es 2.

Para eliminar un registro de estudiante, envíe un BORRAR solicitud con la URL http://localhost:8080/student/2. Vemos que el estudiante cuyo id es 2 ha sido eliminado de la base de datos.