Integración de arranque de resorte de uso avanzado de documentos MongoDB usando MongoDB---MongoRepository para completar adiciones, eliminaciones, cambios y consultas

Adán:

        Antes de aprender la declaración de MongoDB en el cliente de MongoDB, ahora integre MongoDB en el proyecto Spring.

  Portal:

Documentación de MongoDB--Conceptos básicos - Un solo blog de Cheng - Blog de CSDN

Documentación de MongoDB--instalación básica-instalación de linux (construcción del entorno mongodb)-instalación de docker (montar volúmenes de datos)-y comparación detallada de versiones_一单成的博客-CSDN Blog

Documentación de MongoDB--instalación básica-instalación de linux (construcción del entorno mongodb)-instalación de docker (montar volúmenes de datos)-y comparación detallada de versiones_一单成的博客-CSDN Blog

Documentación de MongoDB - Uso básico - Uso de declaraciones básicas de MongoDB en el cliente (ventana dos)/Herramienta de visualización_Blog de One Single Cheng-Blog de CSDN

Documentación de MongoDB-Uso avanzado-Índice de MongoDB-createindex() y dropindex()-Uso de expresiones regulares en MongoDB para encontrar_Un solo blog de Cheng-Blog de CSDN

MongoDB documento-uso avanzado-integración de arranque usando MongoDB---MongoTemplate para completar adiciones, eliminaciones, modificaciones y consultas_Blog de One Single Cheng-CSDN Blog

Introducción al uso de la tecnología:

        Nota mental:

        spring-data-mongodb Proporciona  dos modos de operación y es fácil de operar. La desventaja es que MongoTemplate no   es lo suficientemente flexible  para operar de manera flexible. Estos dos modos se pueden usar de manera flexible en el proyecto.MongoRepository
MongoRepository
MongoTemplate

MongoTemplate 

        MongoTemplate es parte del proyecto Spring Data MongoDB, que es una extensión de Spring que proporciona una capa de abstracción para aplicaciones que utilizan la base de datos MongoDB. MongoTemplate proporciona una manera simple y poderosa de realizar varias operaciones de base de datos sin escribir el código del controlador MongoDB de bajo nivel.

Las funciones principales de MongoTemplate incluyen:

1. Inserción y actualización de documentos: MongoTemplate proporciona una forma conveniente de insertar y actualizar documentos en una base de datos MongoDB.
2. Consultar documentos: MongoTemplate proporciona una variedad de métodos de consulta que pueden usar varios parámetros de consulta para recuperar documentos en la base de datos, incluidas las condiciones de consulta, clasificación, restricciones y proyecciones.
3. Operaciones de agregación: MongoTemplate admite el marco de agregación, que puede realizar operaciones de agregación complejas, como contar, agrupar, sumar, etc.
4. Gestión de índices: MongoTemplate puede crear, eliminar y consultar índices de bases de datos.
5. Comandos y operaciones: MongoTemplate también admite varios comandos y operaciones de bases de datos, como el cálculo de estadísticas de bases de datos, la ejecución de procedimientos almacenados, etc.

El uso de MongoTemplate puede simplificar el trabajo de desarrollo de la operación de la base de datos MongoDB, proporcionar una mayor productividad y una mejor capacidad de mantenimiento.

MongoRepository

MongoRepository es otra capa de abstracción en el proyecto Spring Data MongoDB, que es una abstracción de nivel superior basada en MongoTemplate. MongoRepository proporciona una interfaz basada en anotaciones para definir interacciones con bases de datos MongoDB. Al usar MongoRepository, puede concentrarse en definir la lógica de acceso a datos sin escribir código de operación de base de datos de bajo nivel.

Las funciones principales de MongoRepository incluyen:

1. Consulta de documentos: MongoRepository proporciona un método conveniente para consultar documentos en la base de datos. Mediante el uso de anotaciones, puede definir las condiciones de consulta, el orden, las restricciones y las proyecciones.
2. Operaciones de agregación: MongoRepository admite el marco de agregación, que puede realizar operaciones de agregación complejas, como contar, agrupar, sumar, etc.
3. Consulta de paginación: MongoRepository proporciona una función de consulta de paginación, que puede limitar la cantidad de resultados de la consulta y obtener la siguiente página de resultados.
4. Consulta personalizada: si necesita realizar operaciones de consulta más complejas, MongoRepository también proporciona un método de consulta personalizada, puede escribir procedimientos almacenados o usar el lenguaje de consulta de MongoDB para ejecutar consultas personalizadas.

El uso de MongoRepository puede hacer que su código sea más conciso y mantenible, ya que proporciona una forma declarativa de acceder a la base de datos MongoDB. A través de anotaciones e interfaces implementadas automáticamente, puede concentrarse en implementar la lógica comercial sin preocuparse por los detalles operativos de la base de datos subyacente.

Uso en bota de resorteMongoRepository进行增删改查

Adán:

        Usar MongoRepository的好处是和 MyBatis-Plus es como proporcionar muchos métodos empaquetados. Muy conveniente (para CRUD simple). ¡Pero descubrí que no existe tal cosa! ! Encapsulación modificada de buen uso.

1. Introducir dependencias

 Dependencias principales:

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

Esta dependencia es la dependencia inicial proporcionada por Spring Boot para interactuar con la base de datos MongoDB. Contiene las bibliotecas y dependencias necesarias para usar fácilmente MongoDB al desarrollar aplicaciones con Spring Boot.

Específicamente, esta dependencia proporciona la siguiente funcionalidad:

1. Configuración automática: Spring Boot configurará automáticamente la conexión con la base de datos MongoDB, incluida la creación de un cliente Mongo, la configuración de las propiedades de conexión, etc.
2. MongoTemplate: configura automáticamente MongoTemplate, una clase central para realizar varias operaciones de base de datos. Al usar MongoTemplate, puede insertar, actualizar, consultar y otras operaciones de documentos fácilmente.
3. MongoRepository: MongoRepository se configura automáticamente, que es una interfaz basada en anotaciones para definir interacciones con bases de datos MongoDB. Al heredar MongoRepository, puede realizar cómodamente consultas, operaciones de agregación, etc.
4. Operaciones con plantilla: al usar MongoTemplate y MongoRepository, puede realizar operaciones de base de datos con una plantilla, lo que hace que el código sea más conciso y más legible.

En resumen, al agregar esta dependencia, puede usar fácilmente Spring Boot para integrarse con MongoDB sin configurar y escribir manualmente el código de operación de la base de datos de bajo nivel.

Otras dependencias: (si desea iniciar directamente un proyecto simple de arranque de resorte, puede eliminarlo)

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-mongodb</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

2. El archivo application.yml se usa para escribir el archivo de configuración de conexión MongoDB

spring:
  data:
    mongodb:
      host: 127.0.0.1 #指定MongoDB服务地址
      port: 27017 #指定端口，默认就为27017
      database: article#指定使用的数据库(集合)
      authentication-database: admin # 登录认证的逻辑库名
      username:  #用户名
      password:  #密码

Aviso:

        Si no hay ningún usuario conectado, algunos archivos de configuración se pueden eliminar según la situación real.

        En comparación con MySQL, la diferencia es que un usuario puede administrar varias bases de datos en MySQL, pero cada base de datos de MongoDB necesita un usuario de administración independiente, y se debe ingresar la contraseña de usuario correspondiente al conectarse.

3. Escribir sobre clases de entidades (¡atención si hay pozos!)

Notas principales:

         1. @Document corresponde al documento en MongoDB, que es la unidad de datos más básica en la base de datos. Está compuesto por pares clave-valor, similar al formato JSON, y puede almacenar diferentes campos. El valor del campo puede incluir otros documentos, arreglos y arreglos de documentos.

        2. @Id (clave principal): Se usa para mapear el valor de la variable miembro al valor del _id del documento, puedes ver cómo asignar un valor a _id en mi documento anterior.

        3. @Index (índice): un índice es una estructura de datos especial que se almacena en una colección de datos que es fácil de recorrer y leer, y puede ordenar los datos en el documento de datos. La indexación puede mejorar en gran medida la eficiencia de la consulta de documentos.

        4. @Field (campo): el campo en el documento, similar al concepto de columna en MySQL.

        5. @Aggregation (agregación): la agregación se utiliza principalmente para el procesamiento de datos, como el promedio estadístico, la suma, etc.

Ejemplo:

package com.adn.mongodb.common;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

/**
 * 阿丹实体类
 * */
@Data
@Document(collection = "ExampleDB")
public class Adn {
    @Id
    @Field("_id")
    private Long id;//阿丹主键
    @Field("name")
    private String name;//阿丹名称
    @Field("gender")
    private String gender;//阿丹性别
    @Field("specialty")
    private String specialty;//特长描述
}

El documento del ejemplo es el nombre de la colección.

Aviso:

        Asegúrese de escribir la anotación @Field("nombre") para asignar al nombre del campo, de lo contrario, ¡todos los resultados estarán vacíos! ! !

4. UsoMongoRepository来完成简单增删改查

Este es todo el código empaquetado subyacente, ¡aquí está el código directamente! Si tiene alguna duda, por favor discuta en el área de comentarios. 

capa de control del controlador

package com.adn.mongodb.controller;

import com.adn.mongodb.common.Adn;
import com.adn.mongodb.service.MongodbService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

/**
 * 控制层器
 * */
@RestController
public class MongodbController {
    @Autowired
    private MongodbService mongodbService;


    /**
     * 根据id来进行查询
     * */
    @GetMapping("/adn/{id}")
    public Adn  adn(@PathVariable String  id) {
        System.out.println(id);
        return mongodbService.adn(id);
    }
    /**
     * 增加数据插入数据
     * */
    @PostMapping("/save")
    public Adn  save(@RequestBody Adn adn) {
        return mongodbService.save(adn);
    }
    // @RequestMapping("/adn")
    // public String adn() {

    /**
     * 修改
     * */
    @PutMapping("/update")
    public Adn update(@RequestBody Adn adn) {

        return mongodbService.update(adn);
    }
    /**
     * 插入因为没有对应的方法，所以使用单查询+删除+新增来处理
     * */

    /**
     * 删除
     * */
    @DeleteMapping("/delete/{id}")
    public void delete(@PathVariable String id) {
        mongodbService.delete(id);
    }


}

interfaz de capa de servicio

package com.adn.mongodb.service;

import com.adn.mongodb.common.Adn;

public interface MongodbService {
    Adn adn(String id);


    Adn save(Adn adn);

    Adn update(Adn adn);

    void delete(String id);
}

clase de implementación de la capa de servicio

package com.adn.mongodb.service.Impl;

import com.adn.mongodb.common.Adn;
import com.adn.mongodb.mapper.AdnMapper;
import com.adn.mongodb.service.MongodbService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.autoconfigure.AutoConfigurationPackage;
import org.springframework.stereotype.Service;

import java.util.Optional;

@Service
public class MongodbServiceImpl implements MongodbService {
    @Autowired
    private AdnMapper adnMapper;
    @Override
    public Adn adn(String id) {
        Adn res = null;
        Optional<Adn> byId = adnMapper.findById(id);
        System.out.println(byId);
        boolean present = byId.isPresent();
        if(present){
            res = byId.get();
        }
        return res;
    }

    @Override
    public Adn save(Adn adn) {
        return adnMapper.save(adn);
    }

    @Override
    public Adn update(Adn adn) {
        return adnMapper.updata(adn);
    }

    @Override
    public void delete(String id) {
        adnMapper.deleteById(id);
    }


}

capa dao (escribí mapper porque estoy acostumbrado)

Punto clave: ¡Heredar la clase MongoRepository! ! !

package com.adn.mongodb.mapper;

import com.adn.mongodb.common.Adn;
import org.springframework.data.mongodb.repository.MongoRepository;

import java.util.Optional;

public interface AdnMapper extends MongoRepository<Adn, String> {
    
}