Spring Boot – CrudRepository con ejemplo

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 CrudRepository para administrar datos en una aplicación Spring Boot.

Repositorio Crud 

Hay una interfaz disponible en Spring Boot llamada CrudRepository que contiene métodos para operaciones CRUD. Proporciona una operación Crud genérica en un repositorio. Se define en el paquete org.springframework.data.repository y amplía la interfaz Spring Data Repository . Si alguien quiere usar CrudRepository en la aplicación Spring Boot, debe crear una interfaz y ampliar la interfaz de CrudRepository. 

Sintaxis: 

public interface CrudRepository<T, ID> extends Repository<T, ID>

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 administra el repositorio (Generalmente la clase contenedora de su @Id que se crea dentro de la clase Entidad/Modelo)

Ilustración:

public interface DepartmentRepository extends CrudRepository<Department, Long> {}

Ahora analicemos algunos de los métodos más importantes que están disponibles dentro de CrudRepository a continuación:

Método 1: save(): Guarda una entidad determinada. Utilice la instancia devuelta para otras operaciones, ya que la operación de guardar podría haber cambiado la instancia de la entidad por completo.

Sintaxis:

<S extends T> S save(S entity)

• Parámetros : entidad: no debe ser nulo.
• Devoluciones : la entidad guardada; nunca será nulo.
• Lanza : IllegalArgumentException – en caso de que la entidad dada sea nula.

Método 2: findById(): Recupera una entidad por su id.

Sintaxis:

Optional<T> findById(ID id)

• Parámetros : id – no debe ser nulo.
• Devuelve : la entidad con la identificación dada o Opcional # vacío() si no se encuentra ninguno.
• Excepción lanzada: IllegalArgumentException se lanza si el ‘id’ es nulo.

Método 3: findAll(): Devuelve todas las instancias del tipo.

Sintaxis: 

Iterable<T> findAll()

Tipo de devolución : Todas las entidades

Método 4: count(): Devuelve el número de entidades disponibles.

Sintaxis:

long count()

Tipo de retorno : el número de entidades.

Método 5: deleteById(): Elimina la entidad con la identificación dada.

Sintaxis:

void deleteById(ID id)

Parámetros : Id (no debe ser nulo)

Excepción lanzada : IllegalArgumentException en caso de que la identificación dada sea nula.

Ejemplo

La siguiente aplicación Spring Boot administra una entidad Departamento con CrudRepository. Los datos se guardan en la base de datos H2. Usamos un controlador RESTful.

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 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 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. A continuación se muestra el código para el archivo Department.java

package com.amiya.springbootdemoproject.entity;
  
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
  
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
  
@Entity
@Data
@NoArgsConstructor
@AllArgsConstructor
@Builder
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. 

// Java Program to Illustrate DepartmentRepository.java File
  
// Importing package module to this code
package com.amiya.springbootdemoproject.repository;
// Importing required classes
import com.amiya.springbootdemoproject.entity.Department;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
  
// Annotation
@Repository
  
// Class
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 . A continuación se muestra el código para el archivo DepartmentService.java .

Ejemplo 1-A

package com.amiya.springbootdemoproject.service;
  
import com.amiya.springbootdemoproject.entity.Department;
  
import java.util.List;
  
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 

// Below is the code for the DepartmentServiceImpl.java file.
package com.amiya.springbootdemoproject.service;
  
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.repository.DepartmentRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
  
import java.util.List;
import java.util.Objects;
  
@Service
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 Program to Illustrate DepartmentController File
  
// Importing package module
package com.amiya.springbootdemoproject.controller;
// Importing required classes
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.service.DepartmentService;
import java.util.List;
import javax.validation.Valid;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
  
// Annotation
@RestController
  
// Class
public class DepartmentController {
  
    // Annotation
    @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 como se muestra en los medios a continuación