MongoDB Java CRUD Beispielanleitung

Tutorials
MongoDB

Willkommen zum MongoDB Java Beispiel Tutorial. Zuvor haben wir gelernt, wie man MongoDB auf Unix-Maschinen installiert und einige Befehle über das Terminal ausgeführt. Heute werden wir uns die Funktionen des MongoDB Java Treibers ansehen und wie man gängige CRUD-Operationen (Erstellen, Lesen, Aktualisieren, Löschen) durchführt.

MongoDB Java

  1. MongoDB Java Treiber herunterladen

  2. Erstellen einer MongoDB Java Verbindung

  3. Verbindung zur MongoDB-Datenbank

  4. MongoDB und Sammlungen

  5. MongoDB Java Beispiel

  6. MongoDB Java Treiber Herunterladen

    Wenn Sie ein Maven-Projekt haben, fügen Sie einfach die folgende Abhängigkeit hinzu, um den MongoDB Java-Treiber in Ihre Anwendung einzuschließen.

    <Abhängigkeit>
	<groupId>org.mongodb</groupId>
	<artifactId>mongo-java-driver</artifactId>
	<Version>2.12.3</Version>
</Abhängigkeit>

    Wenn Sie ein eigenständiges Projekt haben, können Sie den MongoDB Java-Treiber von diesem Link herunterladen und in Ihren Projekt-Build-Pfad einbinden. Nun werden wir einige grundlegende Verwendungen des MongoDB Java-Treibers durchgehen und anschließend werden wir uns das Programm für CRUD-Operationen im MongoDB Java Beispiel ansehen.

  7. Erstellen einer MongoDB Java-Verbindung

    MongoClient ist die Schnittstelle zwischen unserem Java-Programm und dem MongoDB-Server. MongoClient wird verwendet, um eine Verbindung herzustellen, sich mit der Datenbank zu verbinden, die Namen der Sammlungen abzurufen und Datenbanken, Sammlungen, Dokumente usw. zu erstellen/lesen/aktualisieren/löschen. Eine der Funktionen des MongoDB Java-Treibers, die ich am meisten mag, ist, dass er threadsicher ist. Daher können wir eine Instanz von MongoClient einmal erstellen und wiederverwenden. Selbst wenn mehrere Threads gleichzeitig darauf zugreifen, wird eine Verbindung aus dem von ihm verwalteten internen Verbindungspool zurückgegeben. Für jede Anfrage an die Datenbank (Suchen, Einfügen usw.) wird der Java-Thread eine Verbindung aus dem Pool erhalten, die Operation ausführen und die Verbindung freigeben. Dies bedeutet, dass die verwendete Verbindung (Socket) jedes Mal unterschiedlich sein kann. Im Folgenden sind einige der üblichen Methoden zum Herstellen einer Verbindung zu einem MongoDB-Server aufgeführt.

    MongoClient mongoClient = new MongoClient(); // verbindet mit Standard-Host und Port d.h. 127.0.0.1:27017
// oder
MongoClient mongoClient = new MongoClient( "localhost" ); // verbindet mit Standardport d.h. 27017
// oder
MongoClient mongoClient = new MongoClient( "localhost" , 27017 ); // sollte immer verwendet werden

// oder, um sich mit einem Replikatsatz zu verbinden, mit automatischer Erkennung des Primärs
MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
                                      new ServerAddress("localhost", 27018),
                                      new ServerAddress("localhost", 27019)));

  8. Verbindung zur MongoDB-Datenbank

    Nachdem wir die Verbindung zum MongoDB-Server hergestellt haben, ist der nächste Schritt, die Verbindung zur Datenbank herzustellen, wie unten gezeigt. Beachten Sie, dass MongoDB die Datenbank für Sie erstellt, wenn sie nicht vorhanden ist.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");

    Der MongoClient bietet eine nützliche Methode, um alle Datenbanknamen abzurufen, wie unten gezeigt.

    MongoClient mongo = new MongoClient("localhost", 27017);
List<String> dbs = mongo.getDatabaseNames();
System.out.println(dbs); // [journaldev, local, admin]

    Wir können eine benutzerpasswortbasierte Authentifizierung für Datenbanken haben. In diesem Fall müssen wir Berechtigungsanmeldeinformationen wie unten angegeben bereitstellen.

    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);

    Wenn Sie ältere Versionen verwenden, müssen Sie Authentifizierungsdetails nach dem Abrufen des Datenbankobjekts bereitstellen, wie unten gezeigt.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
boolean auth = db.authenticate("pankaj", "pankaj123".toCharArray());

    Sie können leicht Mängel im früheren Ansatz erkennen. Die Authentifizierung sollte frühzeitig erfolgen, da wir uns nicht davon erholen können. Eine Datenbank kann entweder mit der MongoClient–dropDatabase(String db)-Methode oder mit der DB–dropDatabase()-Methode gelöscht werden. Da wir die Datenbank löschen, bevorzuge ich die Verwendung der MongoClient-Methode.

  9. MongoDB und Sammlungen

    Jede Datenbank kann null oder mehrere Sammlungen haben. Sie sind wie Tabellen in relationalen Datenbankservern, außer dass Sie kein spezifisches Datenformat haben. Denken Sie daran wie eine generische Liste gegenüber einer Liste von Zeichenfolgen in der Java-Programmiersprache. Wir können alle Sammlungsnamen mit dem folgenden Code abrufen.

    MongoClient mongo = new MongoClient("localhost", 27017);
DB db = mongo.getDB("journaldev");
		
Set<String> collections = db.getCollectionNames();
System.out.println(collections); // [datas, names, system.indexes, users]

    Wir können eine bestimmte Sammlung erhalten, indem wir ihren Namen angeben, wie unten gezeigt.

    DB db = mongo.getDB("journaldev");	
DBCollection col = db.getCollection("users");

    Wenn die Sammlung nicht existiert, wird sie von MongoDB für Sie erstellt. Alle Daten in MongoDB werden in irgendeine Sammlung eingegeben, sodass wir jetzt bereit sind, Einfüge-/Aktualisierungs-/Löschvorgänge durchzuführen. Wir können die Methode drop() der DBCollection verwenden, um eine Sammlung aus der Datenbank zu löschen.

  10. MongoDB Java-Beispiel

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");
		
		//Benutzer erstellen
		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());
		
		//Beispiel lesen
		DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
		DBCursor cursor = col.find(query);
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		
		//Beispiel aktualisieren
		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());
		
		//Beispiel löschen
		result = col.remove(query);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//Ressourcen schließen
		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)
```

Das ist alles, um mit dem MongoDB Java-Treiber zu beginnen. In den nächsten Beiträgen werden wir uns weitere Funktionen ansehen.

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