Protokolování dotazů MongoDB pomocí Spring Boot

1. Přehled

Při používání Spring Data MongoDB se možná budeme muset přihlásit na vyšší úroveň, než je výchozí. Obvykle můžeme potřebovat vidět například některé další informace, jako jsou provádění příkazů nebo parametry dotazu.

V tomto krátkém tutoriálu uvidíme, jak upravit úroveň protokolování MongoDB pro dotazy.

2. Nakonfigurujte protokolování dotazů MongoDB

Podpora MongoDB nabízí MongoOperations rozhraní nebo jeho primární MongoTemplate implementace pro přístup k datům, takže vše, co potřebujeme, je nakonfigurovat úroveň ladění pro MongoTemplate třída.

Jako každá Spring nebo Java aplikace můžeme použít knihovnu loggeru a definovat úroveň protokolování pro MongoTemplate .

Obvykle můžeme do našeho konfiguračního souboru zapsat něco jako:

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

Pokud však spouštíme aplikaci Spring Boot , můžeme to nakonfigurovat v našich application.properties soubor:

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

Stejně tak můžeme použít YAML syntaxe:

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

3. Testovací třída pro protokolování

Nejprve vytvořte Knihu třída:

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

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

    // getters and setters
}

Chceme vytvořit jednoduchou testovací třídu a zkontrolovat protokoly.

Abychom to demonstrovali, používáme Embedded MongoDB. Pro jistotu nejprve zkontrolujme naše závislosti :

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

Nakonec definujme naši testovací třídu pomocí 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. Zaznamenat vzorky

V této části definujeme několik jednoduchých testovacích případů a ukážeme relativní protokoly pro testování nejběžnějších scénářů, jako je hledání, vkládání, aktualizace nebo agregace dokumentu s.

4.1. Vložit

Nejprve začněme vložením jednoho dokumentu :

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

mongoTemplate.insert(book);

Protokoly ukazují, do které kolekce vkládáme. Při hledání dokumentu , ID se také zaprotokoluje:

[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. Aktualizovat

Stejně tak při aktualizaci dokumentu :

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

Můžeme vidět aktuální aktualizovaný dokument pole v protokolech:

[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. Dávkové vložení

Přidejme příklad pro dávkové vkládání:

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

Vidíme počet vložených Dokumentů s v protokolech:

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

4.4. Odebrat

Přidejme také příklad odstranění:

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

mongoTemplate.insert(book);

mongoTemplate.remove(book);

V protokolech vidíme, v tomto případě, ID smazaného Dokumentu :

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

4.5. Agregace

Podívejme se na příklad Agregace . V tomto případě musíme definovat třídu výsledků. Například budeme agregovat podle jména autora:

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Dále definujeme testovací případ pro seskupování:

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

V protokolech můžeme vidět, podle jakého pole jsme agregovali a jaký druh agregačního kanálu:

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