Esempio di tutorial MongoDB Java CRUD

Tutorial
MongoDB

Benvenuto al Tutorial di Esempio su MongoDB in Java. In precedenza abbiamo imparato come installare MongoDB su macchine Unix ed eseguito alcuni comandi dal terminale. Oggi esamineremo le caratteristiche del driver MongoDB Java e come eseguire comuni operazioni CRUD (Create, Read, Update, Delete).

MongoDB Java

  1. Download del Driver MongoDB Java

  2. Creazione della Connessione MongoDB Java

  3. Connessione al Database MongoDB

  4. MongoDB e Collezioni

  5. Esempio di MongoDB Java

  6. Scarica il driver Java MongoDB

    Se hai un progetto Maven, aggiungi la dipendenza seguente per includere il driver Java MongoDB nella tua applicazione.

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

    Se hai un progetto autonomo, puoi scaricare il driver Java MongoDB da questo link e includerlo nel percorso di compilazione del tuo progetto. Ora esaminiamo alcuni utilizzi di base del driver Java MongoDB e successivamente vedremo il programma di esempio Java MongoDB per le operazioni CRUD.

  7. Creazione Connessione MongoDB Java

    MongoClient è l’interfaccia tra il nostro programma Java e il server MongoDB. MongoClient viene utilizzato per creare una connessione, connettersi al database, recuperare i nomi delle collezioni e creare/leggere/aggiornare/eliminare database, collezioni, documenti, ecc. Una delle caratteristiche del driver Java MongoDB che mi piace di più è che è thread-safe, quindi possiamo creare un’istanza di MongoClient una volta e riutilizzarla. Anche se più thread vi accedono contemporaneamente, viene restituita una connessione dal pool di connessioni interno mantenuto da esso. Per ogni richiesta al database (trova, inserisci, ecc.) il thread Java otterrà una connessione dal pool, eseguirà l’operazione e rilascerà la connessione. Questo significa che la connessione (socket) utilizzata può essere diversa ogni volta. Di seguito sono riportati alcuni dei metodi comuni per connettersi a un server MongoDB.

    MongoClient mongoClient = new MongoClient(); // si connette all'host e alla porta predefiniti, cioè 127.0.0.1:27017
// o
MongoClient mongoClient = new MongoClient( "localhost" ); // si connette alla porta predefinita, cioè 27017
// o
MongoClient mongoClient = new MongoClient( "localhost" , 27017 ); // dovrebbe essere utilizzato sempre questo

// o, per connettersi a un set di repliche, con scoperta automatica del primario
MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017),
                                      new ServerAddress("localhost", 27018),
                                      new ServerAddress("localhost", 27019)));

  8. Connessione al Database MongoDB

    Una volta ottenuta la connessione al server MongoDB, il passo successivo è creare la connessione al database, come mostrato di seguito. Nota che se il database non è presente, MongoDB lo creerà per te.

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

    MongoClient fornisce un utile metodo per ottenere tutti i nomi dei database, come mostrato di seguito.

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

    Possiamo avere un’autenticazione basata su utente-password per i database, in tal caso è necessario fornire le credenziali di autorizzazione come segue.

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

    Se si stanno utilizzando versioni più vecchie, è necessario fornire i dettagli di autenticazione dopo aver ottenuto l’oggetto database come segue.

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

    È possibile individuare facilmente i difetti nell’approccio precedente, l’autenticazione dovrebbe essere fatta in una fase precoce perché non possiamo recuperare da essa. Possiamo eliminare un database utilizzando il metodo dropDatabase(String db) di MongoClient o il metodo dropDatabase() di DB. Dato che stiamo eliminando il database, preferisco utilizzare il metodo di MongoClient.

  9. MongoDB e Collezioni

    Ogni database può avere zero o più collezioni, sono simili alle tabelle nei server di database relazionali tranne che non hai un formato specifico dei dati. Pensalo come una lista generica rispetto a una lista di Stringhe in termini di linguaggio di programmazione Java. Possiamo ottenere tutti i nomi delle collezioni usando il codice qui sotto.

    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]

    Possiamo ottenere una collezione specifica fornendo il suo nome, come mostrato di seguito.

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

    Di nuovo, se la collezione non esiste, MongoDB la creerà per te. Tutti i dati in MongoDB vanno in qualche collezione, quindi a questo punto siamo pronti per eseguire operazioni di inserimento/aggiornamento/eliminazione. Possiamo usare il metodo drop() della classe DBCollection per eliminare una collezione dal database.

  10. Esempio Java MongoDB

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");
		
		//creare utente
		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());
		
		//esempio di lettura
		DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
		DBCursor cursor = col.find(query);
		while(cursor.hasNext()){
			System.out.println(cursor.next());
		}
		
		//esempio di aggiornamento
		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());
		
		//esempio di eliminazione
		result = col.remove(query);
		System.out.println(result.getUpsertedId());
		System.out.println(result.getN());
		System.out.println(result.isUpdateOfExisting());
		System.out.println(result.getLastConcern());
		
		//chiudere le risorse
		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)
```

Questo è tutto per iniziare con il driver Java di MongoDB, esploreremo ulteriori funzionalità nei prossimi articoli.

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