1. Inledning
I den här handledningen kommer vi att titta på BSON och hur vi kan använda den för att interagera med MongoDB.
Nu ligger en djupgående beskrivning av MongoDB och alla dess möjligheter utanför ramen för denna artikel. Det är dock användbart att förstå några nyckelbegrepp.
MongoDB är en distribuerad NoSQL-dokumentlagringsmotor. Dokument lagras som BSON-data och grupperas i samlingar. Dokument i en samling är analoga med rader i en relationsdatabastabell .
För en mer djupgående titt, ta en titt på den inledande MongoDB-artikeln.
2. Vad är BSON ?
BSON står för Binary JSON . Det är ett protokoll för binär serialisering av JSON-liknande data.
JSON är ett datautbytesformat som är populärt i moderna webbtjänster. Det ger ett flexibelt sätt att representera komplexa datastrukturer.
BSON ger flera fördelar jämfört med att använda vanlig JSON:
- Kompakt:I de flesta fall kräver lagring av en BSON-struktur mindre utrymme än dess JSON-motsvarighet
- Datatyper:BSON tillhandahåller ytterligare datatyper hittas inte i vanlig JSON, till exempel Datum och BinData
En av de främsta fördelarna med att använda BSON är att det är lätt att ta sig igenom . BSON-dokument innehåller ytterligare metadata som möjliggör enkel manipulering av fälten i ett dokument, utan att behöva läsa hela dokumentet.
3. MongoDB-drivrutinen
Nu när vi har en grundläggande förståelse för BSON och MongoDB, låt oss titta på hur man använder dem tillsammans. Vi kommer att fokusera på de viktigaste åtgärderna från CRUD-akronymen (C reate, R ead, U pdate, D elete).
MongoDB tillhandahåller mjukvarudrivrutiner för de flesta moderna programmeringsspråk. Drivrutinerna är byggda ovanpå BSON-biblioteket , vilket innebär att vi kommer att arbeta direkt med BSON API när vi bygger frågor. För mer information, se vår guide till MongoDB-frågespråket.
I det här avsnittet kommer vi att titta på att använda drivrutinen för att ansluta till ett kluster och använda BSON API för att utföra olika typer av frågor. Observera att MongoDB-drivrutinen tillhandahåller ett Filter klass som kan hjälpa oss att skriva mer kompakt kod. För den här handledningen kommer vi dock enbart att fokusera på att använda BSON-API:et.
Som ett alternativ till att använda MongoDB-drivrutinen och BSON direkt, ta en titt på vår Spring Data MongoDB-guide.
3.1. Ansluter
För att komma igång lägger vi först till MongoDB-drivrutinen som ett beroende i vår applikation:
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongodb-driver-sync</artifactId>
<version>3.10.1</version>
</dependency>Sedan skapar vi en koppling till en MongoDB-databas och samling:
MongoClient mongoClient = MongoClients.create();
MongoDatabase database = mongoClient.getDatabase("myDB");
MongoCollection<Document> collection = database.getCollection("employees");De återstående avsnitten kommer att titta på hur du skapar frågor med samlingen referens.
3.2. Infoga
Låt oss säga att vi har följande JSON som vi vill infoga som ett nytt dokument i en anställd samling:
{
"first_name" : "Joe",
"last_name" : "Smith",
"title" : "Java Developer",
"years_of_service" : 3,
"skills" : ["java","spring","mongodb"],
"manager" : {
"first_name" : "Sally",
"last_name" : "Johanson"
}
}Det här exemplet JSON visar de vanligaste datatyperna vi skulle stöta på med MongoDB-dokument:text, numeriska, arrayer och inbäddade dokument.
För att infoga detta med BSON använder vi MongoDB:s Dokument 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);
Dokumentet klass är det primära API som används i BSON. Det utökar Java-kartan gränssnitt och innehåller flera överbelastade metoder. Detta gör det enkelt att arbeta med inbyggda typer såväl som vanliga objekt som objekt-ID, datum och listor.
3.3. Hitta
För att hitta ett dokument i MongoDB tillhandahåller vi ett sökdokument som anger vilka fält som ska frågas på. Till exempel, för att hitta alla dokument som har efternamnet "Smith" skulle vi använda följande JSON-dokument:
{
"last_name": "Smith"
}Skrivet i BSON skulle detta vara:
Document query = new Document("last_name", "Smith");
List results = new ArrayList<>();
collection.find(query).into(results);"Sök"-frågor kan acceptera flera fält och standardbeteendet är att använda logiska och operatör att kombinera dem. Detta innebär att endast dokument som matchar alla fält kommer att returneras .
För att komma runt detta tillhandahåller MongoDB eller frågeoperator:
{
"$or": [
{ "first_name": "Joe" },
{ "last_name":"Smith" }
]
}Detta kommer att hitta alla dokument som har antingen förnamnet "Joe" eller efternamnet "Smith". För att skriva detta som BSON skulle vi använda ett kapslat Dokument precis som infogningsfrågan ovan:
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. Uppdatera
Uppdateringsfrågor är lite annorlunda i MongoDB eftersom de kräver två dokument :
- Filterkriterierna för att hitta ett eller flera dokument
- Ett uppdateringsdokument som anger vilka fält som ska ändras
Låt oss till exempel säga att vi vill lägga till en "säkerhets"-färdighet till varje anställd som redan har en "vår"-färdighet. Det första dokumentet kommer att hitta alla anställda med "vår"-kunskaper, och det andra kommer att lägga till en ny "säkerhet"-post till deras kompetensuppsättning.
I JSON skulle dessa två frågor se ut så här:
{
"skills": {
$elemMatch: {
"$eq": "spring"
}
}
}
{
"$push": {
"skills": "security"
}
}Och i BSON skulle de vara:
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. Ta bort
Ta bort frågor i MongoDB använder samma syntax som sökfrågor. Vi tillhandahåller helt enkelt ett dokument som anger ett eller flera kriterier som ska matcha.
Låt oss till exempel säga att vi hittade en bugg i vår personaldatabas och av misstag skapade anställda med ett negativt värde för många års tjänst. För att hitta dem alla skulle vi använda följande JSON:
{
"years_of_service" : {
"$lt" : 0
}
}Motsvarande BSON-dokument skulle vara:
Document query = new Document(
"years_of_service",
new Document("$lt", 0));
collection.deleteMany(query);