Spring Boot – Operaciones CRUD – Part 1

CRUD significa Crear, Leer/Recuperar, Actualizar y Eliminar y estas son las cuatro operaciones básicas que realizamos en el almacenamiento persistente. CRUD está orientado a datos y al uso estandarizado de métodos HTTP. HTTP tiene algunos métodos que funcionan como operaciones CRUD y tenga en cuenta que son muy vitales desde una perspectiva de punto de desarrollo en la programación que también nos ayuda a relacionarnos mejor con el desarrollo web y también nos ayuda cuando tratamos con bases de datos. Entonces, las operaciones CRUD estándar son las siguientes:

• POST : crea un nuevo recurso
• GET : lee/recupera un recurso
• PUT : Actualiza un recurso existente
• DELETE : Elimina un recurso

Como el nombre sugiere 

• Operación CREATE : Realiza la instrucción INSERT para crear un nuevo registro.
• Operación READ : Lee los registros de la tabla en función del parámetro de entrada.
• Operación UPDATE : Ejecuta una declaración de actualización en la tabla. Se basa en el parámetro de entrada.
• Operación DELETE : Elimina una fila especificada en la tabla. También se basa en el parámetro de entrada.

Entonces, en este artículo, 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. Así que aquí hay una breve explicación de What’s Spring Boot y What’s H2 Database. 

Bota de primavera

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 porque es un entorno listo para la producción rápida que permite a los desarrolladores centrarse directamente en la lógica en lugar de luchar con la configuración y la configuración. Spring Boot es un marco basado en microservicios y crear una aplicación lista para producción lleva muy poco tiempo.

Base de datos H2

H2 es un sistema de gestión de bases de datos relacionales escrito en Java. Puede integrarse en aplicaciones Java o ejecutarse en modo cliente-servidor. Las principales características de H2 son:

• API JDBC muy rápida y de código abierto
• Modos integrado y de servidor; bases de datos en memoria
• Aplicación de consola basada en navegador
• Tamaño reducido: alrededor de 2,5 MB de tamaño de archivo jar

Repositorio Spring Boot 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. 

Ilustración:

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

Dónde:

• Departamento : tipo de dominio que administra el repositorio (generalmente el nombre de clase de la entidad/modelo)
• Largo : tipo de identificación de la entidad que administra el repositorio (generalmente, la clase contenedora de su @Id que se crea dentro de la clase Entidad/Modelo)

Ejemplo:

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

Ejemplo

package com.amiya.springbootdemoproject.repository;
 
import com.amiya.springbootdemoproject.entity.Department;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
 
@Repository
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

// Java Program to Illustrate DepartmentService.java File
 
// Importing packages
package com.amiya.springbootdemoproject.service;
import com.amiya.springbootdemoproject.entity.Department;
// Importing required classes
import java.util.List;
 
// Class
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);
}

A continuación se muestra el código para el archivo DepartmentServiceImpl.java

Ejemplo 2

// Java Program to Illustrate DepartmentServiceImpl.java
// File
 
// Importing required packages
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 implementing DepartmentService 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 Program to Illustrate DepartmentController.java File
 
// Importing 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: