En guide till MongoDB med Java

1. Översikt

I den här artikeln ska vi ta en titt på att integrera MongoDB, en mycket populär NoSQL-databas med öppen källkod med en fristående Java-klient.

MongoDB är skrivet i C++ och har en hel del solida funktioner som map-reduce, auto-sharding, replikering, hög tillgänglighet etc.

2. MongoDB

Låt oss börja med några viktiga punkter om själva MongoDB:

lagrar data i JSON-liknande dokument som kan ha olika strukturer
använder dynamiska scheman, vilket innebär att vi kan skapa poster utan att fördefiniera någonting
strukturen för en post kan ändras helt enkelt genom att lägga till nya fält eller ta bort befintliga

Ovannämnda datamodell ger oss möjligheten att representera hierarkiska relationer, att enkelt lagra arrayer och andra mer komplexa strukturer.

3. Terminologier

Att förstå begrepp i MongoDB blir lättare om vi kan jämföra dem med relationsdatabasstrukturer.

Låt oss se analogierna mellan Mongo och ett traditionellt MySQL-system:

Tabell i MySQL blir en Samling i Mongo
Rad blir ett Dokument
Kolumn blir ett Fält
Gå med definieras som länkar och inbäddad dokument

Detta är naturligtvis ett förenklat sätt att se på MongoDB:s kärnkoncept, men ändå användbart.

Låt oss nu dyka in i implementeringen för att förstå denna kraftfulla databas.

4. Maven beroenden

Vi måste börja med att definiera beroendet av en Java-drivrutin för MongoDB:

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>3.4.1</version>
</dependency>

För att kontrollera om någon ny version av biblioteket har släppts – spåra utgivningarna här.

5. Använder MongoDB

Låt oss nu börja implementera Mongo-frågor med Java. Vi kommer att följa med de grundläggande CRUD-operationerna eftersom de är de bästa att börja med.

5.1. Skapa en anslutning med MongoClient

Låt oss först göra en anslutning till en MongoDB-server. Med version>=2.10.0 använder vi MongoClient :

MongoClient mongoClient = new MongoClient("localhost", 27017);

Och för äldre versioner använd Mongo klass:

Mongo mongo = new Mongo("localhost", 27017);

5.2. Ansluta till en databas

Låt oss nu ansluta till vår databas. Det är intressant att notera att vi inte behöver skapa en. När Mongo ser att databasen inte existerar kommer den att skapa den åt oss:

DB database = mongoClient.getDB("myMongoDb");

Ibland körs MongoDB som standard i autentiserat läge. I så fall måste vi autentisera när vi ansluter till en databas.

Vi kan göra det enligt nedan:

MongoClient mongoClient = new MongoClient();
DB database = mongoClient.getDB("myMongoDb");
boolean auth = database.authenticate("username", "pwd".toCharArray());

5.3. Visa befintliga databaser

Låt oss visa alla befintliga databaser. När vi vill använda kommandoraden liknar syntaxen för att visa databaser MySQL:

show databases;

I Java visar vi databaser med hjälp av utdrag nedan:

mongoClient.getDatabaseNames().forEach(System.out::println);

Utdata blir:

local      0.000GB
myMongoDb  0.000GB

Ovan, lokal är standard Mongo-databasen.

5.4. Skapa en samling

Låt oss börja med att skapa en samling (tabellekvivalent för MongoDB) för vår databas. När vi har anslutit till vår databas kan vi göra en samling som:

database.createCollection("customers", null);

Låt oss nu visa alla befintliga samlingar för aktuell databas:

database.getCollectionNames().forEach(System.out::println);

Utdata blir:

customers

5.5. Spara – Infoga

spara operationen har spara-eller-uppdatera semantik:om ett id är närvarande utför den en uppdatering , om inte – det gör en insert .

När vi spara en ny kund:

DBCollection collection = database.getCollection("customers");
BasicDBObject document = new BasicDBObject();
document.put("name", "Shubham");
document.put("company", "Baeldung");
collection.insert(document);

Entiteten kommer att infogas i en databas:

{
    "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"),
    "name" : "Shubham",
    "company" : "Baeldung"
}

Därefter ska vi titta på samma operation – spara – med uppdatering semantik.

5.6. Spara – Uppdatera

Låt oss nu titta på spara med uppdatering semantik, som verkar på en befintlig kund:

{
    "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"),
    "name" : "Shubham",
    "company" : "Baeldung"
}

Nu, när vi spara den befintliga kunden – vi kommer att uppdatera den:

BasicDBObject query = new BasicDBObject();
query.put("name", "Shubham");

BasicDBObject newDocument = new BasicDBObject();
newDocument.put("name", "John");

BasicDBObject updateObject = new BasicDBObject();
updateObject.put("$set", newDocument);

collection.update(query, updateObject);

Databasen kommer att se ut så här:

{
    "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"),
    "name" : "John",
    "company" : "Baeldung"
}

Som du kan se, spara i det här exemplet använder semantiken för uppdatering , eftersom vi använder objekt med angivet _id .

5.7. Läs ett Dokument Från en samling

Låt oss söka efter ett Dokument i en samling genom att göra en fråga:

BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", "John");
DBCursor cursor = collection.find(searchQuery);

while (cursor.hasNext()) {
    System.out.println(cursor.next());
}

Det kommer att visa det enda dokumentet vi har nu i vår samling :

[
    {
      "_id" : ObjectId("33a52bb7830b8c9b233b4fe6"),
      "name" : "John",
      "company" : "Baeldung"
    }
]

5.8. Ta bort ett Dokument

Låt oss gå vidare till vår senaste CRUD-operation, radering:

BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", "John");

collection.remove(searchQuery);

Med kommandot ovan utfört är vårt enda dokument kommer att tas bort från Samlingen .