1. Panoramica
Quando si utilizza Spring Data MongoDB, potrebbe essere necessario accedere a un livello superiore rispetto a quello predefinito. In genere, potrebbe essere necessario visualizzare, ad esempio, alcune informazioni aggiuntive come esecuzioni di istruzioni o parametri di query.
In questo breve tutorial, vedremo come modificare il livello di registrazione di MongoDB per le query.
2. Configura la registrazione delle query MongoDB
Il supporto MongoDB offre MongoOperations interfaccia o il suo MongoTemplate principale implementazione per accedere ai dati, quindi tutto ciò di cui abbiamo bisogno è configurare un livello di debug per MongoTemplate classe.
Come qualsiasi applicazione Spring o Java, possiamo utilizzare una libreria di logger e definire un livello di registrazione per MongoTemplate .
In genere, possiamo scrivere nel nostro file di configurazione qualcosa del tipo:
<logger name="org.springframework.data.mongodb.core.MongoTemplate" level="DEBUG" />Tuttavia, se stiamo eseguendo un'applicazione Spring Boot , possiamo configurarlo nel nostro application.properties file:
logging.level.org.springframework.data.mongodb.core.MongoTemplate=DEBUGAllo stesso modo, possiamo usare YAML sintassi:
logging:
level:
org:
springframework:
data:
mongodb:
core:
MongoTemplate: DEBUG
3. Classe di prova per la registrazione
Per prima cosa, creiamo un Libro classe:
@Document(collection = "book")
public class Book {
@MongoId
private ObjectId id;
private String bookName;
private String authorName;
// getters and setters
}Vogliamo creare una semplice classe di test e controllare i log.
Per dimostrarlo, utilizziamo Embedded MongoDB. Per essere sicuri, controlliamo prima le nostre dipendenze :
<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>Infine, definiamo la nostra classe di test utilizzando 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. Campioni di registro
In questa sezione definiremo alcuni semplici casi di test e mostreremo i relativi log per testare gli scenari più comuni, come la ricerca, l'inserimento, l'aggiornamento o l'aggregazione di Documento s.
4.1. Inserisci
Innanzitutto, iniziamo con l'inserimento di un singolo Documento :
Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");
mongoTemplate.insert(book);
I log mostrano in quale collezione stiamo inserendo. Quando si trova un Documento , viene registrato anche l'ID:
[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. Aggiorna
Allo stesso modo, quando si aggiorna un Documento :
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);
Possiamo vedere il Documento aggiornato effettivo campo nei log:
[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. Inserimento batch
Aggiungiamo un esempio per un inserimento batch:
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);Possiamo vedere il numero di Documenti inseriti s nei registri:
[2022-03-20 17:52:00,564]-[main] DEBUG MongoTemplate - Inserting list of Documents containing 2 items4.4. Rimuovi
Inoltre, aggiungiamo un esempio per rimuovere:
Book book = new Book();
book.setBookName("Book");
book.setAuthorName("Author");
mongoTemplate.insert(book);
mongoTemplate.remove(book);
Possiamo vedere nei log, in questo caso, l'id del Documento eliminato :
[2022-03-20 17:56:42,151]-[main] DEBUG MongoTemplate - Remove using query: { "_id" : { "$oid" : "62375cca2a2cba4db774d8c1"}} in collection: book.4.5. Aggregazione
Vediamo un esempio per Aggregazione . In questo caso, dobbiamo definire una classe di risultati. Ad esempio, aggregheremo in base al nome dell'autore:
public class GroupByAuthor {
@Id
private String authorName;
private int authCount;
// getters and setters
}Quindi, definiamo un test case per il raggruppamento:
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);Possiamo vedere nei log in base a quale campo abbiamo aggregato e che tipo di pipeline di aggregazione:
[2022-03-20 17:58:51,237]-[main] DEBUG MongoTemplate - Executing aggregation: [{ "$group" : { "_id" : "$authorName", "authCount" : { "$sum" : 1}}}] in collection book
