Using the MongoDB Client
MongoDB is a well known NoSQL Database that is widely used.
In this guide, we see how you can get your REST services to use the MongoDB database.
Pré-requisitos
Para concluir este guia, você precisa:
-
Cerca de 15 minutos
-
Um IDE
-
JDK 17+ installed with
JAVA_HOME
configured appropriately -
Apache Maven 3.9.8
-
Opcionalmente, o Quarkus CLI se você quiser usá-lo
-
Opcionalmente, Mandrel ou GraalVM instalado e configurado apropriadamente se você quiser criar um executável nativo (ou Docker se você usar uma compilação de contêiner nativo)
-
MongoDB installed or Docker installed
Arquitetura
The application built in this guide is quite simple: the user can add elements in a list using a form and the list is updated.
All the information between the browser and the server is formatted as JSON.
The elements are stored in MongoDB.
Solução
Recomendamos que siga as instruções nas seções seguintes e crie a aplicação passo a passo. No entanto, você pode ir diretamente para o exemplo completo.
Clone o repositório Git: git clone https://github.com/quarkusio/quarkus-quickstarts.git
, ou baixe um arquivo.
The solution is located in the mongodb-quickstart
directory.
Criar o projeto Maven
Primeiro, precisamos de um novo projeto. Crie um novo projeto com o seguinte comando:
Para usuários do Windows:
-
Se estiver usando cmd, (não use barra invertida '\' e coloque tudo na mesma linha)
-
Se estiver usando o Powershell, envolva os parâmetros '-D' entre aspas duplas, por exemplo, '"-DprojectArtifactId=mongodb-quickstart"'
This command generates a Maven structure importing the Quarkus REST (formerly RESTEasy Reactive) Jackson and MongoDB Client extensions.
After this, the quarkus-mongodb-client
extension has been added to your build file.
If you already have your Quarkus project configured, you can add the mongodb-client
extension
to your project by running the following command in your project base directory:
quarkus extension add mongodb-client
./mvnw quarkus:add-extension -Dextensions='mongodb-client'
./gradlew addExtension --extensions='mongodb-client'
Isso adicionará o seguinte ao seu arquivo pom.xml
:
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-mongodb-client</artifactId>
</dependency>
implementation("io.quarkus:quarkus-mongodb-client")
Creating your first JSON REST service
In this example, we will create an application to manage a list of fruits.
First, let’s create the Fruit
bean as follows:
package org.acme.mongodb;
import java.util.Objects;
public class Fruit {
private String name;
private String description;
private String id;
public Fruit() {
}
public Fruit(String name, String description) {
this.name = name;
this.description = description;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
@Override
public boolean equals(Object obj) {
if (!(obj instanceof Fruit)) {
return false;
}
Fruit other = (Fruit) obj;
return Objects.equals(other.name, this.name);
}
@Override
public int hashCode() {
return Objects.hash(this.name);
}
public void setId(String id) {
this.id = id;
}
public String getId() {
return id;
}
}
Nothing fancy. One important thing to note is that having a default constructor is required by the JSON serialization layer.
Now create a org.acme.mongodb.FruitService
that will be the business layer of our application and store/load the fruits from the mongoDB database.
package org.acme.mongodb;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import org.bson.Document;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.ArrayList;
import java.util.List;
@ApplicationScoped
public class FruitService {
@Inject MongoClient mongoClient;
public List<Fruit> list(){
List<Fruit> list = new ArrayList<>();
MongoCursor<Document> cursor = getCollection().find().iterator();
try {
while (cursor.hasNext()) {
Document document = cursor.next();
Fruit fruit = new Fruit();
fruit.setName(document.getString("name"));
fruit.setDescription(document.getString("description"));
list.add(fruit);
}
} finally {
cursor.close();
}
return list;
}
public void add(Fruit fruit){
Document document = new Document()
.append("name", fruit.getName())
.append("description", fruit.getDescription());
getCollection().insertOne(document);
}
private MongoCollection getCollection(){
return mongoClient.getDatabase("fruit").getCollection("fruit");
}
}
Now, create the org.acme.mongodb.FruitResource
class as follows:
@Path("/fruits")
public class FruitResource {
@Inject FruitService fruitService;
@GET
public List<Fruit> list() {
return fruitService.list();
}
@POST
public List<Fruit> add(Fruit fruit) {
fruitService.add(fruit);
return list();
}
}
The implementation is pretty straightforward, and you just need to define your endpoints using the Jakarta REST annotations and use the FruitService
to list/add new fruits.
Configuring the MongoDB database
The main property to configure is the URL to access to MongoDB. Almost all configuration can be included in the connection URI, so we advise you to do so. You can find more information in the MongoDB documentation: https://docs.mongodb.com/manual/reference/connection-string/
A sample configuration should look like this:
# configure the mongoDB client for a replica set of two nodes
quarkus.mongodb.connection-string = mongodb://mongo1:27017,mongo2:27017
In this example, we are using a single instance running on localhost:
# configure the mongoDB client for a single instance on localhost
quarkus.mongodb.connection-string = mongodb://localhost:27017
If you need more configuration properties, there is a full list at the end of this guide.
By default, Quarkus will restrict the use of JNDI within an application, as a precaution to try and mitigate any future vulnerabilities similar to Log4Shell.
Because the mongo+srv protocol often used to connect to MongoDB requires JNDI, this protection is automatically disabled when using the MongoDB client extension.
|
Use the MongoDB Dev Services
See MongoDB Dev Services.
Multiple MongoDB Clients
MongoDB allows you to configure multiple clients. Using several clients works the same way as having a single client.
quarkus.mongodb.connection-string = mongodb://login:pass@mongo1:27017/database
quarkus.mongodb.users.connection-string = mongodb://mongo2:27017/userdb
quarkus.mongodb.inventory.connection-string = mongodb://mongo3:27017/invdb,mongo4:27017/invdb
Notice there’s an extra bit in the key (the users
and inventory
segments).
The syntax is as follows: quarkus.mongodb.[optional name.][mongo connection property]
.
If the name is omitted, it configures the default client.
The use of multiple MongoDB clients enables multi-tenancy for MongoDB by allowing to connect to multiple MongoDB clusters. |
Named Mongo client Injection
When using multiple clients, each MongoClient
, you can select the client to inject using the io.quarkus.mongodb.MongoClientName
qualifier.
Using the above properties to configure three different clients, you can also inject each one as follows:
@Inject
MongoClient defaultMongoClient;
@Inject
@MongoClientName("users")
MongoClient mongoClient1;
@Inject
@MongoClientName("inventory")
ReactiveMongoClient mongoClient2;
Running a MongoDB Database
As by default, MongoClient
is configured to access a local MongoDB database on port 27017 (the default MongoDB port), if you have a local running database on this port, there is nothing more to do before being able to test it!
If you want to use Docker to run a MongoDB database, you can use the following command to launch one:
docker run -ti --rm -p 27017:27017 mongo:4.4
If you use Dev Services, launching the container manually is not necessary. |
Creating a frontend
Now let’s add a simple web page to interact with our FruitResource
.
Quarkus automatically serves static resources located under the META-INF/resources
directory.
In the src/main/resources/META-INF/resources
directory, add a fruits.html
file with the content from this fruits.html file in it.
You can now interact with your REST service:
-
start Quarkus with:
CLIquarkus dev
Maven./mvnw quarkus:dev
Gradle./gradlew --console=plain quarkusDev
-
open a browser to
http://localhost:8080/fruits.html
-
add new fruits to the list via the form
Reactive MongoDB Client
A reactive MongoDB Client is included in Quarkus. Using it is as easy as using the classic MongoDB Client. You can rewrite the previous example to use it like the following.
Mutiny
The MongoDB reactive client uses Mutiny reactive types. If you are not familiar with Mutiny, check Mutiny - an intuitive reactive programming library. |
package org.acme.mongodb;
import io.quarkus.mongodb.reactive.ReactiveMongoClient;
import io.quarkus.mongodb.reactive.ReactiveMongoCollection;
import io.smallrye.mutiny.Uni;
import org.bson.Document;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.List;
@ApplicationScoped
public class ReactiveFruitService {
@Inject
ReactiveMongoClient mongoClient;
public Uni<List<Fruit>> list() {
return getCollection().find()
.map(doc -> {
Fruit fruit = new Fruit();
fruit.setName(doc.getString("name"));
fruit.setDescription(doc.getString("description"));
return fruit;
}).collect().asList();
}
public Uni<Void> add(Fruit fruit) {
Document document = new Document()
.append("name", fruit.getName())
.append("description", fruit.getDescription());
return getCollection().insertOne(document)
.onItem().ignore().andContinueWithNull();
}
private ReactiveMongoCollection<Document> getCollection() {
return mongoClient.getDatabase("fruit").getCollection("fruit");
}
}
package org.acme.mongodb;
import io.smallrye.mutiny.Uni;
import java.util.List;
import jakarta.inject.Inject;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.Consumes;
import jakarta.ws.rs.GET;
import jakarta.ws.rs.POST;
import jakarta.ws.rs.core.MediaType;
@Path("/reactive_fruits")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class ReactiveFruitResource {
@Inject
ReactiveFruitService fruitService;
@GET
public Uni<List<Fruit>> list() {
return fruitService.list();
}
@POST
public Uni<List<Fruit>> add(Fruit fruit) {
return fruitService.add(fruit)
.onItem().ignore().andSwitchTo(this::list);
}
}
Simplifying MongoDB Client usage using BSON codec
By using a Bson Codec
, the MongoDB Client will take care of the transformation of your domain object to/from a MongoDB Document
automatically.
First you need to create a Bson Codec
that will tell Bson how to transform your entity to/from a MongoDB Document
.
Here we use a CollectibleCodec
as our object is retrievable from the database (it has a MongoDB identifier), if not we would have used a Codec
instead.
More information in the codec documentation: https://www.mongodb.com/docs/drivers/java/sync/current/fundamentals/data-formats/codecs/.
package org.acme.mongodb.codec;
import com.mongodb.MongoClientSettings;
import org.acme.mongodb.Fruit;
import org.bson.Document;
import org.bson.BsonWriter;
import org.bson.BsonValue;
import org.bson.BsonReader;
import org.bson.BsonString;
import org.bson.codecs.Codec;
import org.bson.codecs.CollectibleCodec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;
import java.util.UUID;
public class FruitCodec implements CollectibleCodec<Fruit> {
private final Codec<Document> documentCodec;
public FruitCodec() {
this.documentCodec = MongoClientSettings.getDefaultCodecRegistry().get(Document.class);
}
@Override
public void encode(BsonWriter writer, Fruit fruit, EncoderContext encoderContext) {
Document doc = new Document();
doc.put("name", fruit.getName());
doc.put("description", fruit.getDescription());
documentCodec.encode(writer, doc, encoderContext);
}
@Override
public Class<Fruit> getEncoderClass() {
return Fruit.class;
}
@Override
public Fruit generateIdIfAbsentFromDocument(Fruit document) {
if (!documentHasId(document)) {
document.setId(UUID.randomUUID().toString());
}
return document;
}
@Override
public boolean documentHasId(Fruit document) {
return document.getId() != null;
}
@Override
public BsonValue getDocumentId(Fruit document) {
return new BsonString(document.getId());
}
@Override
public Fruit decode(BsonReader reader, DecoderContext decoderContext) {
Document document = documentCodec.decode(reader, decoderContext);
Fruit fruit = new Fruit();
if (document.getString("id") != null) {
fruit.setId(document.getString("id"));
}
fruit.setName(document.getString("name"));
fruit.setDescription(document.getString("description"));
return fruit;
}
}
Then you need to create a CodecProvider
to link this Codec
to the Fruit
class.
package org.acme.mongodb.codec;
import org.acme.mongodb.Fruit;
import org.bson.codecs.Codec;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;
public class FruitCodecProvider implements CodecProvider {
@Override
public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
if (clazz.equals(Fruit.class)) {
return (Codec<T>) new FruitCodec();
}
return null;
}
}
Quarkus takes care of registering the CodecProvider
for you as a CDI bean of @Singleton
scope.
Finally, when getting the MongoCollection
from the database you can use directly the Fruit
class instead of the Document
one, the codec will automatically map the Document
to/from your Fruit
class.
Here is an example of using a MongoCollection
with the FruitCodec
.
package org.acme.mongodb;
import com.mongodb.client.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import java.util.ArrayList;
import java.util.List;
@ApplicationScoped
public class CodecFruitService {
@Inject MongoClient mongoClient;
public List<Fruit> list(){
List<Fruit> list = new ArrayList<>();
MongoCursor<Fruit> cursor = getCollection().find().iterator();
try {
while (cursor.hasNext()) {
list.add(cursor.next());
}
} finally {
cursor.close();
}
return list;
}
public void add(Fruit fruit){
getCollection().insertOne(fruit);
}
private MongoCollection<Fruit> getCollection(){
return mongoClient.getDatabase("fruit").getCollection("fruit", Fruit.class);
}
}
The POJO Codec
The POJO Codec provides a set of annotations that enable the customization of the way a POJO is mapped to a MongoDB collection and this codec is initialized automatically by Quarkus
One of these annotations is the @BsonDiscriminator
annotation that allows to storage multiple Java types in a single MongoDB collection by adding
a discriminator field inside the document. It can be useful when working with abstract types or interfaces.
Quarkus will automatically register all the classes annotated with @BsonDiscriminator
with the POJO codec.
The POJO Codec have enhanced generic support via PropertyCodecProvider
,
Quarkus will automatically register any PropertyCodecProvider
with the POJO Codec (these classes are automatically made CDI beans of @Singleton
scope).
When building native executables and using generic types, you might need to register the type arguments for reflection.
Simplifying MongoDB with Panache
The MongoDB with Panache extension facilitates the usage of MongoDB by providing active record style entities (and repositories) like you have in Hibernate ORM with Panache and focuses on making your entities trivial and fun to write in Quarkus.
Schema migration with Liquibase
The Liquibase MongoDB extension facilitates the initialization of a MongoDB database including indices and initial data. It implements the same schema migration facilities that Liquibase offers for SQL databases.
Connection Health Check
If you are using the quarkus-smallrye-health
extension, quarkus-mongodb-client
will automatically add a readiness health check
to validate the connection to the cluster.
So when you access the /q/health/ready
endpoint of your application you will have information about the connection validation status.
This behavior can be disabled by setting the quarkus.mongodb.health.enabled
property to false
in your application.properties
.
Metrics
If you are using the quarkus-micrometer
or quarkus-smallrye-metrics
extension, quarkus-mongodb-client
can provide metrics about the connection pools.
This behavior must first be enabled by setting the quarkus.mongodb.metrics.enabled
property to true
in your application.properties
.
So when you access the /q/metrics
endpoint of your application you will have information about the connection pool status.
When using SmallRye Metrics, connection pool metrics will be available under the vendor
scope.
Tracing
To use tracing with MongoDB, you need to add the quarkus-opentelemetry
extension to your project.
Even with all the tracing infrastructure in place the mongodb tracing is not enabled by default, and you need to enable it by setting this property:
# enable tracing
quarkus.mongodb.tracing.enabled=true
Testing helpers
Dev Services for MongoDB is your best option to start a MongoDB database for your unit tests.
But if you can’t use it, you can start a MongoDB database using one of the two QuarkusTestResourceLifecycleManager
that Quarkus provides.
They rely on Flapdoodle embedded MongoDB.
-
io.quarkus.test.mongodb.MongoTestResource
will start a single instance on port 27017. -
io.quarkus.test.mongodb.MongoReplicaSetTestResource
will start a replicaset with two instances, one on port 27017 and the other on port 27018.
To use them, you need to add the io.quarkus:quarkus-test-mongodb
dependency to your pom.xml.
For more information about the usage of a QuarkusTestResourceLifecycleManager
please read Quarkus test resource.
To set the desired port MongoDB will listen to when it is launched, the following code should be used:
To set the desired MongoDB version that will be launched, the following code should be used:
The string value used can be any of one of the |
The legacy client
We don’t include the legacy MongoDB client by default. It contains the now retired MongoDB Java API (DB, DBCollection,… )
and the com.mongodb.MongoClient
that is now superseded by com.mongodb.client.MongoClient
.
If you want to use the legacy API, you need to add the following dependency to your build file:
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-legacy</artifactId>
</dependency>
implementation("org.mongodb:mongodb-driver-legacy")
Building a native executable
You can use the MongoDB client in a native executable.
If you want to use SSL/TLS encryption, you need to add these properties in your application.properties
:
quarkus.mongodb.tls=true
quarkus.mongodb.tls-insecure=true # only if TLS certificate cannot be validated
You can then build a native executable with the usual command:
quarkus build --native
./mvnw install -Dnative
./gradlew build -Dquarkus.native.enabled=true
Running it is as simple as executing ./target/mongodb-quickstart-1.0.0-SNAPSHOT-runner
.
You can then point your browser to http://localhost:8080/fruits.html
and use your application.
Currently, Quarkus doesn’t support Client-Side Field Level Encryption in native mode. |
If you encounter the following error when running your application in native mode: |
Using mongo+srv:// urls
mongo+srv://
urls are supported out of the box in JVM mode.
However, in native, the default DNS resolver, provided by the MongoDB client, uses JNDI and does not work in native mode.
If you need to use mongo+srv://
in native mode, you can configure an alternative DNS resolver.
This feature is experimental and may introduce a difference between JVM applications and native applications.
To enable the alternative DNS resolver, use:
quarkus.mongodb.native.dns.use-vertx-dns-resolver=true
As indicated in the property name, it uses Vert.x to retrieve the DNS records.
By default, it tries to read the first nameserver
from /etc/resolv.conf
, if this file exists.
You can also configure your DNS server:
quarkus.mongodb.native.dns.use-vertx-dns-resolver=true
quarkus.mongodb.native.dns.server-host=10.0.0.1
quarkus.mongodb.native.dns.server-port=53 # 53 is the default port
Also, you can configure the lookup timeout using:
quarkus.mongodb.native.dns.use-vertx-dns-resolver=true
quarkus.mongodb.native.dns.lookup-timeout=10s # the default is 5s
Customize the Mongo client configuration programmatically
If you need to customize the Mongo client configuration programmatically, you need to implement the io.quarkus.mongodb.runtime.MongoClientCustomizer
interface and expose it as a CDI application scoped bean:
@ApplicationScoped
public class MyCustomizer implements MongoClientCustomizer {
@Override
public MongoClientSettings.Builder customize(MongoClientSettings.Builder builder) {
return builder.applicationName("my-app");
}
}
The bean can customize a specific client using the @MongoClientName
qualifier to indicate the client name.
When there is no qualifier, it customizes the default client.
At most one customizer can be used per client.
If multiple customizers targeting the same client are detected, an exception is thrown at build time.
This feature can be used to configure client-side field level encryption (CSFLE). Follows the instructions from the Mongo web site to configure CSFLE:
@ApplicationScoped
public class MyCustomizer implements MongoClientCustomizer {
@Override
public MongoClientSettings.Builder customize(MongoClientSettings.Builder builder) {
Map<String, Map<String, Object>> kmsProviders = getKmsProviders();
String dek = getDataEncryptionKey();
Map<String, BsonDocument> schema = getSchema(dek);
Map<String, Object> extraOptions = new HashMap<>();
extraOptions.put("cryptSharedLibPath", "<path to crypt shared library>");
return builder.autoEncryptionSettings(AutoEncryptionSettings.builder()
.keyVaultNamespace(KEY_VAULT_NAMESPACE)
.kmsProviders(kmsProviders)
.schemaMap(schemaMap)
.extraOptions(extraOptions)
.build());
}
}
Client-side field level encryption, and feature relying on Mongo Crypt in general, are not supported in native mode. |
Referência de configuração
Propriedade de Configuração Fixa no Momento da Compilação - Todas as outras propriedades de configuração podem ser sobrepostas em tempo de execução.
Configuration property |
Tipo |
Padrão |
---|---|---|
boolean |
|
|
boolean |
|
|
boolean |
|
|
boolean |
|
|
Configures the connection string. The format is:
An alternative format, using the
Environment variable: Show more |
string |
|
list of string |
|
|
string |
||
string |
||
int |
||
int |
||
boolean |
|
|
boolean |
|
|
string |
||
When choosing among multiple MongoDB servers to send a request, the driver will only send that request to a server whose ping time is less than or equal to the server with the fastest ping time plus the local threshold. Environment variable: Show more |
||
string |
||
string |
||
string |
|
|
|
||
string |
||
int |
|
|
|
||
boolean |
|
|
Configures the connection string. The format is:
An alternative format, using the
Environment variable: Show more |
string |
|
list of string |
|
|
string |
||
string |
||
int |
||
int |
||
boolean |
|
|
boolean |
|
|
string |
||
When choosing among multiple MongoDB servers to send a request, the driver will only send that request to a server whose ping time is less than or equal to the server with the fastest ping time plus the local threshold. Environment variable: Show more |
||
string |
||
string |
||
string |
|
|
|
||
Tipo |
Padrão |
|
If DevServices has been explicitly enabled or disabled. DevServices is generally enabled by default, unless there is an existing configuration present. When DevServices is enabled Quarkus will attempt to automatically configure and start a database when running in Dev or Test mode. Environment variable: Show more |
boolean |
|
string |
||
int |
||
Map<String,String> |
||
Map<String,String> |
||
Indicates if the MongoDB server managed by Quarkus Dev Services is shared. When shared, Quarkus looks for running containers using label-based service discovery. If a matching container is found, it is used, and so a second one is not started. Otherwise, Dev Services for MongoDB starts a new container. The discovery uses the Container sharing is only used in dev mode. Environment variable: Show more |
boolean |
|
The value of the Environment variable: Show more |
string |
|
Tipo |
Padrão |
|
Configures the safety. If set to Environment variable: Show more |
boolean |
|
Configures the journal writing aspect. If set to Environment variable: Show more |
boolean |
|
string |
||
boolean |
|
|
Tipo |
Padrão |
|
string |
||
string |
||
Configures the authentication mechanism to use if a credential was supplied. The default is unspecified, in which case the client will pick the most secure mechanism available based on the sever version. For the GSSAPI and MONGODB-X509 mechanisms, no password is accepted, only the username. Supported values: null or Environment variable: Show more |
string |
|
Configures the source of the authentication credentials. This is typically the database where the credentials have been created. The value defaults to the database specified in the path portion of the connection string or in the 'database' configuration property. If the database is specified in neither place, the default value is Environment variable: Show more |
string |
|
Map<String,String> |
||
string |
||
The credentials provider bean name. This is a bean name (as in For Vault, the credentials provider bean name is Environment variable: Show more |
string |
|
Tipo |
Padrão |
|
Configures the safety. If set to Environment variable: Show more |
boolean |
|
Configures the journal writing aspect. If set to Environment variable: Show more |
boolean |
|
string |
||
boolean |
|
|
Tipo |
Padrão |
|
string |
||
string |
||
Configures the authentication mechanism to use if a credential was supplied. The default is unspecified, in which case the client will pick the most secure mechanism available based on the sever version. For the GSSAPI and MONGODB-X509 mechanisms, no password is accepted, only the username. Supported values: null or Environment variable: Show more |
string |
|
Configures the source of the authentication credentials. This is typically the database where the credentials have been created. The value defaults to the database specified in the path portion of the connection string or in the 'database' configuration property. If the database is specified in neither place, the default value is Environment variable: Show more |
string |
|
Map<String,String> |
||
string |
||
The credentials provider bean name. This is a bean name (as in For Vault, the credentials provider bean name is Environment variable: Show more |
string |
About the Duration format
To write duration values, use the standard Você também pode usar um formato simplificado, começando com um número:
Em outros casos, o formato simplificado é traduzido para o formato 'java.time.Duration' para análise:
|