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=DEBUGEbenso 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: book4.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 items4.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
