Spring Boot – Operaciones CRUD usando MongoDB

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 configuración. Spring Boot es un marco basado en microservicios y crear una aplicación lista para producción lleva muy poco tiempo.

MongoDB y MongoDB Compass

MongoDB , la base de datos NoSQL más popular, es una base de datos orientada a documentos de código abierto. El término ‘NoSQL’ significa ‘no relacional’. Significa que MongoDB no se basa en la estructura de base de datos relacional similar a una tabla, sino que proporciona un mecanismo completamente diferente para el almacenamiento y la recuperación de datos. Este formato de almacenamiento se llama BSON (similar al formato JSON). Una estructura simple de documento MongoDB: 

{
 title: 'GeeksforGeeks',
 by: 'Amiya Rout',
 url: 'https://www.geeksforgeeks.org',
 type: 'NoSQL'
} 

MongoDB Compass es una poderosa GUI para consultar, agregar y analizar sus datos de MongoDB en un entorno visual. Compass es de uso gratuito y fuente disponible y se puede ejecutar en macOS, Windows y Linux.

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

# Configuration for MongoDB

spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=BookStore (Here BookStore is my database name)

MongoRepositorio

MongoRepository es una interfaz proporcionada por Spring Data en el paquete org.springframework.data.mongodb.repository . MongoRepository amplía las interfaces PagingAndSortingRepository y QueryByExampleExecutor que amplían aún más la interfaz CrudRepository . MongoRepository proporciona todos los métodos necesarios que ayudan a crear una aplicación CRUD y también admite los métodos de consulta derivados personalizados.

Sintaxis:

public interface MongoRepository<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 BookRepo extends MongoRepository<Book, Integer> {}

Ejemplo: Haremos una aplicación Spring Boot que administre una entidad Libro con MongoRepository. Los datos se guardan en la base de datos MongoDB. 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
• MongoDB
• Lombok
• Herramientas de desarrollo

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.6.0</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.globallogic</groupId>
    <artifactId>spring-mongodb</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>spring-mongodb</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-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
  
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </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 3 paquetes y cree algunas clases e interfaces dentro de estos paquetes como se ve en la imagen a continuación

• modelo
• repositorio
• 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

Creando una clase POJO simple dentro del archivo Book.java.

Ejemplo

// Java Program to illustrate Book File
  
// Importing required classes
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
  
// Annotations
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(collection = "Book")
  
// Class
public class Book {
  
    // Attributes
    @Id private int id;
    private String bookName;
    private String authorName;
}

Paso 5: dentro del paquete del repositorio

Cree una interfaz simple y nombre la interfaz como BookRepo . Esta interfaz ampliará el MongoRepository como hemos discutido anteriormente.

Ejemplo

// Java Program to Illustrate BookRepo File
  
import com.globallogic.spring.mongodb.model.Book;
import org.springframework.data.mongodb.repository.MongoRepository;
  
public interface BookRepo
    extends MongoRepository<Book, Integer> {
}

Paso 6: dentro del paquete del controlador

Dentro del paquete, cree una clase llamada BookController .

import com.globallogic.spring.mongodb.model.Book;
import com.globallogic.spring.mongodb.repository.BookRepo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
  
import java.util.List;
  
// Annotation 
@RestController
  
// Class 
public class BookController {
  
    @Autowired
    private BookRepo repo;
  
    @PostMapping("/addBook")
    public String saveBook(@RequestBody Book book){
        repo.save(book);
        
        return "Added Successfully";
    }
  
    @GetMapping("/findAllBooks")
    public List<Book> getBooks() {
        
        return repo.findAll();
    }
  
    @DeleteMapping("/delete/{id}")
    public String deleteBook(@PathVariable int id){
        repo.deleteById(id);
        
        return "Deleted Successfully";
    }
  
}

Paso 7: a continuación se muestra el código para el archivo application.properties

server.port = 8989

# MongoDB Configuration
server.port:8989
spring.data.mongodb.host=localhost
spring.data.mongodb.port=27017
spring.data.mongodb.database=BookStore

Paso 8: Dentro de MongoDB Compass

Vaya a su MongoDB Compass y cree una base de datos llamada BookStore y dentro de la base de datos cree una colección llamada Book como se ve en la imagen de abajo

Ahora ejecute su aplicación y probemos los puntos finales en Postman y también consulte nuestro MongoDB Compass.

Probando el Endpoint en Postman

Extremo 1: POST – http://localhost:8989/addBook

Punto final 2: GET – http://localhost:8989/findAllBooks

Extremo 3: ELIMINAR – http://localhost:8989/delete/1329

Finalmente, MongoDB Compass es como se muestra en la imagen a continuación como se muestra a continuación de la siguiente manera: