TOC

MongoDB BSON Guide

MongoDB BSON Guide

1. Introdução

Neste tutorial, veremosBSON e como podemos usá-lo para interagir comMongoDB.

Agora, uma descrição detalhada do MongoDB e de todos os seus recursos está além do escopo deste artigo. No entanto, será útil entender alguns conceitos-chave.

O MongoDB é um mecanismo de armazenamento de documentos NoSQL distribuído. Os documentos são armazenados como dados BSON e agrupados em coleções. Documents in a collection are analogous to rows in a relational database table.

Para uma visão mais aprofundada, dê uma olhada emintroductory MongoDB article.

2. O que é BSON?

BSON stands for Binary JSON. É um protocolo para serialização binária de dados do tipo JSON.

JSON é um formato de troca de dados que é popular em serviços da web modernos. Ele fornece uma maneira flexível de representar estruturas de dados complexas.

O BSON oferece várias vantagens sobre o uso regular de JSON:

  • Compacto: na maioria dos casos, armazenando umBSON structure requires less space than its JSON equivalent

  • Tipos de dados:BSON provides additional data types não encontrados em JSON regular, comoDate eBinData

One of the main benefits of using BSON is that it’s easy to traverse. Os documentos BSON contêm metadados adicionais que permitem uma fácil manipulação dos campos de um documento, sem a necessidade de ler todo o documento.

3. O driver MongoDB

Agora que temos um conhecimento básico de BSON e MongoDB, vamos ver como usá-los juntos. Vamos nos concentrar nas principais ações da sigla CRUD (Create,Read,Update,Delete).

O MongoDB fornecesoftware drivers para a maioria das linguagens de programação modernas. The drivers are built on top of the BSON library, o que significa que trabalharemos diretamente com a API BSON ao construir consultas. Para obter mais informações, consulte nossoguide to the MongoDB query language.

Nesta seção, veremos como usar o driver para se conectar a um cluster e usar a API BSON para realizar diferentes tipos de consultas. Observe que o driver MongoDB fornece umFilters class que pode nos ajudar a escrever um código mais compacto. Para este tutorial, no entanto, nos concentraremos exclusivamente no uso da API BSON principal.

Como alternativa para usar o driver MongoDB e BSON diretamente, dê uma olhada em nossoSpring Data MongoDB guide.

3.1. Conectando

Para começar, primeiro adicionamosMongoDB driver como uma dependência em nosso aplicativo: 


    org.mongodb
    mongodb-driver-sync
    3.10.1

Em seguida, criamos uma conexão com um banco de dados e coleção do MongoDB: 

MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection collection = database.getCollection("employees");

As seções restantes examinarão a criação de consultas usando a referênciacollection.

3.2. Inserir

Digamos que temos o seguinte JSON que queremos inserir como um novo documento em uma coleçãoemployees: 

{
  "first_name" : "Joe",
  "last_name" : "Smith",
  "title" : "Java Developer",
  "years_of_service" : 3,
  "skills" : ["java","spring","mongodb"],
  "manager" : {
     "first_name" : "Sally",
     "last_name" : "Johanson"
  }
}

Este exemplo JSON mostra os tipos de dados mais comuns que encontraríamos com documentos do MongoDB: texto, numérico, matrizes e documentos incorporados.

Para inserir isso usando BSON, usaríamos a APIDocument do MongoDB: 

Document employee = new Document()
    .append("first_name", "Joe")
    .append("last_name", "Smith")
    .append("title", "Java Developer")
    .append("years_of_service", 3)
    .append("skills", Arrays.asList("java", "spring", "mongodb"))
    .append("manager", new Document()
                           .append("first_name", "Sally")
                           .append("last_name", "Johanson"));
collection.insertOne(employee);

A classeDocument é a API principal usada no BSON. Ele estende a interface JavaMap e contém vários métodos sobrecarregados. Isso facilita o trabalho com tipos nativos, bem como com objetos comuns, como IDs, datas e listas de objetos.

3.3. Find

Para localizar um documento no MongoDB, fornecemos um documento de pesquisa que especifica quais campos os quais consultar. Por exemplo, para encontrar todos os documentos com o sobrenome "Smith", usaríamos o seguinte documento JSON: 

{
  "last_name": "Smith"
}

Escrito em BSON, isso seria: 

Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);

As consultas “Find” podem aceitar vários campos e o comportamento padrão é usar o operador lógicoand para combiná-los. This means only documents that match all fields will be returned.

Para contornar isso, o MongoDB fornece o operador de consultaor: 

{
  "$or": [
    { "first_name": "Joe" },
    { "last_name":"Smith" }
  ]
}

Ele encontrará todos os documentos que têm o nome "Joe" ou o sobrenome "Smith". Para escrever isso como BSON, usaríamos umDocument aninhado, assim como a consulta de inserção acima: 

Document query =
  new Document("$or", Arrays.asList(
      new Document("last_name", "Smith"),
      new Document("first_name", "Joe")));
List results = new ArrayList<>();
collection.find(query).into(results);

3.4. Atualizar

Update queries are a little different in MongoDB because they require two documents:

  1. O critério de filtro para encontrar um ou mais documentos

  2. Um documento de atualização especificando quais campos modificar

Por exemplo, digamos que queremos adicionar uma habilidade de "segurança" para cada funcionário que já possui uma habilidade de "mola". O primeiro documento encontrará todos os funcionários com habilidades de "primavera" e o segundo adicionará uma nova entrada de "segurança" à sua matriz de habilidades.

No JSON, essas duas consultas se pareceriam com: 

{
  "skills": {
    $elemMatch:  {
      "$eq": "spring"
    }
  }
}

{
  "$push": {
    "skills": "security"
  }
}

E no BSON, eles seriam: 

Document query = new Document(
  "skills",
  new Document(
    "$elemMatch",
    new Document("$eq", "spring")));
Document update = new Document(
  "$push",
  new Document("skills", "security"));
collection.updateMany(query, update);

3.5. Excluir

Delete queries in MongoDB use the same syntax as find queries. Simplesmente fornecemos um documento que especifica um ou mais critérios correspondentes.

Por exemplo, digamos que encontramos um bug em nosso banco de dados de funcionários e acidentalmente criamos funcionários com um valor negativo para anos de serviço. Para encontrar todos eles, usaríamos o seguinte JSON: 

{
  "years_of_service" : {
    "$lt" : 0
  }
}

O documento BSON equivalente seria: 

Document query = new Document(
  "years_of_service",
  new Document("$lt", 0));
collection.deleteMany(query);

4. Conclusão

Neste tutorial, vimos uma introdução básica à construção de consultas MongoDB usando a biblioteca BSON. Usando apenas a API BSON, implementamos operações básicas de CRUD para uma coleção do MongoDB.

O que não abordamos são tópicos mais avançados, como projeções, agregações, consultas geoespaciais, operações em massa e muito mais. Tudo isso é possível usando apenas a biblioteca BSON. Os exemplos que vimos aqui formam os blocos de construção que usaríamos para implementar essas operações mais avançadas.

Como sempre, você pode encontrar os exemplos de código acima em nossoGitHub repo.

Related