H2 es una base de datos incrustada, de código abierto y en memoria. Es un sistema de gestión de bases de datos relacionales escrito en Java. Es una aplicación cliente/servidor. Almacena datos en la memoria, no conserva los datos en el disco. Aquí discutiremos cómo podemos configurar y realizar algunas operaciones básicas en Spring Boot utilizando la base de datos H2.
Algunas de las características principales de la base de datos H2 son:
- API JDBC muy rápida y de código abierto
- Modos integrado y de servidor; bases de datos basadas en disco o en memoria
- Soporte de transacciones, concurrencia de múltiples versiones
- Aplicación de consola basada en navegador
- Bases de datos cifradas
- Búsqueda de texto completo
- Java puro con un tamaño reducido: alrededor de 2,5 MB de tamaño de archivo jar
- controlador ODBC
Configurar la base de datos H2 en la aplicación Spring Boot
Paso 1: Agregar la dependencia
Para usar la base de datos H2 en la aplicación Spring Boot, debemos agregar la siguiente dependencia en el archivo pom.xml :
dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<scope>runtime</scope>
</dependency>
Paso 2: escriba algunas propiedades en el archivo application.properties
# H2 Database spring.h2.console.enabled=true spring.datasource.url=jdbc:h2:mem:dcbapp spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=password spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
Comprendamos cuáles son estas propiedades abriendo la consola de la base de datos H2.
Consola H2: De manera 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.
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:8082/h2-console .
Nota : Proporcione su número de puerto en el que se ejecuta su aplicación Spring
La siguiente figura muestra la vista de consola de la base de datos H2.
Ejemplo:
Vamos a realizar algunas operaciones CRUD básicas mediante la creación de una aplicación Spring Boot y el uso de la base de datos H2.
Paso 1: Consulte este artículo Cómo crear un proyecto Spring Boot con IntelliJ IDEA y cree un proyecto Spring Boot.
Paso 2: agregue la siguiente dependencia
- Telaraña de primavera
- Base de datos H2
- Lombok
- JPA de datos de primavera
A continuación se muestra el código completo para el archivo pom.xml . Por favor, compruebe si se ha perdido algo.
XML
<?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.5.5</version> <relativePath/> <!-- lookup parent from repository --> </parent> <groupId>com.amiya</groupId> <artifactId>Spring-Boot-Demo-Project</artifactId> <version>1.0.0-SNAPSHOT</version> <name>Spring-Boot-Demo-Project</name> <description>Demo project for Spring Boot</description> <properties> <java.version>11</java.version> </properties> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <scope>runtime</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>runtime</scope> <optional>true</optional> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-jpa</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <optional>true</optional> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> <configuration> <excludes> <exclude> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> </exclude> </excludes> </configuration> </plugin> </plugins> </build> </project>
Paso 3 : cree 4 paquetes y luego cree algunas clases e interfaces dentro de estos paquetes como se ve en la imagen a continuación
- entidad
- repositorio
- Servicio
- controlador
Nota :
- Icono verde redondeado ‘I’ Los botones son interfaz
- Los botones ‘C’ de icono redondeado azul son clases
Paso 4: dentro del paquete de entidad
Cree una clase POJO simple dentro del archivo Department.java.
Ejemplo:
Java
// Java Program to Demonstrate Department File
// Importing required package modules
package com.amiya.springbootdemoproject.entity;
// Importing required classes
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
// Class
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
private Long departmentId;
private String departmentName;
private String departmentAddress;
private String departmentCode;
}
Paso 5: dentro del paquete del repositorio
Cree una interfaz simple y nombre la interfaz como DepartmentRepository. Esta interfaz ampliará CrudRepository como hemos comentado anteriormente.
Ejemplo A continuación se muestra el código para el archivo DepartmentRepository.java
Java
package com.amiya.springbootdemoproject.repository;
import com.amiya.springbootdemoproject.entity.Department;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
// Annotation
@Repository
// Interface extending CrudRepository
public interface DepartmentRepository
extends CrudRepository<Department, Long> {
}
Paso 6: Dentro del paquete de servicios
Dentro del paquete, cree una interfaz denominada DepartmentService y una clase denominada DepartmentServiceImpl .
Ejemplo 1-A
Java
// Java Program to Demonstrate DepartmentService File
// Importing required package modules
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
// Importing required classes
import java.util.List;
// Interface
public interface DepartmentService {
// Save operation
Department saveDepartment(Department department);
// Read operation
List<Department> fetchDepartmentList();
// Update operation
Department updateDepartment(Department department,
Long departmentId);
// Delete operation
void deleteDepartmentById(Long departmentId);
}
Ejemplo 1-B
Java
// Java Program to Demonstrate DepartmentServiceImpl.java
// File
// Importing required package modules
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.repository.DepartmentRepository;
import java.util.List;
import java.util.Objects;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
// Annotation
@Service
// Class
public class DepartmentServiceImpl
implements DepartmentService {
@Autowired
private DepartmentRepository departmentRepository;
// Save operation
@Override
public Department saveDepartment(Department department)
{
return departmentRepository.save(department);
}
// Read operation
@Override public List<Department> fetchDepartmentList()
{
return (List<Department>)
departmentRepository.findAll();
}
// Update operation
@Override
public Department
updateDepartment(Department department,
Long departmentId)
{
Department depDB
= departmentRepository.findById(departmentId)
.get();
if (Objects.nonNull(department.getDepartmentName())
&& !"".equalsIgnoreCase(
department.getDepartmentName())) {
depDB.setDepartmentName(
department.getDepartmentName());
}
if (Objects.nonNull(
department.getDepartmentAddress())
&& !"".equalsIgnoreCase(
department.getDepartmentAddress())) {
depDB.setDepartmentAddress(
department.getDepartmentAddress());
}
if (Objects.nonNull(department.getDepartmentCode())
&& !"".equalsIgnoreCase(
department.getDepartmentCode())) {
depDB.setDepartmentCode(
department.getDepartmentCode());
}
return departmentRepository.save(depDB);
}
// Delete operation
@Override
public void deleteDepartmentById(Long departmentId)
{
departmentRepository.deleteById(departmentId);
}
}
Paso 7: Dentro del paquete del controlador
Dentro del paquete, cree una clase llamada DepartmentController .
Ejemplo
Java
// java Program to Illustrate DepartmentController File
// Importing required packages modules
package com.amiya.springbootdemoproject.controller;
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.service.DepartmentService;
import java.util.List;
// Importing required classes
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
// Annotation
@RestController
// Class
public class DepartmentController {
@Autowired private DepartmentService departmentService;
// Save operation
@PostMapping("/departments")
public Department saveDepartment(
@Valid @RequestBody Department department)
{
return departmentService.saveDepartment(department);
}
// Read operation
@GetMapping("/departments")
public List<Department> fetchDepartmentList()
{
return departmentService.fetchDepartmentList();
}
// Update operation
@PutMapping("/departments/{id}")
public Department
updateDepartment(@RequestBody Department department,
@PathVariable("id") Long departmentId)
{
return departmentService.updateDepartment(
department, departmentId);
}
// Delete operation
@DeleteMapping("/departments/{id}")
public String deleteDepartmentById(@PathVariable("id")
Long departmentId)
{
departmentService.deleteDepartmentById(
departmentId);
return "Deleted Successfully";
}
}
Paso 8: a continuación se muestra el código para el archivo application.properties
server.port = 8082 # H2 Database spring.h2.console.enabled=true spring.datasource.url=jdbc:h2:mem:dcbapp spring.datasource.driverClassName=org.h2.Driver spring.datasource.username=sa spring.datasource.password=password spring.jpa.database-platform=org.hibernate.dialect.H2Dialect
Ahora ejecute su aplicación y probemos los puntos finales en Postman y también consulte nuestra base de datos H2.
Probando el Endpoint en Postman
Extremo 1: POST – http://localhost:8082/departamentos/
Extremo 2: GET – http://localhost:8082/departamentos/
Extremo 3: PUT – http://localhost:8082/departamentos/1
Extremo 4: ELIMINAR – http://localhost:8082/departamentos/1
Por último, la base de datos H2 se muestra en los siguientes medios de la siguiente manera:
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA