Intégration MongoDB document-advanced use-spring-boot à l'aide de MongoDB --- MongoRepository pour effectuer des ajouts, des suppressions, des modifications et des requêtes

Adam:

        Avant d'apprendre l'instruction MongoDB sur le client MongoDB, intégrez maintenant MongoDB dans le projet Spring.

  Portail:

Documentation MongoDB - Concepts de base - Un seul blog Cheng - Blog CSDN

Documentation MongoDB--installation de base-installation Linux (construction de l'environnement mongodb)-installation docker (montage des volumes de données)-et comparaison détaillée des versions_一单成的博客-CSDN Blog

Documentation MongoDB--installation de base-installation Linux (construction de l'environnement mongodb)-installation docker (montage des volumes de données)-et comparaison détaillée des versions_一单成的博客-CSDN Blog

Documentation MongoDB - Utilisation de base - Utilisation des instructions de base de MongoDB dans le client (fenêtre DOS)/Outil de visualisation_Blog de One Single Cheng - Blog CSDN

Documentation MongoDB-Utilisation avancée-MongoDB Index-createindex() et dropindex()-Utilisation d'expressions régulières dans MongoDB pour trouver_One Single Cheng Blog-CSDN Blog

Intégration MongoDB document-advanced use-spring-boot à l'aide de MongoDB --- MongoTemplate pour effectuer des ajouts, des suppressions, des modifications et des requêtes_One Single Cheng's Blog-CSDN Blog

Introduction à l'utilisation de la technologie :

        Note conceptuelle :

        spring-data-mongodbMongoTemplate Il   offre  MongoRepositorydeux modes de
MongoRepository fonctionnement et est facile à utiliser.L'inconvénient est qu'il n'est pas assez flexible
MongoTemplate pour fonctionner de manière flexible.Ces deux modes peuvent être utilisés de manière flexible dans le projet

MongoTemplate 

        MongoTemplate fait partie du projet Spring Data MongoDB, qui est une extension Spring qui fournit une couche d'abstraction pour les applications utilisant la base de données MongoDB. MongoTemplate fournit un moyen simple et puissant d'effectuer diverses opérations de base de données sans écrire de code de pilote MongoDB de bas niveau.

Les principales fonctions de MongoTemplate incluent :

1. Insertion et mise à jour de documents : MongoTemplate fournit un moyen pratique d'insérer et de mettre à jour des documents dans une base de données MongoDB.
2. Documents de requête : MongoTemplate fournit une variété de méthodes de requête qui peuvent utiliser divers paramètres de requête pour récupérer des documents dans la base de données, y compris les conditions de requête, le tri, les restrictions et les projections.
3. Opérations d'agrégation : MongoTemplate prend en charge le cadre d'agrégation, qui peut effectuer des opérations d'agrégation complexes, telles que le comptage, le regroupement, la sommation, etc.
4. Gestion des index : MongoTemplate peut créer, supprimer et interroger des index de base de données.
5. Commandes et opérations : MongoTemplate prend également en charge diverses commandes et opérations de base de données, telles que le calcul de statistiques de base de données, l'exécution de procédures stockées, etc.

L'utilisation de MongoTemplate peut simplifier le travail de développement de l'exploitation de la base de données MongoDB, fournir une productivité plus élevée et une meilleure maintenabilité.

MongoRepository

MongoRepository est une autre couche d'abstraction du projet Spring Data MongoDB, qui est une abstraction de niveau supérieur basée sur MongoTemplate. MongoRepository fournit une interface basée sur des annotations pour définir les interactions avec les bases de données MongoDB. En utilisant MongoRepository, vous pouvez vous concentrer sur la définition de la logique d'accès aux données sans écrire de code d'opération de base de données de bas niveau.

Les principales fonctions de MongoRepository incluent :

1. Interrogation de documents : MongoRepository fournit une méthode pratique pour interroger des documents dans la base de données. En utilisant des annotations, vous pouvez définir les conditions de requête, l'ordre, les restrictions et les projections.
2. Opérations d'agrégation : MongoRepository prend en charge le cadre d'agrégation, qui peut effectuer des opérations d'agrégation complexes, telles que le comptage, le regroupement, la sommation, etc.
3. Requête de pagination : MongoRepository fournit une fonction de requête de pagination, qui peut limiter le nombre de résultats de la requête et obtenir la page de résultats suivante.
4. Requête personnalisée : si vous devez effectuer des opérations de requête plus complexes, MongoRepository fournit également une méthode de requête personnalisée, vous pouvez écrire des procédures stockées ou utiliser le langage de requête de MongoDB pour exécuter des requêtes personnalisées.

L'utilisation de MongoRepository peut rendre votre code plus concis et maintenable, car il fournit un moyen déclaratif d'accéder à la base de données MongoDB. Grâce aux annotations et aux interfaces implémentées automatiquement, vous pouvez vous concentrer sur l'implémentation de la logique métier sans vous soucier des détails des opérations de base de données sous-jacentes.

Utilisation en botte à ressortMongoRepository进行增删改查

Adam:

        Utiliser MongoRepository的好处是和 MyBatis-Plus, c'est comme fournir plusieurs méthodes packagées. Très pratique (pour CRUD simple). Mais j'ai découvert qu'il n'y a rien de tel! ! Encapsulation modifiée de bon usage.

1. Introduire des dépendances

 Dépendances principales :

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

Cette dépendance est la dépendance de démarrage fournie par Spring Boot pour interagir avec la base de données MongoDB. Il contient les bibliothèques et dépendances requises pour utiliser facilement MongoDB lors du développement d'applications avec Spring Boot.

Plus précisément, cette dépendance fournit les fonctionnalités suivantes :

1. Configuration automatique : Spring Boot configurera automatiquement la connexion avec la base de données MongoDB, y compris la création d'un client Mongo, la définition des propriétés de connexion, etc.
2. MongoTemplate : configure automatiquement MongoTemplate, une classe principale pour effectuer diverses opérations de base de données. En utilisant MongoTemplate, vous pouvez facilement insérer, mettre à jour, interroger et effectuer d'autres opérations sur des documents.
3. MongoRepository : MongoRepository est automatiquement configuré, qui est une interface basée sur des annotations pour définir les interactions avec les bases de données MongoDB. En héritant de MongoRepository, vous pouvez facilement effectuer des requêtes, des opérations d'agrégation, etc.
4. Opérations basées sur un modèle : en utilisant MongoTemplate et MongoRepository, vous pouvez effectuer des opérations de base de données de manière basée sur un modèle, ce qui rend le code plus concis et plus lisible.

En bref, en ajoutant cette dépendance, vous pouvez facilement utiliser Spring Boot pour vous intégrer à MongoDB sans configurer et écrire manuellement le code d'opération de base de données de bas niveau.

Autres dépendances : (si vous souhaitez démarrer directement un projet Spring-Boot simple, vous pouvez le supprimer)

<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. Le fichier application.yml est utilisé pour écrire le fichier de configuration de la connexion MongoDB

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

Avis:

        S'il n'y a pas d'utilisateur connecté, certains fichiers de configuration peuvent être supprimés en fonction de la situation réelle.

        Par rapport à MySQL, la différence est qu'un utilisateur peut gérer plusieurs bases de données dans MySQL, mais chaque base de données de MongoDB nécessite un utilisateur de gestion indépendant et le mot de passe utilisateur correspondant doit être saisi lors de la connexion.

3. Écrire sur les classes d'entités (attention s'il y a des fosses !!)

Remarques principales :

         1. @Document correspond au document dans MongoDB, qui est l'unité de données la plus élémentaire de la base de données. Il est composé de paires clé-valeur, similaires au format JSON, et peut stocker différents champs. La valeur du champ peut inclure autres documents, tableaux et tableaux de documents .

        2. @Id (clé primaire): Il est utilisé pour mapper la valeur de la variable membre à la valeur du _id du document.Vous pouvez voir comment attribuer une valeur à _id dans mon document précédent.

        3. @Index (index) : un index est une structure de données spéciale qui est stockée dans une collection de données facile à parcourir et à lire, et qui peut trier les données dans le document de données. L'indexation peut grandement améliorer l'efficacité des requêtes de documents.

        4. @Field (champ) : le champ dans le document, similaire au concept de colonne dans MySQL.

        5. @Aggregation (agrégation) : L'agrégation est principalement utilisée pour le traitement des données, comme la moyenne statistique, la sommation, etc.

Exemple:

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;//特长描述
}

Le document dans l'exemple est le nom de la collection

Avis:

        Assurez-vous d'écrire l'annotation @Field("name") pour faire correspondre le nom du champ, sinon tous les résultats seront vides ! ! !

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

C'est tout le code packagé sous-jacent, voici le code directement ! Si vous avez des doutes, veuillez en discuter dans la zone de commentaires 

couche de contrôle du contrôleur

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);
    }


}

interface de la couche de service

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);
}

classe d'implémentation de la couche de service

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);
    }


}

couche dao (j'ai écrit mapper parce que j'y suis habitué)

Point clé : hériter de la classe 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> {
    
}