Bem-vindo ao Tutorial de Exemplo do MongoDB Java. Anteriormente, aprendemos como instalar o MongoDB em máquinas Unix e executamos alguns comandos pelo terminal. Hoje, vamos explorar as funcionalidades do Driver MongoDB Java e como realizar operações comuns de CRUD (Create, Read, Update, Delete).
MongoDB Java
-
Download do Driver Java MongoDB
Se você possui um projeto Maven, apenas adicione a dependência abaixo para incluir o driver Java do MongoDB em sua aplicação.
<dependency> <groupId>org.mongodb</groupId> <artifactId>mongo-java-driver</artifactId> <version>2.12.3</version> </dependency>Se você possui um projeto independente, você pode baixar o Driver Java do MongoDB a partir deste link e incluí-lo no caminho de construção do seu projeto. Agora, vamos revisar alguns usos básicos do driver Java do MongoDB e então examinaremos o programa de Exemplo Java do MongoDB para operações CRUD.
-
Criando Conexão Java com o MongoDB
MongoClient é a interface entre nosso programa Java e o servidor MongoDB.
MongoClienté usado para criar conexão, conectar ao banco de dados, recuperar nomes de coleções e criar/lêr/atualizar/excluir bancos de dados, coleções, documentos, etc. Uma das características do driver Java do MongoDB que mais gosto é que ele é seguro para threads, então podemos criar uma instância deMongoClientuma vez e reutilizá-la. Mesmo que vários threads acessem simultaneamente, uma conexão é retornada a partir do pool de conexões interno mantido por ele. Para cada solicitação ao banco de dados (buscar, inserir etc.), a thread Java obterá uma conexão do pool, executará a operação e liberará a conexão. Isso significa que a conexão (socket) usada pode ser diferente a cada vez. Abaixo estão alguns dos métodos comuns para se conectar a um servidor MongoDB.MongoClient mongoClient = new MongoClient(); //conecta ao host e porta padrão, ou seja, 127.0.0.1:27017 // ou MongoClient mongoClient = new MongoClient( "localhost" ); //conecta à porta padrão, ou seja, 27017 // ou MongoClient mongoClient = new MongoClient( "localhost" , 27017 ); //deve-se usar sempre este // ou, para se conectar a um conjunto de réplicas, com descoberta automática do primário MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017), new ServerAddress("localhost", 27018), new ServerAddress("localhost", 27019))); -
Conexão com Banco de Dados MongoDB
Uma vez que obtemos a conexão com o servidor MongoDB, o próximo passo é criar a conexão com o banco de dados, como mostrado abaixo. Note que se o banco de dados não estiver presente, o MongoDB o criará para você.
MongoClient mongo = new MongoClient("localhost", 27017); DB db = mongo.getDB("journaldev");O MongoClient fornece um método útil para obter todos os nomes de banco de dados, como mostrado abaixo.
MongoClient mongo = new MongoClient("localhost", 27017); List<String> dbs = mongo.getDatabaseNames(); System.out.println(dbs); // [journaldev, local, admin]Pode-se ter autenticação baseada em usuário-senha para bancos de dados, nesse caso, precisamos fornecer credenciais de autorização como abaixo.
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 estiver usando versões mais antigas, é necessário fornecer detalhes de autenticação após obter o objeto do banco de dados como abaixo.
MongoClient mongo = new MongoClient("localhost", 27017); DB db = mongo.getDB("journaldev"); boolean auth = db.authenticate("pankaj", "pankaj123".toCharArray());É fácil perceber falhas na abordagem anterior, a autenticação deve ser feita em uma fase inicial, pois não podemos nos recuperar dela. Podemos excluir um banco de dados usando o método
dropDatabase(String db)do MongoClient ou o métododropDatabase()do DB. Como estamos excluindo o banco de dados, prefiro usar o método do MongoClient. -
MongoDB e Coleções
Cada banco de dados pode ter zero ou várias coleções, elas são como tabelas em servidores de banco de dados relacionais exceto que você não tem um formato específico de dados. Pense nisso como uma lista genérica vs lista de Strings em termos da linguagem de programação Java. Podemos obter todos os nomes das coleções usando o código abaixo.
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]Podemos obter uma coleção específica fornecendo seu nome, conforme mostrado abaixo.
DB db = mongo.getDB("journaldev"); DBCollection col = db.getCollection("users");Novamente, se a coleção não existir, o MongoDB a criará para você. Todos os dados no MongoDB vão para alguma coleção, então neste ponto estamos prontos para realizar operações de inserção/atualização/exclusão. Podemos usar o método
DBCollectiondrop()para excluir uma coleção do banco de dados. -
Exemplo de MongoDB Java
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");
//criar usuário
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());
//exemplo de leitura
DBObject query = BasicDBObjectBuilder.start().add("_id", user.getId()).get();
DBCursor cursor = col.find(query);
while(cursor.hasNext()){
System.out.println(cursor.next());
}
//exemplo de atualização
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());
//exemplo de exclusão
result = col.remove(query);
System.out.println(result.getUpsertedId());
System.out.println(result.getN());
System.out.println(result.isUpdateOfExisting());
System.out.println(result.getLastConcern());
//fechar recursos
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)
```
Isso é tudo para começar com o Driver Java do MongoDB, vamos explorar mais recursos nos próximos posts.
Source:
https://www.digitalocean.com/community/tutorials/mongodb-java-crud-example-tutorial