Spring Boot: operaciones CRUD con base de datos MySQL

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 MySQL. Así que aquí hay una breve explicación de What’s Spring Boot y What’s MySQL 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 instalació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 MySQL

MySQL es un RDBMS (Sistema de administración de bases de datos relacionales) basado en SQL (Lenguaje de consulta estructurado) , que es el lenguaje popular para acceder y administrar los registros en la base de datos. MySQL es un software gratuito y de código abierto bajo la licencia GNU. Cuenta con el apoyo de Oracle Company. Los datos en una base de datos MySQL se almacenan en tablas. Una tabla es una colección de datos relacionados y consta de columnas y filas. Algunas de las características de MySQL se enumeran a continuación:

1. Es un sistema de base de datos utilizado en la web.
2. Se ejecuta en un servidor
3. Es ideal para aplicaciones pequeñas y grandes.
4. Es muy rápido, confiable y fácil de usar.
5. Utiliza SQL estándar
6. Es gratis para descargar y usar

Entonces, para conectar y realizar la operación CRUD con MySQL DB con la aplicación Spring Boot, solo tenemos que configurarlo dentro del archivo application.properties de la siguiente manera:

# Configuration for MySQL Database

spring.jpa.hibernate.ddl-auto=update

spring.datasource.url = jdbc:mysql://localhost:3306/schooldb 
(Datasource URL of your DB and "schooldb", here is your schema name)

spring.datasource.username=amiya559 (Your MySQL Workbench user name)
spring.datasource.password=password.123 (Your MySQL Workbench password)
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true

Repositorio JPA 

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 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 JpaRepository<Department, Long> {}

Ejemplo: Tendremos una aplicación Spring Boot que administra una entidad Departamento con JpaRepository. Los datos se guardan en la base de datos MySQL. Usamos un controlador RESTful.

Paso 1: Cree un proyecto Spring Boot con digamos que sea IntelliJ

Paso 2: agregue la siguiente dependencia como se indica a continuación de la siguiente manera:

• Telaraña de primavera
• Base de datos MySQL
• Lombok
• JPA de datos de primavera

A continuación se muestra el código completo para el archivo pom.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 for MySQL Database -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</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 enumeran y cree algunas clases e interfaces dentro de estos paquetes como se ve en la imagen a continuación como se muestra:

• 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

Se realiza mediante la creación de una clase POJO simple dentro del archivo Department.java. 

//  Java Program to Illustrate Department File
 
// Importing package module to code fragment
package com.amiya.springbootdemoproject.entity;
 
// Importing required classes
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;
 
// Annotations
@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 Program to Illustrate DepartmentRepository 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.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

Ejemplo 1-A Dentro del paquete, cree una interfaz denominada DepartmentService y una clase denominada DepartmentServiceImpl .  

// Java Program to Illustrate DepartmentService File
 
// Importing package to this 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 Program to Illustrate DepartmentServiceImpl File
 
// Importing package module to this code
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 denominada DepartmentController. 

// Java Program to Illustrate DepartmentController File
 
// Importing package module to this code
package com.amiya.springbootdemoproject.controller;
 
import com.amiya.springbootdemoproject.entity.Department;
import com.amiya.springbootdemoproject.service.DepartmentService;
import java.util.List;
import javax.validation.Valid;
// Importing required classes
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

# Configuration for MySQL Database
spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://localhost:3306/schooldb
spring.datasource.username=amiya559
spring.datasource.password=password.123
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.jpa.show-sql:true

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 

MySQL Workbench aparecerá como se muestra a continuación: