Logning af MongoDB-forespørgsler med Spring Boot

1. Oversigt

Når du bruger Spring Data MongoDB, skal vi muligvis logge til et højere niveau end standardniveauet. Typisk kan vi være nødt til at se, for eksempel nogle yderligere oplysninger, såsom udførelse af sætninger eller forespørgselsparametre.

I denne korte vejledning vil vi se, hvordan man ændrer MongoDB-logningsniveauet for forespørgsler.

2. Konfigurer MongoDB Queries Logging

MongoDB Support tilbyder MongoOperations grænseflade eller dens primære MongoTemplate implementering for at få adgang til data, så alt hvad vi behøver er at konfigurere et fejlretningsniveau for MongoTemplate klasse.

Som enhver Spring- eller Java-applikation kan vi bruge et loggerbibliotek og definere et logningsniveau for MongoTemplate .

Typisk kan vi skrive i vores konfigurationsfil noget som:

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

Men hvis vi kører en Spring Boot-applikation , vi kan konfigurere dette i vores application.properties fil:

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

Ligeledes kan vi bruge YAML syntaks:

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

3. Testklasse til logning

Lad os først oprette en bog klasse:

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

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

    // getters and setters
}

Vi vil oprette en simpel testklasse og tjekke logs ud.

For at demonstrere dette bruger vi Embedded MongoDB. For at være sikker, lad os først tjekke vores afhængigheder :

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

Lad os endelig definere vores testklasse ved hjælp af 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. Logprøver

I dette afsnit vil vi definere nogle simple testcases og vise de relative logfiler for at teste de mest almindelige scenarier, såsom at finde, indsætte, opdatere eller aggregere Dokument s.

4.1. Indsæt

Lad os først starte med at indsætte et enkelt Dokument :

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

mongoTemplate.insert(book);

Logfilerne viser, hvilken samling vi indsætter. Når du finder et Dokument , id'et logges også:

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

Ligeledes ved opdatering af et 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 faktiske opdaterede Dokument felt i loggene:

[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-indsæt

Lad os tilføje et eksempel på en batch-indsættelse:

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 antallet af indsatte Dokument s i logfilerne:

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

4.4. Fjern

Lad os også tilføje et eksempel på fjernelse:

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

mongoTemplate.insert(book);

mongoTemplate.remove(book);

Vi kan se i logfilerne, i dette tilfælde, id'et for det slettede Dokument :

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

4.5. Aggregation

Lad os se et eksempel på Aggregation . I dette tilfælde skal vi definere en resultatklasse. For eksempel samler vi efter forfatternavnet:

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Lad os derefter definere en testcase for 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 logfilerne, efter hvilket felt vi har aggregeret, og hvilken slags aggregeringspipeline:

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