Java x Kotlin: sintaxe diferente, mesmas possibilidades
AM
Ashni Mehta5 min read • Published Nov 25, 2024 • Updated Nov 25, 2024
Avalie esse Artigo
Desde que o Java foi introduzido no 1995, milhões de desenvolvedores o usaram para construir aplicativos em uma variedade de setores e espaços problemáticos. Outras linguagens também emergiram, construindo sobre a base sólida que Java forneceu ao longo dos últimos 30 anos. Apache Geovy, lançado pela primeira vez em 2007, é uma linguagem compatível com a sintaxe Java para a JVM. O Scala, destinado a abordar algumas das críticas do Java, também pode ser executado na JVM e é interoperável com o Java.
Kotlin é o mais novo contendor popular no mundo das linguagens JVM . Lançado em 2011, ele tem ganhado popularidade constante – primeiro no mundo do desenvolvimento de aplicação Android e agora, no espaço da JVM no lado do servidor. O Kotlin é interoperável com o Java e tem como alvo principal a JVM. No entanto, é mais conciso que o Java, com segurança nula e suporte a coroutine.
Neste artigo, abordaremos como usar alguns recursos do MongoDB e comparar e contrastar como eles se parecem em Kotlin e Java.
Suponha que você queira rastrear alterações em seus dados no MongoDB. Podem ser alterações em uma collection, banco de dados de dados ou sistema. Você pode monitorar alterações em tempo real por meio de change streams, um recurso disponível no servidor MongoDB . Esse recurso permite que os aplicativos observem as alterações nos dados e React reajam a elas.
Os change streams estão disponíveis em várias versões do servidor MongoDB , mas em versões mais recentes foi introduzida a capacidade de divisão um grande evento de change stream (um evento que excede 16MB), com $changeStreamSplitLargeEvent. A capacidade de conter ou omitir uma pré-imagem (um documento que representa a versão do documento antes da operação) e uma pós-imagem (o mesmo, mas para depois da operação) também foi introduzida, com ChangeStreamPreAndPostImagesOptions.
Em Java, você pode abrir um change stream em uma collection e imprimir eventos conforme eles ocorrem, da seguinte forma:
1 ChangeStreamIterable<Document> changeStream = collection.watch(); 2 changeStream.forEach(event -> System.out.println("Received a change: " + event));
O método watch() é como você pode abrir um fluxo de alterações em um MongoCollection, MongoDatabase ou MongoClient. Observe que, dependendo do objeto em que você chama watch(), o escopo de eventos que o change stream escuta mudará (por exemplo, se você chamar watch() em um MongoDatabase, todas as collections nesse banco de dados de dados serão monitoradas).
O método é semelhante em Kotlin, mas observe que, no driver Kotlin Coroutine, você pode aproveitar o poder dos fluxos, pois o método watch () retornará uma instância de ChangeStreamFlow, que é uma implementação de fluxo para fluxos de mudança:
1 val changeStream = collection.watch() 2 changeStream.collect { 3 println("Received a change: $it") 4 }
No MongoDB, as queries podem ser construídas de algumas maneiras. Antes de entrar em detalhes, vamos começar com um exemplo. Suponhamos que queremos encontrar todos os pacientes em uma
patients coleção que correspondam aos seguintes critérios de elegibilidade para um novo teste de saúde:- Doentes cujo gênero é "male "
- Doentes com menos de "30 "
Queremos devolver apenas seus endereços para que possamos enviar um aviso pelo e-mail sobre este novo teste.
1 collection.find({ "gender": "male", "age" : { "$lt": 30 }}, { "_id": 0, "address": 1 })
Os resultados da query acima seriam um conjunto de documentos contendo apenas o campo de endereço (o campo _id foi suprimido por ser projetado). Se usássemos o driver Java , sem construtores, nossa consulta seria semelhante ao seguinte:
1 Bson filter = new Document().append("gender", "male").append("age", new Document().append("$lt", 30)); 2 Bson projection = new Document().append("_id", 0).append("address", 1); 3 4 collection.find(filter).projection(projection);
O resultado acima produziria os endereços dos pacientes que correspondem aos critérios anteriores. No entanto, o driver também fornece métodos para simplificar o processo de uso de operações CRUD e a API de aggregation para criar query com mais eficiência. Esses métodos são chamados de construtores.
Se usássemos construtores, em vez do código acima, nosso código em Java poderia se assemelhar ao seguinte:
1 import static com.mongodb.client.model.Filters.*; 2 import static com.mongodb.client.model.Projections.*; 3 4 Bson filter = and(eq("gender", "male"), lt("age", 30)); 5 Bson projection = fields(excludeId(), include("address")); 6 7 collection.find(filter).projection(projection);
Existem vários construtores disponíveis no driver Java atualmente:
- Filtros, para criar filtros de consulta
- Projeções, para projetos de construção
- Classifica, para criar critérios de classificação
- Atualizações, para criar atualizações
- Agregados, para criar agregação pipelines
- Índices, para criar chaves de índice
No exemplo acima, usamos os filtros e as projeções. Filtros são operações que o MongoDB usa para limitar resultados ao que você deseja ver, e as projeções permitem especificar quais campos incluir e excluir nos resultados da query. As projeções são particularmente úteis quando você deseja limitar a quantidade de dados que o MongoDB está enviando para aplicativos, para otimizar o desempenho ou reduzir os custos de armazenamento.
Os mesmos construtores estão disponíveis em Kotlin e podem ser usados com sintaxe ligeiramente diferente. Se considerarmos o caso do não construtor em Kotlin, nosso código poderá ter a seguinte aparência:
1 val filter = Document().append("gender", "male").append("age", Document().append("\$lt", 30)) 2 val projection = Document().append("_id", 0).append("address", 1) 3 val results = collection.find<Results>(filter).projection(projection)
Os construtores simplificam isso um pouco, com o código resultante semelhante ao seguinte:
1 val filter = Filters.and(Filters.eq(User::gender.name, "male"), Filters.lt(User::age.name, 30)) 2 val projection = Projections.fields(Projections.excludeId(), Projections.include("address")) 3 val results = collection.find<Results>(filter).projection(projection)
O MongoDB suporta criptografia de várias maneiras:
(1) Em trânsito por TLS/SSL, para garantir que o tráfego de rede do MongoDB seja legível apenas pelo cliente pretendido
(2) Em repouso, para ajudar a garantir a conformidade com os padrões de segurança e privacidade, como HIPAA, PCI-DSS e FERPA
(3) Em uso, para criptografar dados quando transmitidos, armazenados e processados
Queryable Encryption é uma forma de criptografia em uso que permite criptografar dados confidenciais do lado do cliente, armazenar campos confidenciais como dados criptografados totalmente aleatórios no lado do servidor e executar queries expressivas nos dados criptografados. É um esquema de criptografia rápido e pesquisável pioneiro no setor que permite realizar queries expressivas em campos criptografados sem a necessidade de criptografia determinística ou encraves de hardware. Embora a Queryable Encryption tenha sido lançada no ano passado, com suporte para queries de igualdade, com o MongoDB 8.0 vem a capacidade de executar queries de intervalo também. As queries de intervalo podem ser usadas para filtrar documentos com intervalos de valores específicos, como datas ou intervalos numéricos.
Para usar o novo suporte de intervalo, primeiro você precisará: \
- Opcional: se estiver usando criptografia explícita (em oposição à criptografia automática), também será necessário criar uma chave de criptografia de dados para o(s) campo(s) criptografado(s).
Após ter seu aplicação, você precisará:
- Especifique quais campos você deseja criptografar adicionando-os ao esquema de criptografia com a
queriespropriedade. Semelhante à especificação de um de " "queryTypeequalitypara consultas de igualdade, para consultas de intervalo, você gostaria de especificar umqueryTypederange" ". - Instancie ClientEncryption para acessar a API para métodos assistente de criptografia (você pode usar ClientEncryptions#create para fazer isso).
- Crie a coleção (observe que é recomendado criar explicitamente a coleção para que um índice seja criado nos campos criptografados).
- Insira pelo menos um documento com campos criptografados.
Para obter um guia mais detalhado das etapas acima, temos trechos de código em toda a documentação.
Depois que um campo for designado como criptografado e pelo menos um documento tiver sido inserido em sua coleção com um desses campos criptografados, você poderá fazer uma query para encontrar documentos correspondentes. Em Java, uma query de intervalo para localizar um usuário cujo valor da conta esteja entre 1000 e 2000 pode ser semelhante ao seguinte:
1 Document filter = new Document("patientRecord.billAmount", new Document("$gt", 1000).append("$lt", 2000)); 2 Patient findResult = collection.find(filter).first();
Kotlin não é tão diferente, em termos de sintaxe, com a query de intervalo resultante semelhante ao seguinte:
1 val filter = Document("patientRecord.billAmount", Document("\$gt", 1000).append("\$lt", 2000)) 2 val findResult: Patient? = collection.find(filter).first()
Para explorar as consultas de intervalo (e a Queryable Encryption) em mais detalhes, consulte nosso tutorial, Java atende a Queryable Encryption! Ele guiará você passo a passo pelo processo de configuração de um projeto, configuração da criptografia automática, das classes de criptografia e muito mais.
No artigo acima, abordamos os principais recursos do MongoDB e como usá-los em duas linguagens diferentes, mas complementares. Java e Kotlin são duas linguagens distintas direcionadas ao JVM, mas com o suporte do MongoDB para ambos, você pode ter certeza de que pode interagir com seus dados na linguagem de sua escolha. Além disso, como Java e Kotlin são interoperáveis, você pode aproveitar o poder do ecossistema Java de longa data e as bibliotecas e utilidades dentro dele para construir novos aplicativos Kotlin .
Principais comentários nos fóruns
Ainda não há comentários sobre este artigo.