Rejestrowanie zapytań MongoDB za pomocą Spring Boot

1. Przegląd

Korzystając z Spring Data MongoDB, może być konieczne zalogowanie się na wyższy poziom niż domyślny. Zazwyczaj możemy potrzebować na przykład dodatkowych informacji, takich jak wykonanie instrukcji lub parametry zapytania.

W tym krótkim samouczku zobaczymy, jak zmodyfikować poziom rejestrowania MongoDB dla zapytań.

2. Skonfiguruj rejestrowanie zapytań MongoDB

Wsparcie MongoDB oferuje MongoOperations interfejs lub jego główny MongoTemplate implementacji dostępu do danych, więc wszystko, czego potrzebujemy, to skonfigurować poziom debugowania dla MongoTemplate klasa.

Jak każda aplikacja Spring lub Java, możemy użyć biblioteki rejestratora i zdefiniować poziom rejestrowania dla MongoTemplate .

Zazwyczaj możemy napisać w naszym pliku konfiguracyjnym coś takiego:

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

Jeśli jednak używamy aplikacji Spring Boot , możemy to skonfigurować w naszych application.properties plik:

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

Podobnie możemy użyć YAML składnia:

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

3. Testuj klasę logowania

Najpierw utwórzmy książkę klasa:

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

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

    // getters and setters
}

Chcemy stworzyć prostą klasę testową i sprawdzić logi.

Aby to zademonstrować, używamy Embedded MongoDB. Dla pewności najpierw sprawdźmy nasze zależności :

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

Na koniec zdefiniujmy naszą klasę testową za 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. Próbki dziennika

W tej sekcji zdefiniujemy kilka prostych przypadków testowych i pokażemy względne dzienniki w celu przetestowania najczęstszych scenariuszy, takich jak znajdowanie, wstawianie, aktualizowanie lub agregowanie Dokumentu s.

4.1. Wstaw

Najpierw zacznijmy od wstawienia pojedynczego Dokumentu :

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

mongoTemplate.insert(book);

Logi pokazują, do której kolekcji wstawiamy. Po znalezieniu Dokumentu , identyfikator jest również rejestrowany:

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

Podobnie podczas aktualizowania 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);

Widzimy aktualnie zaktualizowany Dokument pole w logach:

[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. Wstaw wsadowy

Dodajmy przykład wstawiania wsadowego:

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

Widzimy liczbę wstawionych dokumentów s w dziennikach:

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

4.4. Usuń

Dodajmy też przykład usuwania:

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

mongoTemplate.insert(book);

mongoTemplate.remove(book);

Widzimy w dziennikach, w tym przypadku, identyfikator usuniętego Dokumentu :

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

4.5. Agregacja

Zobaczmy przykład Agregacji . W takim przypadku musimy zdefiniować klasę wynikową. Na przykład agregujemy według nazwiska autora:

public class GroupByAuthor {

    @Id
    private String authorName;
    private int authCount;

    // getters and setters
}

Następnie zdefiniujmy przypadek testowy do grupowania:

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

Widzimy w logach, według którego pola zagregowaliśmy i jaki rodzaj potoku agregacji:

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