1. Introducción
En este tutorial, veremos BSON y cómo podemos usarlo para interactuar con MongoDB.
Ahora, una descripción detallada de MongoDB y todas sus capacidades está más allá del alcance de este artículo. Sin embargo, será útil comprender algunos conceptos clave.
MongoDB es un motor de almacenamiento de documentos NoSQL distribuido. Los documentos se almacenan como datos BSON y se agrupan en colecciones. Los documentos de una colección son similares a las filas de una tabla de base de datos relacional .
Para una mirada más profunda, eche un vistazo al artículo introductorio de MongoDB.
2. ¿Qué es BSON? ?
BSON significa JSON binario . Es un protocolo para la serialización binaria de datos similares a JSON.
JSON es un formato de intercambio de datos popular en los servicios web modernos. Proporciona una forma flexible de representar estructuras de datos complejas.
BSON ofrece varias ventajas sobre el uso de JSON normal:
- Compacto:en la mayoría de los casos, almacenar una estructura BSON requiere menos espacio que su equivalente JSON
- Tipos de datos:BSON proporciona tipos de datos adicionales no se encuentra en JSON normal, como Date y BinData
Uno de los principales beneficios de usar BSON es que es fácil de atravesar . Los documentos BSON contienen metadatos adicionales que permiten manipular fácilmente los campos de un documento, sin tener que leer todo el documento.
3. El controlador MongoDB
Ahora que tenemos una comprensión básica de BSON y MongoDB, veamos cómo usarlos juntos. Nos centraremos en las principales acciones del acrónimo CRUD (C Crear, R cabeza, U actualización, D eliminar).
MongoDB proporciona controladores de software para la mayoría de los lenguajes de programación modernos. Los controladores están construidos sobre la biblioteca BSON , lo que significa que trabajaremos directamente con la API de BSON al crear consultas. Para obtener más información, consulte nuestra guía del lenguaje de consulta de MongoDB.
En esta sección, veremos el uso del controlador para conectarse a un clúster y el uso de la API de BSON para realizar diferentes tipos de consultas. Tenga en cuenta que el controlador MongoDB proporciona un Filtros clase que puede ayudarnos a escribir un código más compacto. Sin embargo, para este tutorial, nos centraremos únicamente en el uso de la API básica de BSON.
Como alternativa al uso directo del controlador MongoDB y BSON, consulte nuestra guía Spring Data MongoDB.
3.1. Conectando
Para comenzar, primero agregamos el controlador MongoDB como una dependencia en nuestra aplicación:
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>3.10.1</version>
</dependency>Luego creamos una conexión a una base de datos y colección MongoDB:
MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection<Document> collection = database.getCollection("employees");Las secciones restantes analizarán la creación de consultas utilizando la colección referencia.
3.2. Insertar
Digamos que tenemos el siguiente JSON que queremos insertar como un nuevo documento en un empleados colección:
{
"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 JSON de ejemplo muestra los tipos de datos más comunes que encontraríamos con los documentos de MongoDB:texto, numéricos, matrices y documentos incrustados.
Para insertar esto usando BSON, usaríamos el Documento de 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);
El Documento class es la API principal utilizada en BSON. Extiende el Java Map interfaz y contiene varios métodos sobrecargados. Esto facilita el trabajo con tipos nativos, así como con objetos comunes, como ID de objeto, fechas y listas.
3.3. Buscar
Para encontrar un documento en MongoDB, proporcionamos un documento de búsqueda que especifica en qué campos consultar. Por ejemplo, para encontrar todos los documentos que tienen un apellido de "Smith" usaríamos el siguiente documento JSON:
{
"last_name": "Smith"
}Escrito en BSON sería:
Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);Las consultas de "Buscar" pueden aceptar múltiples campos y el comportamiento predeterminado es usar los y lógicos operador para combinarlos. Esto significa que solo se devolverán los documentos que coincidan con todos los campos .
Para evitar esto, MongoDB proporciona el o operador de consulta:
{
"$or": [
{ "first_name": "Joe" },
{ "last_name":"Smith" }
]
}Esto encontrará todos los documentos que tengan el nombre de pila "Joe" o el apellido "Smith". Para escribir esto como BSON, usaríamos un Documento anidado al igual que la consulta de inserción anterior:
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. Actualizar
Las consultas de actualización son un poco diferentes en MongoDB porque requieren dos documentos :
- Los criterios de filtrado para encontrar uno o más documentos
- Un documento de actualización que especifica qué campos modificar
Por ejemplo, digamos que queremos agregar una habilidad de "seguridad" a cada empleado que ya tiene una habilidad de "primavera". El primer documento encontrará a todos los empleados con habilidades "primaveras", y el segundo agregará una nueva entrada de "seguridad" a su matriz de habilidades.
En JSON, estas dos consultas se verían así:
{
"skills": {
$elemMatch: {
"$eq": "spring"
}
}
}
{
"$push": {
"skills": "security"
}
}Y en BSON serían:
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. Eliminar
Las consultas de eliminación en MongoDB usan la misma sintaxis que las consultas de búsqueda. Simplemente proporcionamos un documento que especifica uno o más criterios para coincidir.
Por ejemplo, digamos que encontramos un error en nuestra base de datos de empleados y accidentalmente creamos empleados con un valor negativo para los años de servicio. Para encontrarlos todos, usaríamos el siguiente JSON:
{
"years_of_service" : {
"$lt" : 0
}
}El documento BSON equivalente sería:
Document query = new Document(
"years_of_service",
new Document("$lt", 0));
collection.deleteMany(query);
