MongoDB-Dokument-erweiterte Use-Spring-Boot-Integration mit MongoDB---MongoRepository zum Abschließen von Hinzufügungen, Löschungen, Änderungen und Abfragen

Adam:

        Bevor Sie die MongoDB-Anweisung auf dem MongoDB-Client lernen, integrieren Sie nun MongoDB in das Spring-Projekt.

  Portal:

MongoDB-Dokumentation – Grundlegende Konzepte – Ein einziger Cheng-Blog – CSDN-Blog

MongoDB-Dokumentation – grundlegende Installation – Linux-Installation (Erstellung der MongoDB-Umgebung) – Docker-Installation (Montieren von Datenvolumes) – und detaillierter Versionsvergleich_一单成的博客 – CSDN-Blog

MongoDB-Dokumentation – grundlegende Installation – Linux-Installation (Erstellung der MongoDB-Umgebung) – Docker-Installation (Montieren von Datenvolumes) – und detaillierter Versionsvergleich_一单成的博客 – CSDN-Blog

MongoDB-Dokumentation – Grundlegende Verwendung – Verwenden von MongoDB-Basisanweisungen im Client (DOS-Fenster)/Visualisierungstool_One Single Chengs Blog-CSDN-Blog

MongoDB-Dokumentation - Erweiterte Verwendung - MongoDB-Index - createindex () und dropindex () - Verwenden regulärer Ausdrücke in MongoDB, um_Ein einzelnes Cheng-Blog - CSDN-Blog zu finden

MongoDB-Dokument-erweiterte Verwendung-Spring-Boot-Integration mit MongoDB---MongoTemplate zum Abschließen von Hinzufügungen, Löschungen, Änderungen und Abfragen_One Single Chengs Blog-CSDN-Blog

Einführung in die Einsatztechnologie:

        Konzeptpapier:

        spring-data-mongodbMongoTemplate Es   bietet  MongoRepositoryzwei Betriebsmodi
MongoRepository und ist einfach zu bedienen. Der Nachteil besteht darin, dass es nicht flexibel genug ist,
MongoTemplate um flexibel zu arbeiten. Diese beiden Modi können im Projekt flexibel verwendet werden

MongoTemplate 

        MongoTemplate ist Teil des Spring Data MongoDB-Projekts, einer Spring-Erweiterung, die eine Abstraktionsschicht für Anwendungen bereitstellt, die die MongoDB-Datenbank verwenden. MongoTemplate bietet eine einfache und leistungsstarke Möglichkeit, verschiedene Datenbankoperationen durchzuführen, ohne MongoDB-Treibercode auf niedriger Ebene schreiben zu müssen.

Zu den Hauptfunktionen von MongoTemplate gehören:

1. Einfügen und Aktualisieren von Dokumenten: MongoTemplate bietet eine praktische Möglichkeit, Dokumente in eine MongoDB-Datenbank einzufügen und zu aktualisieren.
2. Dokumente abfragen: MongoTemplate bietet eine Vielzahl von Abfragemethoden, die verschiedene Abfrageparameter verwenden können, um Dokumente in der Datenbank abzurufen, einschließlich Abfragebedingungen, Sortierung, Einschränkungen und Projektionen.
3. Aggregationsoperationen: MongoTemplate unterstützt das Aggregationsframework, das komplexe Aggregationsoperationen wie Zählen, Gruppieren, Summieren usw. ausführen kann.
4. Indexverwaltung: MongoTemplate kann Datenbankindizes erstellen, löschen und abfragen.
5. Befehle und Operationen: MongoTemplate unterstützt auch verschiedene Datenbankbefehle und -operationen, z. B. das Berechnen von Datenbankstatistiken, das Ausführen gespeicherter Prozeduren usw.

Die Verwendung von MongoTemplate kann die Entwicklungsarbeit des MongoDB-Datenbankbetriebs vereinfachen, eine höhere Produktivität und eine bessere Wartbarkeit bieten.

MongoRepository

MongoRepository ist eine weitere Abstraktionsschicht im Spring Data MongoDB-Projekt, bei der es sich um eine Abstraktion auf höherer Ebene handelt, die auf MongoTemplate basiert. MongoRepository bietet eine annotationsbasierte Schnittstelle zum Definieren von Interaktionen mit MongoDB-Datenbanken. Durch die Verwendung von MongoRepository können Sie sich auf die Definition der Datenzugriffslogik konzentrieren, ohne Low-Level-Datenbankbetriebscode schreiben zu müssen.

Zu den Hauptfunktionen von MongoRepository gehören:

1. Dokumente abfragen: MongoRepository bietet eine praktische Methode zum Abfragen von Dokumenten in der Datenbank. Mithilfe von Anmerkungen können Sie Abfragebedingungen, Reihenfolge, Einschränkungen und Prognosen definieren.
2. Aggregationsoperationen: MongoRepository unterstützt das Aggregationsframework, das komplexe Aggregationsoperationen wie Zählen, Gruppieren, Summieren usw. durchführen kann.
3. Paging-Abfrage: MongoRepository bietet eine Paging-Abfragefunktion, mit der die Anzahl der Abfrageergebnisse begrenzt und die nächste Ergebnisseite abgerufen werden kann.
4. Benutzerdefinierte Abfrage: Wenn Sie komplexere Abfragevorgänge ausführen müssen, bietet MongoRepository auch eine benutzerdefinierte Abfragemethode. Sie können gespeicherte Prozeduren schreiben oder die Abfragesprache von MongoDB verwenden, um benutzerdefinierte Abfragen auszuführen.

Die Verwendung von MongoRepository kann Ihren Code prägnanter und wartbarer machen, da es eine deklarative Möglichkeit bietet, auf die MongoDB-Datenbank zuzugreifen. Durch Annotationen und automatisch implementierte Schnittstellen können Sie sich auf die Implementierung der Geschäftslogik konzentrieren, ohne sich um die zugrunde liegenden Details des Datenbankbetriebs kümmern zu müssen.

Verwendung im SpringbootMongoRepository进行增删改查

Adam:

        Die Verwendung von MongoRepository的好处是和 MyBatis-Plus ist wie die Bereitstellung vieler Paketmethoden. Sehr praktisch (für einfaches CRUD). Aber ich habe herausgefunden, dass es so etwas nicht gibt! ! Modifizierte Kapselung für gute Nutzung.

1. Abhängigkeiten einführen

 Kernabhängigkeiten:

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

Diese Abhängigkeit ist die von Spring Boot bereitgestellte Starterabhängigkeit für die Interaktion mit der MongoDB-Datenbank. Es enthält die erforderlichen Bibliotheken und Abhängigkeiten, um MongoDB bei der Entwicklung von Anwendungen mit Spring Boot problemlos zu verwenden.

Konkret bietet diese Abhängigkeit die folgende Funktionalität:

1. Automatische Konfiguration: Spring Boot konfiguriert automatisch die Verbindung mit der MongoDB-Datenbank, einschließlich der Erstellung eines Mongo-Clients, der Festlegung von Verbindungseigenschaften usw.
2. MongoTemplate: Konfiguriert automatisch MongoTemplate, eine Kernklasse zum Ausführen verschiedener Datenbankoperationen. Durch die Verwendung von MongoTemplate können Sie Dokumente problemlos einfügen, aktualisieren, abfragen und andere Vorgänge durchführen.
3. MongoRepository: MongoRepository wird automatisch konfiguriert. Hierbei handelt es sich um eine annotationsbasierte Schnittstelle zum Definieren von Interaktionen mit MongoDB-Datenbanken. Durch die Übernahme von MongoRepository können Sie bequem Abfragen, Aggregationsvorgänge usw. durchführen.
4. Vorgänge mit Vorlagen: Durch die Verwendung von MongoTemplate und MongoRepository können Sie Datenbankvorgänge auf Vorlagenbasis ausführen, wodurch der Code prägnanter und lesbarer wird.

Kurz gesagt: Durch das Hinzufügen dieser Abhängigkeit können Sie Spring Boot problemlos für die Integration in MongoDB verwenden, ohne den Datenbankbetriebscode auf niedriger Ebene manuell konfigurieren und schreiben zu müssen.

Andere Abhängigkeiten: (Wenn Sie ein einfaches Spring-Boot-Projekt direkt starten möchten, können Sie es wegnehmen)

<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. Die Datei application.yml wird zum Schreiben der Verbindungs-MongoDB-Konfigurationsdatei verwendet

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

Beachten:

        Wenn kein verbundener Benutzer vorhanden ist, können einige Konfigurationsdateien entsprechend der tatsächlichen Situation gelöscht werden.

        Im Vergleich zu MySQL besteht der Unterschied darin, dass ein Benutzer mehrere Datenbanken in MySQL verwalten kann, jede Datenbank von MongoDB jedoch einen unabhängigen Verwaltungsbenutzer benötigt und beim Herstellen der Verbindung das entsprechende Benutzerkennwort eingegeben werden muss.

3. Schreiben über Entitätsklassen (Achtung, wenn es Löcher gibt!!)

Haupthinweise:

         1. @Document entspricht dem Dokument in MongoDB, der grundlegendsten Dateneinheit in der Datenbank. Es besteht aus Schlüssel-Wert-Paaren, ähnlich dem JSON-Format, und kann verschiedene Felder speichern. Der Wert des Feldes kann enthalten andere Dokumente, Arrays und Dokument-Arrays.

        2. @Id (Primärschlüssel): Wird verwendet, um den Wert der Mitgliedsvariablen dem Wert der _id des Dokuments zuzuordnen. In meinem vorherigen Dokument können Sie sehen, wie Sie _id einen Wert zuweisen.

        3. @Index (Index): Ein Index ist eine spezielle Datenstruktur, die in einer Datensammlung gespeichert wird, die leicht zu durchlaufen und zu lesen ist und die Daten im Datendokument sortieren kann. Durch die Indizierung kann die Effizienz der Dokumentabfrage erheblich verbessert werden.

        4. @Field (Feld): Das Feld im Dokument, ähnlich dem Spaltenkonzept in MySQL.

        5. @Aggregation (Aggregation): Aggregation wird hauptsächlich für die Datenverarbeitung verwendet, z. B. statistischer Durchschnitt, Summation usw.

Beispiel:

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

Dokument im Beispiel ist der Name der Sammlung

Beachten:

        Stellen Sie sicher, dass Sie die Annotation @Field("name") schreiben, um sie dem Namen des Feldes zuzuordnen, da sonst alle Ergebnisse leer sind! ! !

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

Dies ist der gesamte zugrunde liegende Paketcode. Hier ist der Code direkt! Wenn Sie Zweifel haben, diskutieren Sie diese bitte im Kommentarbereich 

Controller-Kontrollschicht

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


}

Service-Layer-Schnittstelle

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

Service-Layer-Implementierungsklasse

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


}

Dao-Ebene (Ich habe Mapper geschrieben, weil ich daran gewöhnt bin)

Kernpunkt: Die MongoRepository-Klasse erben! ! !

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> {
    
}