1. Introdução
Neste tutorial, veremos o BSON e como podemos usá-lo para interagir com o MongoDB.
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.
MongoDB é um mecanismo de armazenamento de documentos NoSQL distribuído. Os documentos são armazenados como dados BSON e agrupados em coleções. Documentos em uma coleção são análogos a linhas em uma tabela de banco de dados relacional .
Para uma visão mais aprofundada, dê uma olhada no artigo introdutório do MongoDB.
2. O que é BSON ?
BSON significa JSON binário . É um protocolo para serialização binária de dados semelhantes a JSON.
JSON é um formato de troca de dados que é popular em serviços web modernos. Ele fornece uma maneira flexível de representar estruturas de dados complexas.
O BSON oferece várias vantagens sobre o uso de JSON regular:
- Compacto:na maioria dos casos, armazenar uma estrutura BSON requer menos espaço do que seu equivalente JSON
- Tipos de dados:BSON fornece tipos de dados adicionais não encontrado em JSON normal, como Data e BinData
Um dos principais benefícios de usar o BSON é que ele é fácil de percorrer . Os documentos BSON contêm metadados adicionais que permitem a fácil manipulação dos campos de um documento, sem a necessidade de ler todo o documento em si.
3. O Driver MongoDB
Agora que temos uma compreensão básica do BSON e do MongoDB, vamos ver como usá-los juntos. Vamos nos concentrar nas principais ações da sigla CRUD (C ria, R ead, U pdate, D eleito).
O MongoDB fornece drivers de software para a maioria das linguagens de programação modernas. Os drivers são criados com base na biblioteca BSON , o que significa que trabalharemos diretamente com a API BSON ao criar consultas. Para obter mais informações, consulte nosso guia para a linguagem de consulta do MongoDB.
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 do MongoDB fornece um Filtros classe que pode nos ajudar a escrever um código mais compacto. Para este tutorial, no entanto, vamos nos concentrar apenas no uso da API principal do BSON.
Como alternativa para usar o driver MongoDB e o BSON diretamente, dê uma olhada em nosso guia Spring Data MongoDB.
3.1. Conectando
Para começar, primeiro adicionamos o driver MongoDB como uma dependência em nosso aplicativo:
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>3.10.1</version>
</dependency>Em seguida, criamos uma conexão com um banco de dados e uma coleção do MongoDB:
MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection<Document> collection = database.getCollection("employees");As seções restantes analisarão a criação de consultas usando a coleção referência.
3.2. Inserir
Digamos que temos o seguinte JSON que queremos inserir como um novo documento em um funcionários coleção:
{
"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 de 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 o Document do MongoDB API:
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);
O Documento class é a API primária usada no BSON. Ele estende o Java Mapa interface e contém vários métodos sobrecarregados. Isso facilita o trabalho com tipos nativos, bem como com objetos comuns, como IDs de objetos, datas e listas.
3.3. Encontrar
Para encontrar um documento no MongoDB, fornecemos um documento de pesquisa que especifica em quais campos consultar. Por exemplo, para encontrar todos os documentos com sobrenome “Smith”, usaríamos o seguinte documento JSON:
{
"last_name": "Smith"
}Escrito em BSON seria:
Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);As consultas "Localizar" podem aceitar vários campos e o comportamento padrão é usar os comandos lógicos e operador para combiná-los. Isso significa que apenas os documentos que corresponderem a todos os campos serão retornados .
Para contornar isso, o MongoDB fornece o ou operador de consulta:
{
"$or": [
{ "first_name": "Joe" },
{ "last_name":"Smith" }
]
}Isso encontrará todos os documentos que tenham o primeiro nome “Joe” ou o sobrenome “Smith”. Para escrever isso como BSON, usaríamos um Document 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
As consultas de atualização são um pouco diferentes no MongoDB porque exigem dois documentos :
- Os critérios de filtro para encontrar um ou mais documentos
- Um documento de atualização especificando quais campos modificar
Por exemplo, digamos que queremos adicionar uma habilidade de “segurança” a cada funcionário que já tenha uma habilidade de “primavera”. O primeiro documento encontrará todos os funcionários com habilidades de "primavera" e o segundo adicionará uma nova entrada de "segurança" à matriz de habilidades.
Em JSON, essas duas consultas ficariam assim:
{
"skills": {
$elemMatch: {
"$eq": "spring"
}
}
}
{
"$push": {
"skills": "security"
}
}E em BSON, 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
As consultas de exclusão no MongoDB usam a mesma sintaxe das consultas de localização. Nós simplesmente fornecemos um documento que especifica um ou mais critérios para corresponder.
Por exemplo, digamos que encontramos um bug em nosso banco de dados de funcionários e acidentalmente criamos funcionários a com um valor negativo por anos de serviço. Para encontrá-los todos, 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);
