MongoDB Java CRUD Voorbeeld Tutorial

MongoDB

Welkom bij de MongoDB Java Voorbeeld Tutorial. Eerder hebben we geleerd hoe MongoDB te installeren op Unix-machines en enkele commando’s uitgevoerd vanaf de terminal. Vandaag zullen we kijken naar de functies van de MongoDB Java Driver en hoe u gemeenschappelijke CRUD (Create, Read, Update, Delete) bewerkingen kunt uitvoeren.

MongoDB Java

MongoDB Java Driver Downloaden
MongoDB Java Verbinding Maken
Verbinding met MongoDB Database
MongoDB en Collecties
MongoDB Java Voorbeeld
html

MongoDB Java Driver Download

Als u een Maven-project heeft, voegt u gewoon de onderstaande afhankelijkheid toe om de MongoDB Java-driver in uw toepassing op te nemen.
```
<dependency>
	<groupId>org.mongodb</groupId>
	<artifactId>mongo-java-driver</artifactId>
	<version>2.12.3</version>
</dependency>
```
Als u een op zichzelf staand project heeft, kunt u de MongoDB Java-driver downloaden van deze link en deze opnemen in het buildpad van uw project. Laten we nu wat basisgebruik van de MongoDB Java-driver doornemen en daarna zullen we het programma voor CRUD-operaties in het MongoDB Java Voorbeeld bekijken.
Het maken van een MongoDB Java-verbinding

MongoClient is de interface tussen ons Java-programma en de MongoDB-server. MongoClient wordt gebruikt om verbinding te maken, verbinding te maken met de database, collectienamen op te halen en databases, collecties, documenten enzovoort te maken/lezen/bijwerken/verwijderen. Een van de functies van de MongoDB Java-driver die ik het meest waardeer, is dat deze thread-safe is, zodat we een instantie van MongoClient slechts één keer kunnen maken en opnieuw kunnen gebruiken. Zelfs als meerdere threads er tegelijkertijd toegang toe hebben, wordt er een verbinding geretourneerd uit de interne verbindingenpool die door het wordt onderhouden. Voor elk verzoek aan de database (zoeken, invoegen enzovoort) zal de Java-thread een verbinding uit de pool verkrijgen, de bewerking uitvoeren en de verbinding vrijgeven. Dit betekent dat de gebruikte verbinding (socket) elke keer anders kan zijn. Hieronder staan enkele van de gebruikelijke methoden om verbinding te maken met een MongoDB-server.
```
MongoClient mongoClient = new MongoClient(); // verbindt met de standaard host en poort, d.w.z. 127.0.0.1:27017
// of
MongoClient mongoClient = new MongoClient( "localhost" ); // verbindt met de standaard poort, d.w.z. 27017
// of
MongoClient mongoClient = new MongoClient( "localhost" , 27017 ); // moet altijd worden gebruikt

// of, om verbinding te maken met een replica set, met automatische detectie van de primaire
MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
                                      new ServerAddress("localhost", 27018),
                                      new ServerAddress("localhost", 27019)));
```
Verbinding met MongoDB Database

Zodra we verbinding hebben gemaakt met de MongoDB-server, is de volgende stap om verbinding te maken met de database, zoals hieronder weergegeven. Let op: als de database niet aanwezig is, zal MongoDB deze voor u aanmaken.
```
MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
```
MongoClient biedt een handige methode om alle databasenamen te krijgen, zoals hieronder weergegeven.
```
MongoClient mongo = new MongoClient("localhost", 27017);
List<String> dbs = mongo.getDatabaseNames();
System.out.println(dbs); // [journaldev, local, admin]
```
We kunnen authenticatie op basis van gebruikersnaam en wachtwoord hebben voor databases, in dat geval moeten we autorisatiegegevens verstrekken zoals hieronder.
```
MongoCredential journaldevAuth = MongoCredential.createPlainCredential("pankaj", "journaldev", "pankaj123".toCharArray());
MongoCredential testAuth = MongoCredential.createPlainCredential("pankaj", "test", "pankaj123".toCharArray());
List<MongoCredential> auths = new ArrayList<MongoCredential>();
auths.add(journaldevAuth);
auths.add(testAuth);

ServerAddress serverAddress = new ServerAddress("localhost", 27017);
MongoClient mongo = new MongoClient(serverAddress, auths);
```
Als u oudere versies gebruikt, moet u de authenticatiegegevens verstrekken nadat u het database-object hebt ontvangen, zoals hieronder.
```
MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
boolean auth = db.authenticate("pankaj", "pankaj123".toCharArray());
```
U kunt gemakkelijk tekortkomingen vinden in de eerdere benadering, de authenticatie moet in een vroeg stadium worden uitgevoerd omdat we er niet van kunnen herstellen. We kunnen een database verwijderen door gebruik te maken van de MongoClient dropDatabase(String db) methode of door de DB dropDatabase() methode. Omdat we de database verwijderen, geef ik de voorkeur aan de MongoClient-methode.
MongoDB en Collecties

Elke database kan nul of meerdere collecties hebben, vergelijkbaar met tabellen in relationele databaseservers, behalve dat er geen specifiek gegevensformaat is. Denk eraan als een generieke lijst versus een lijst van Strings in termen van de Java-programmeertaal. We kunnen alle collectienamen krijgen met de onderstaande code.
```
MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
		
Set<String> collecties = db.getCollectionNames();
System.out.println(collecties); // [datas, names, system.indexes, users]
```
We kunnen een specifieke collectie krijgen door de naam ervan te verstrekken, zoals hieronder wordt getoond.
```
DB db = mongo.getDB("journaldev");	
DBCollection col = db.getCollection("users");
```
Als de collectie nog niet bestaat, zal MongoDB deze voor u aanmaken. Alle gegevens in MongoDB worden in een bepaalde collectie geplaatst, dus op dit punt zijn we klaar om invoeg-/update-/verwijderbewerkingen uit te voeren. We kunnen de DBCollection drop()-methode gebruiken om een collectie uit de database te verwijderen.
MongoDB Java Voorbeeld

Even though we can work on any valid JSON document in MongoDB collection, in real life we have POJO classes that are mapped with these data. So I will create a java bean and use it for my examples. `User.java`

```
package com.journaldev.mongodb.model;

public class User {

	private int id;
	private String name;
	private String role;
	private boolean isEmployee;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getRole() {
		return role;
	}
	public void setRole(String role) {
		this.role = role;
	}
	public boolean isEmployee() {
		return isEmployee;
	}
	public void setEmployee(boolean isEmployee) {
		this.isEmployee = isEmployee;
	}
}
```

Here is the complete MongoDB java example program showing all the CRUD operations one by one. `MongoDBExample.java`

```
package com.journaldev.mongodb.main;

import java.net.UnknownHostException;

import com.journaldev.mongodb.model.User;
import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.WriteResult;

public class MongoDBExample {

	public static void main(String[] args) throws UnknownHostException {
	
		User user = createUser();
		DBObject doc = createDBObject(user);
		
		MongoClient mongo = new MongoClient("localhost", 27017);
		DB db = mongo.getDB("journaldev");
		
		DBCollection col = db.getCollection("users");
		
		//gebruiker aanmaken
		WriteResult result = col.insert(doc);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//voorbeeld lezen
		DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
		DBCursor cursor = col.find(query);
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		
		//voorbeeld bijwerken
		user.setName("Pankaj Kumar");
		doc = createDBObject(user);
		result = col.update(query, doc);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//voorbeeld verwijderen
		result = col.remove(query);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//bronnen sluiten
		mongo.close();
	}

	private static DBObject createDBObject(User user) {
		BasicDBObjectBuilder docBuilder = BasicDBObjectBuilder.start();
								
		docBuilder.append("_id", user.getId());
		docBuilder.append("name", user.getName());
		docBuilder.append("role", user.getRole());
		docBuilder.append("isEmployee", user.isEmployee());
		return docBuilder.get();
	}

	private static User createUser() {
		User u = new User();
		u.setId(2);
		u.setName("Pankaj");
		u.setEmployee(true);
		u.setRole("CEO");
		return u;
	}
	
	

}
```

A sample execution results in following output.

```
null
0
false
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
{ "_id" : 2 , "name" : "Pankaj" , "role" : "CEO" , "isEmployee" : true}
null
1
true
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
null
1
false
WriteConcern { "getlasterror" : 1} / (Continue on error? false)
```

Notice that I am saving User id with **\_id** name, this is a reserved key for the primary key of any record in the collection. If we don't provide one, MongoDB will create one for us. It's like sequencer or auto increment column in relational database tables. Since I am deleting the created record, further execution won't cause any issues. But if there are duplicate record, then we will get below errors.

```
Exception in thread "main" com.mongodb.MongoException$DuplicateKey: { "serverUsed" : "localhost:27017" , "ok" : 1 , "n" : 0 ,
 "err" : "insertDocument :: caused by :: 11000 E11000 duplicate key error index: journaldev.users.$_id_  dup key: { : 1 }" , 
"code" : 11000}
	at com.mongodb.CommandResult.getWriteException(CommandResult.java:88)
	at com.mongodb.CommandResult.getException(CommandResult.java:79)
	at com.mongodb.DBCollectionImpl.translateBulkWriteException(DBCollectionImpl.java:314)
	at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:189)
	at com.mongodb.DBCollectionImpl.insert(DBCollectionImpl.java:165)
	at com.mongodb.DBCollection.insert(DBCollection.java:93)
	at com.mongodb.DBCollection.insert(DBCollection.java:78)
	at com.mongodb.DBCollection.insert(DBCollection.java:120)
	at com.journaldev.mongodb.main.MongoDBExample.main(MongoDBExample.java:27)
```

Dat is alles om je op weg te helpen met MongoDB Java Driver, we zullen meer functies bekijken in volgende berichten.

Source:
https://www.digitalocean.com/community/tutorials/mongodb-java-crud-example-tutorial

MongoDB Java

MongoDB Java Driver Download

Het maken van een MongoDB Java-verbinding

Verbinding met MongoDB Database

MongoDB en Collecties

MongoDB Java Voorbeeld