Logga MongoDB-frågor med Spring Boot

1. Översikt

När vi använder Spring Data MongoDB kan vi behöva logga till en högre nivå än standardnivån. Vanligtvis kan vi behöva se, till exempel, viss ytterligare information, såsom körningar av satser eller frågeparametrar.

I den här korta handledningen kommer vi att se hur du ändrar MongoDB-loggningsnivån för frågor.

2. Konfigurera MongoDB Queries Logging

MongoDB Support erbjuder MongoOperations gränssnittet eller dess primära MongoTemplate implementering för att komma åt data, så allt vi behöver är att konfigurera en felsökningsnivå för MongoTemplate klass.

Som alla Spring- eller Java-applikationer kan vi använda ett loggbibliotek och definiera en loggningsnivå för MongoTemplate .

Vanligtvis kan vi skriva i vår konfigurationsfil något i stil med:

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

Men om vi kör en Spring Boot-applikation , vi kan konfigurera detta i våra application.properties fil:

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

På samma sätt kan vi använda YAML syntax:

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

3. Testklass för loggning

Låt oss först skapa en bok klass:

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

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

    // getters and setters
}

Vi vill skapa en enkel testklass och kolla in loggar.

För att demonstrera detta använder vi Embedded MongoDB. För att vara säker, låt oss kontrollera våra beroenden först :

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

Slutligen, låt oss definiera vår testklass med 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. Logga prover

I det här avsnittet kommer vi att definiera några enkla testfall och visa de relativa loggarna för att testa de vanligaste scenarierna, som att hitta, infoga, uppdatera eller aggregera Dokument s.

4.1. Infoga

Låt oss först börja med att infoga ett enda Dokument :

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

mongoTemplate.insert(book);

Loggarna visar i vilken samling vi infogar. När du hittar ett Dokument , id loggas också:

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

Likaså när du uppdaterar ett Dokument :

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

Vi kan se det faktiska uppdaterade dokumentet fältet i loggarna:

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

Låt oss lägga till ett exempel för en batchinsättning:

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

Vi kan se antalet infogade Dokument s i loggarna:

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

4.4. Ta bort

Låt oss också lägga till ett exempel för att ta bort:

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

mongoTemplate.insert(book);

mongoTemplate.remove(book);

Vi kan se i loggarna, i det här fallet, ID:t för det borttagna dokumentet :

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

4.5. Aggregation

Låt oss se ett exempel för Aggregation . I det här fallet måste vi definiera en resultatklass. Till exempel kommer vi att sammanställa efter författarens namn:

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Låt oss sedan definiera ett testfall för gruppering:

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

Vi kan se i loggarna efter vilket fält vi har aggregerat och vilken typ av aggregeringspipeline:

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