Spring Boot está construido en la parte superior del resorte y contiene todas las características del resorte. Y se está convirtiendo en el favorito de los desarrolladores en estos días debido a su rápido entorno listo para producción que les permite concentrarse directamente en la lógica en lugar de luchar con la configuración y la instalación. Spring Boot es un marco basado en microservicios y crear una aplicación lista para producción lleva muy poco tiempo. Las siguientes son algunas de las características de Spring Boot:
- Permite evitar la configuración pesada de XML que está presente en primavera.
- Proporciona fácil mantenimiento y creación de puntos finales REST
- Incluye servidor Tomcat incorporado
- La implementación es muy fácil, los archivos war y jar se pueden implementar fácilmente en el servidor tomcat
Para obtener más información, consulte este artículo: Introducción a Spring Boot . En este artículo, discutiremos cómo usar JpaRepository para administrar datos en una aplicación Spring Boot.
JpaRepositorio
JpaRepository es una extensión específica de JPA (API de persistencia de Java) de Repository. Contiene la API completa de CrudRepository y PagingAndSortingRepository . Por lo tanto, contiene API para operaciones CRUD básicas y también API para paginación y clasificación.
Sintaxis:
public interface JpaRepository<T,ID> extends PagingAndSortingRepository<T,ID>, QueryByExampleExecutor<T>
Dónde:
- T: tipo de dominio que administra el repositorio (generalmente el nombre de clase de la entidad/modelo)
- ID: Tipo de id de la entidad que maneja el repositorio (Generalmente la clase contenedora de su @Id que se crea dentro de la clase Entidad/Modelo)
Ilustración:
public interface DepartmentRepository extends JpaRepository<Department, Long> {}
Métodos
Algunos de los métodos más importantes que están disponibles dentro de JpaRepository se detallan a continuación.
Método 1: saveAll(): Guarda todas las entidades dadas.
Sintaxis:
<S extends T> List<S> saveAll(Iterable<S> entities)
Parámetros : Entidades, teniendo en cuenta que no deben ser nulos ni contener nulos.
Tipo de devolución : las entidades guardadas; nunca será nulo. El Iterable devuelto tendrá el mismo tamaño que el Iterable pasado como argumento.
Exception Thrown: lanza IllegalArgumentException en caso de que las entidades dadas o una de sus entidades sea nula.
Método 2: getById(): Devuelve una referencia a la entidad con el identificador dado. Dependiendo de cómo se implemente el proveedor de persistencia JPA, es muy probable que siempre devuelva una instancia y genere una EntityNotFoundException en el primer acceso. Algunos de ellos rechazarán inmediatamente los identificadores no válidos.
Sintaxis:
T getById(ID id)
Parámetros : id – no debe ser nulo.
Tipo de retorno: una referencia a la entidad con el identificador dado.
Método 3: flush(): Vacía todos los cambios pendientes en la base de datos.
Sintaxis:
void flush()
Método 4: saveAndFlush(): guarda una entidad y elimina los cambios al instante.
Sintaxis:
<S extends T> S saveAndFlush(S entity)
Parámetros: La entidad a guardar. No debe ser nulo.
Tipo de devolución : la entidad guardada
Método 5: deleteAllInBatch(): elimina las entidades dadas en un lote, lo que significa que creará una sola consulta. Este tipo de operación deja el caché de primer nivel de JPA y la base de datos sin sincronizar. Considere vaciar EntityManager antes de llamar a este método.
Sintaxis:
void deleteAllInBatch(Iterable<T> entities)
Parámetros : Las entidades a borrar, no deben ser nulas.
Implementación: Consideremos una aplicación Spring Boot que administra una entidad Departamento con JpaRepository. Los datos se guardan en la base de datos H2. Usamos un controlador RESTful.
Paso 1: cree 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
Ejemplo: Aquí está el código completo para el archivo pom.xml .
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 como se indica a continuación y 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.
Java
// Java Program to Demonstrate Department File
// Importing package module to this code fragment
package com.amiya.springbootdemoproject.entity;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
// Importing required classes
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@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á el JpaRepository como hemos discutido anteriormente.
Ejemplo:
Java
// Java Program to Illustrate DepartmentRepository File
// Importing package module to code fragment
package com.amiya.springbootdemoproject.repository;
import com.amiya.springbootdemoproject.entity.Department;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
// Annotation
@Repository
// Interface
public interface DepartmentRepository
extends JpaRepository<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 to code fragment
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 Illustrate DepartmentServiceImpl File
// Importing package module to code fragment
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.repository.DepartmentRepository;
// Importing required classes
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 .
Java
// Java Program to Demonstrate DepartmentController File
// Importing package module to code fragment
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
La base de datos H2 es la siguiente :
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA