Menu Docs
Página inicial do Docs
/
Idiomas
/
Kotlin
/
Driver de Kotlin Sync
/
Construtores

Use construtores com classes de dados

Nesta página

Visão geral

Neste guia, você pode aprender como usar suas propriedades da Classe de Dados diretamente com as classes de construtor disponíveis no driver Kotlin Sync.

O driver Kotlin Sync implementa extensões que permitem fazer referência às propriedades da classe de dados ao usar métodos de construtor em vez de usar nomes de campo de string. Você pode estruturar seu código dessa forma para torná-lo mais seguro para o tipo e melhorar a interoperabilidade do Kotlin dos seus aplicativos.

A biblioteca de extensões também permite que você construa queries, atualize documentos e escreva outras declarações usando a notação infix. Para saber mais sobre esta notação, consulte Notação Infix na documentação de referência do Kotlin .

Observação

Esta página fornece um número limitado de exemplos de código para demonstrar essa funcionalidade. Para saber mais sobre como usar classes de construtores, consulte o guia Usar padrão de código de construtores.

Adicionar extensões Kotlin ao seu projeto

Para implementar esta funcionalidade, você deve adicionar a dependência do mongodb-driver-kotlin-extensions à sua lista de dependências.

Selecione a partir das seguintes abas para ver como adicionar a dependência de extensão ao seu projeto usando os gerenciadores de pacote Gradle e Maven:

Se você estiver usando o Gradle para gerenciar suas dependências, adicione o seguinte à sua build.gradle.kts lista de dependências do :

build.gradle.kts
implementation("org.mongodb:mongodb-driver-kotlin-extensions:5.3.0")

Se você estiver usando o Maven para gerenciar suas dependências, adicione o seguinte à sua pom.xml lista de dependências do :

pom.xml
<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver-kotlin-extensions</artifactId>
    <version>5.3.0</version>
</dependency>

Depois de instalar a dependência de extensões, você pode usar os métodos de extensão importando classes e métodos do caminho com.mongodb.kotlin.client.model. É possível misturar o uso desses métodos e dos métodos de construtor padrão no mesmo aplicação, conforme mostrado no exemplo de Agregados neste guia.

Exemplos de construtores

Esta seção contém exemplos que demonstram como usar as propriedades da classe de dados diretamente com os métodos da classe de construtor a partir do pacote de extensões .

Dica

Anotações da classe de dados

Quando você o construtor de extensões de classe de dados de métodos de classe, os métodos respeitam suas anotações de classe de dados dos pacotes bson-kotlin e bson-kotlinx . Para saber mais sobre anotações, consulte a seção Especificar conversão de componente usando anotações do guia Formato de dados do documento: classes de dados.

Dados de amostra

Os exemplos nesta seção usam documentos na coleção students que descrevem alunos em uma escola. Os documentos na coleção students são modelados pela seguinte classe de dados Kotlin :

data class Student(
    val name: String,
    val teachers: List<String>,
    val gradeAverage: Double
)

Filtros

Você pode usar ajudantes da classe de construtores Filters para consultar propriedades da classe de dados.

O código abaixo mostra maneiras diferentes de usar os métodos de extensão Filters para executar queries na classe de dados Student:

import com.mongodb.kotlin.client.model.Filters.eq
import com.mongodb.kotlin.client.model.Filters.all
val student = Student(
    "Sandra Nook",
    listOf("Alvarez", "Gruber"),
    85.7
)
// Equivalent equality queries
Student::name.eq(student.name)
eq(Student::name, student.name)
Student::name eq student.name // Infix notation
// Equivalent array queries
all(Student::teachers, student.teachers)
Student::teachers.all(student.teachers)
Student::teachers all student.teachers // Infix notation

Indexes

Você pode usar ajudantes da classe de construtores Indexes para criar índices nas propriedades da classe de dados.

O seguinte código mostra maneiras diferentes de usar os métodos de extensão Indexes para criar índices na classe de dados Student :

import com.mongodb.kotlin.client.model.Indexes.ascending
import com.mongodb.kotlin.client.model.Indexes.descending
val ascendingIdx = Indexes.ascending(Student::name)
val descendingIdx = Indexes.descending(Student::teachers)
val ascIdxName = collection.createIndex(ascendingIdx)
val descIdxName = collection.createIndex(descendingIdx)

Projeções

Você pode utilizar ajudantes da classe de construtores do Projections para criar projeções para propriedades de classe de dados.

O seguinte código mostra como usar os métodos de extensão Projections para criar uma projeção na classe de dados Student:

import com.mongodb.kotlin.client.model.Projections.excludeId
import com.mongodb.kotlin.client.model.Projections.fields
import com.mongodb.kotlin.client.model.Projections.include
val combinedProj = fields(
    include(Student::name, Student::gradeAverage),
    excludeId()
)
collection.find().projection(combinedProj)

Tipos

Você pode usar ajudantes da classe de construtores Sorts para classificar as propriedades da sua classe de dados.

O código a seguir mostra como usar os métodos de extensão Sorts para criar classificações diferentes na classe de dados Student :

import com.mongodb.client.model.Sorts.orderBy
import com.mongodb.kotlin.client.model.Sorts
val sort = orderBy(
    Sorts.descending(Student::gradeAverage),
    Sorts.ascending(Student::name)
)
collection.find().sort(sort)

Updates

Você pode usar ajudantes da classe de construtores Updates para executar atualizações usando suas propriedades de classe de dados.

O código a seguir mostra como usar os métodos de extensão Sorts para criar classificações diferentes na classe de dados Student :

import com.mongodb.kotlin.client.model.Filters.gte
import com.mongodb.kotlin.client.model.Updates.addToSet
import com.mongodb.kotlin.client.model.Updates.combine
import com.mongodb.kotlin.client.model.Updates.max
val filter = Student::gradeAverage gte 85.0
val update = combine(
    addToSet(Student::teachers, "Soto"),
    Student::gradeAverage.max(90.0)
)
collection.updateMany(filter, update)

Agregados

Você pode utilizar os auxiliares das classes de construtores Aggregates e Accumulators para executar agregações utilizando suas propriedades de classe de dados.

O código a seguir mostra como usar os métodos de extensão Accumulators e os métodos assistente de Aggregates para executar uma agregação na classe de dados Student :

import com.mongodb.client.model.Aggregates.group
import com.mongodb.client.model.Aggregates.limit
import com.mongodb.client.model.Aggregates.sort
import com.mongodb.kotlin.client.model.Accumulators.avg
// Data class to store aggregation result
data class Summary ( val average: Double )
val pipeline = listOf(
    // Sorts grades from high to low
    sort(Sorts.descending(Student::gradeAverage)),
    // Selects the top 3 students
    limit(3),
    // Calculates the average of their grades and stores value in a Summary instance
    group(null, avg(Summary::average, "\$${Student::gradeAverage.name}"))
)
val result = collection.aggregate<Summary>(pipeline)

Documentação da API

Voltar

Construtores

Próximo

Segurança