1. Introduzione
In questo tutorial, esamineremo BSON e come possiamo usarlo per interagire con MongoDB.
Ora, una descrizione approfondita di MongoDB e di tutte le sue capacità va oltre lo scopo di questo articolo. Tuttavia, sarà utile comprendere alcuni concetti chiave.
MongoDB è un motore di archiviazione di documenti NoSQL distribuito. I documenti vengono archiviati come dati BSON e raggruppati in raccolte. I documenti in una raccolta sono analoghi alle righe in una tabella di database relazionale .
Per uno sguardo più approfondito, dai un'occhiata all'articolo introduttivo di MongoDB.
2. Che cos'è BSON ?
BSON sta per JSON binario . È un protocollo per la serializzazione binaria di dati simili a JSON.
JSON è un formato di scambio dati diffuso nei moderni servizi web. Fornisce un modo flessibile per rappresentare strutture di dati complesse.
BSON offre diversi vantaggi rispetto all'utilizzo di JSON normale:
- Compatto:nella maggior parte dei casi, l'archiviazione di una struttura BSON richiede meno spazio rispetto al suo equivalente JSON
- Tipi di dati:BSON fornisce tipi di dati aggiuntivi non trovato in JSON normale, come Date e BinData
Uno dei principali vantaggi dell'utilizzo di BSON è che è facile da attraversare . I documenti BSON contengono metadati aggiuntivi che consentono una facile manipolazione dei campi di un documento, senza dover leggere l'intero documento stesso.
3. Il driver MongoDB
Ora che abbiamo una conoscenza di base di BSON e MongoDB, diamo un'occhiata a come usarli insieme. Ci concentreremo sulle azioni principali dell'acronimo CRUD (C reate, R ead, U pdate, D elete).
MongoDB fornisce driver software per i linguaggi di programmazione più moderni. I driver sono basati sulla libreria BSON , il che significa che lavoreremo direttamente con l'API BSON durante la creazione di query. Per ulteriori informazioni, consulta la nostra guida al linguaggio di query MongoDB.
In questa sezione, esamineremo l'utilizzo del driver per la connessione a un cluster e l'utilizzo dell'API BSON per eseguire diversi tipi di query. Nota che il driver MongoDB fornisce un Filtri classe che può aiutarci a scrivere codice più compatto. Per questo tutorial, tuttavia, ci concentreremo esclusivamente sull'utilizzo dell'API BSON di base.
In alternativa all'utilizzo diretto del driver MongoDB e BSON, dai un'occhiata alla nostra guida Spring Data MongoDB.
3.1. Connessione
Per iniziare, aggiungiamo prima il driver MongoDB come dipendenza nella nostra applicazione:
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>3.10.1</version>
</dependency>Quindi creiamo una connessione a un database e a una raccolta MongoDB:
MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection<Document> collection = database.getCollection("employees");Le restanti sezioni esamineranno la creazione di query utilizzando la raccolta riferimento.
3.2. Inserisci
Supponiamo di avere il seguente JSON che vogliamo inserire come nuovo documento in un dipendente collezione:
{
"first_name" : "Joe",
"last_name" : "Smith",
"title" : "Java Developer",
"years_of_service" : 3,
"skills" : ["java","spring","mongodb"],
"manager" : {
"first_name" : "Sally",
"last_name" : "Johanson"
}
}Questo esempio JSON mostra i tipi di dati più comuni che incontreremmo con i documenti MongoDB:testo, numerico, array e documenti incorporati.
Per inserirlo usando BSON, useremmo il Documento di 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);
Il documento class è l'API principale utilizzata in BSON. Estende la Mappa di Java interfaccia e contiene diversi metodi sovraccaricati. Ciò semplifica il lavoro con tipi nativi e oggetti comuni come ID oggetto, date ed elenchi.
3.3. Trova
Per trovare un documento in MongoDB, forniamo un documento di ricerca che specifica su quali campi eseguire query. Ad esempio, per trovare tutti i documenti che hanno il cognome "Smith" utilizzeremo il seguente documento JSON:
{
"last_name": "Smith"
}Scritto in BSON sarebbe:
Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);Le query "Trova" possono accettare più campi e il comportamento predefinito prevede l'utilizzo della logica e operatore per combinarli. Ciò significa che verranno restituiti solo i documenti che corrispondono a tutti i campi .
Per aggirare questo problema, MongoDB fornisce o operatore di query:
{
"$or": [
{ "first_name": "Joe" },
{ "last_name":"Smith" }
]
}Questo troverà tutti i documenti che hanno il nome "Joe" o il cognome "Smith". Per scrivere questo come BSON, useremmo un Documento annidato proprio come la query di inserimento sopra:
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. Aggiorna
Le query di aggiornamento sono leggermente diverse in MongoDB perché richiedono due documenti :
- I criteri di filtro per trovare uno o più documenti
- Un documento di aggiornamento che specifica quali campi modificare
Ad esempio, supponiamo di voler aggiungere una competenza di "sicurezza" a ogni dipendente che ha già una competenza di "primavera". Il primo documento troverà tutti i dipendenti con competenze "primaverili" e il secondo aggiungerà una nuova voce "sicurezza" al loro array di competenze.
In JSON, queste due query sarebbero simili a:
{
"skills": {
$elemMatch: {
"$eq": "spring"
}
}
}
{
"$push": {
"skills": "security"
}
}E in BSON sarebbero:
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. Elimina
Le query di eliminazione in MongoDB utilizzano la stessa sintassi delle query di ricerca. Forniamo semplicemente un documento che specifica uno o più criteri da soddisfare.
Ad esempio, supponiamo di aver trovato un bug nel nostro database dei dipendenti e di aver accidentalmente creato dipendenti con un valore negativo per anni di servizio. Per trovarli tutti, useremmo il seguente JSON:
{
"years_of_service" : {
"$lt" : 0
}
}Il documento BSON equivalente sarebbe:
Document query = new Document(
"years_of_service",
new Document("$lt", 0));
collection.deleteMany(query);
