MongoDB
 sql >> Datenbank >  >> NoSQL >> MongoDB

Protokollieren von MongoDB-Abfragen mit Spring Boot

1. Übersicht

Bei Verwendung von Spring Data MongoDB müssen wir uns möglicherweise auf einer höheren Ebene als der Standardebene anmelden. Typischerweise müssen wir zum Beispiel einige zusätzliche Informationen wie Anweisungsausführungen oder Abfrageparameter sehen.

In diesem kurzen Tutorial erfahren Sie, wie Sie die MongoDB-Protokollierungsebene für Abfragen ändern.

2. Protokollierung von MongoDB-Abfragen konfigurieren

Der MongoDB-Support bietet die MongoOperations Schnittstelle oder ihr primäres MongoTemplate Implementierung für den Zugriff auf Daten, sodass wir lediglich eine Debug-Ebene für das MongoTemplate konfigurieren müssen Klasse.

Wie jede Spring- oder Java-Anwendung können wir eine Protokollierungsbibliothek verwenden und eine Protokollierungsebene für MongoTemplate definieren .

Normalerweise können wir in unsere Konfigurationsdatei etwas schreiben wie:

<logger name="org.springframework.data.mongodb.core.MongoTemplate" level="DEBUG" />

Allerdings, wenn wir eine Spring Boot-Anwendung ausführen , können wir dies in unseren application.properties konfigurieren Datei:

logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG

Ebenso können wir YAML verwenden Syntax:

logging:
  level:
    org:
      springframework:
        data:
          mongodb:
            core:
              MongoTemplate: DEBUG

3. Testklasse für Protokollierung

Lassen Sie uns zuerst ein Buch erstellen Klasse:

@Document(collection = "book")
public class Book {

    @MongoId
    private ObjectId id;
    private String bookName;
    private String authorName;

    // getters and setters
}

Wir möchten eine einfache Testklasse erstellen und Protokolle auschecken.

Um dies zu demonstrieren, verwenden wir Embedded MongoDB. Um sicherzugehen, überprüfen wir zuerst unsere Abhängigkeiten :

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
    <groupId>de.flapdoodle.embed</groupId>
    <artifactId>de.flapdoodle.embed.mongo</artifactId>
    <version>${embed.mongo.version}</version>
    <scope>test</scope>
</dependency>

Abschließend definieren wir unsere Testklasse mit Spring Boot Test:

@SpringBootTest
@TestPropertySource(properties = { "logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUG" })
public class LoggingUnitTest {

    private static final String CONNECTION_STRING = "mongodb://%s:%d";

    private MongodExecutable mongodExecutable;
    private MongoTemplate mongoTemplate;

    @AfterEach
    void clean() {
        mongodExecutable.stop();
    }

    @BeforeEach
    void setup() throws Exception {
        String ip = "localhost";
        int port = 27017;

        ImmutableMongodConfig mongodbConfig = MongodConfig.builder()
          .version(Version.Main.PRODUCTION)
          .net(new Net(ip, port, Network.localhostIsIPv6()))
          .build();

        MongodStarter starter = MongodStarter.getDefaultInstance();
        mongodExecutable = starter.prepare(mongodbConfig);
        mongodExecutable.start();
        mongoTemplate = new MongoTemplate(MongoClients.create(String.format(CONNECTION_STRING, ip, port)), "test");
    }
    // tests
}

4. Protokollbeispiele

In diesem Abschnitt definieren wir einige einfache Testfälle und zeigen die entsprechenden Protokolle, um die gängigsten Szenarien zu testen, z. B. Suchen, Einfügen, Aktualisieren oder Zusammenfassen von Dokument s.

4.1. Einfügen

Beginnen wir zunächst mit dem Einfügen eines einzelnen Dokuments :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

Die Protokolle zeigen, in welche Sammlung wir einfügen. Beim Finden eines Dokuments , die ID wird ebenfalls protokolliert:

[2022-03-20 17:42:47,093]-[main] DEBUG MongoTemplate - Inserting Document containing fields: [bookName, authorName, _class] in collection: book
...
[2022-03-20 17:42:47,144]-[main] DEBUG MongoTemplate - findOne using query: { "id" : { "$oid" : "623759871ff6275fe96a5ecb"}} fields: Document{{}} for class: class com.baeldung.mongodb.models.Book in collection: book
[2022-03-20 17:42:47,149]-[main] DEBUG MongoTemplate - findOne using query: { "_id" : { "$oid" : "623759871ff6275fe96a5ecb"}} fields: {} in db.collection: test.book

4.2. Aktualisieren

Ebenso beim Aktualisieren eines Dokuments :

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

String authorNameUpdate = "AuthorNameUpdate";

book.setAuthorName(authorNameUpdate);
mongoTemplate.updateFirst(query(where("bookName").is("Book")), update("authorName", authorNameUpdate), Book.class);

Wir können das aktuelle aktualisierte Dokument sehen Feld in den Protokollen:

[2022-03-20 17:48:31,759]-[main] DEBUG MongoTemplate - Calling update using query: { "bookName" : "Book"} and update: { "$set" : { "authorName" : "AuthorNameUpdate"}} in collection: book

4.3. Batch Insert

Lassen Sie uns ein Beispiel für eine Stapeleinfügung hinzufügen:

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

Book book1 = new Book();
book1.setBookName("Book1");
book1.setAuthorName("Author1");

mongoTemplate.insert(Arrays.asList(book, book1), Book.class);

Wir können die Anzahl der eingefügten Dokumente sehen s in den Protokollen:

[2022-03-20 17:52:00,564]-[main] DEBUG MongoTemplate - Inserting list of Documents containing 2 items

4.4. Entfernen

Fügen wir außerdem ein Beispiel zum Entfernen hinzu:

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

mongoTemplate.insert(book);

mongoTemplate.remove(book);

Wir können in den Protokollen in diesem Fall die ID des gelöschten Dokuments sehen :

[2022-03-20 17:56:42,151]-[main] DEBUG MongoTemplate - Remove using query: { "_id" : { "$oid" : "62375cca2a2cba4db774d8c1"}} in collection: book.

4.5. Aggregation

Sehen wir uns ein Beispiel für Aggregation an . In diesem Fall müssen wir eine Ergebnisklasse definieren. Beispielsweise aggregieren wir nach dem Autorennamen:

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Als Nächstes definieren wir einen Testfall für die Gruppierung:

Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");

Book book1 = new Book();
book1.setBookName("Book1");
book1.setAuthorName("Author");

Book book2 = new Book();
book2.setBookName("Book2");
book2.setAuthorName("Author");

mongoTemplate.insert(Arrays.asList(book, book1, book2), Book.class);

GroupOperation groupByAuthor = group("authorName")
  .count()
  .as("authCount");

Aggregation aggregation = newAggregation(groupByAuthor);

AggregationResults<GroupByAuthor> aggregationResults = mongoTemplate.aggregate(aggregation, "book", GroupByAuthor.class);

Wir können in den Protokollen sehen, nach welchem ​​Feld wir aggregiert haben und welche Art von Aggregationspipeline:

[2022-03-20 17:58:51,237]-[main] DEBUG MongoTemplate - Executing aggregation: [{ "$group" : { "_id" : "$authorName", "authCount" : { "$sum" : 1}}}] in collection book