MongoDB Async Driver Quick Tour

The following code snippets come from the QuickTour.java example code that can be found with the async driver source.

Going Async with Callbacks

The MongoDB Async driver provides an asynchronous API that can leverage either Netty or Java 7’s AsynchronousSocketChannel for fast and non-blocking IO.

The API mirrors the new Synchronous API from the MongoDB Driver, but any methods that cause network IO take a SingleResponseCallback<T> and return immediately, where T is the type of response for the document.

The SingleResponseCallback<T> interface requires the implementation of a single method onResult(T result, Throwable t) which is called when the operation has completed. The result parameter contains the result of the operation, if successful. If the operation failed for any reason then the t contains the Throwable reason for the failure.

Make a Connection

The following example shows multiple ways to connect to the database mydb on the local machine, using the MongoClients.create helper.

// To directly connect to the default server localhost on port 27017
MongoClient mongoClient = MongoClients.create();

// Use a Connection String
MongoClient mongoClient = MongoClients.create("mongodb://localhost");

// or a Connection String
MongoClient mongoClient = MongoClients.create(new ConnectionString("mongodb://localhost"));

// or provide custom MongoClientSettings
ClusterSettings clusterSettings = ClusterSettings.builder().hosts(asList(new ServerAddress("localhost"))).build();
MongoClientSettings settings = MongoClientSettings.builder().clusterSettings(clusterSettings).build();
MongoClient mongoClient = MongoClients.create(settings);

MongoDatabase database = mongoClient.getDatabase("mydb");

At this point, the database object will be a connection to a MongoDB server for the specified database.

MongoClient

The MongoClient instance actually represents a pool of connections to the database; you will only need one instance of class MongoClient even with multiple concurrently executing asynchronous operations.

Get a Collection

To get a collection to operate upon, specify the name of the collection to the getCollection(String collectionName) method:

The following example gets the collection test:

MongoCollection<Document> collection = database.getCollection("test");

Insert a Document

Once you have the collection object, you can insert documents into the collection. For example, consider the following JSON document; the document contains a field info which is an embedded document:

{
   "name" : "MongoDB",
   "type" : "database",
   "count" : 1,
   "info" : {
               x : 203,
               y : 102
             }
}

To create the document using the Java driver, use the Document class. You can use this class to create the embedded document as well.

Document doc = new Document("name", "MongoDB")
               .append("type", "database")
               .append("count", 1)
               .append("info", new Document("x", 203).append("y", 102));

To insert the document into the collection, use the insertOne() method.

collection.insertOne(doc, new SingleResultCallback<Void>() {
    @Override
    public void onResult(final Void result, final Throwable t) {
        System.out.println("Inserted!");
    }
});

As SingleResponseCallback<T> is a functional interface and it can be implemented as a lambda for users on Java 8:

collection.insertOne(doc, (Void result, final Throwable t) -> System.out.println("Inserted!"));

Once the document has been inserted the onResult callback will be called and it will print “Inserted!”. Remember, in a normal application you would always check for the presence of errors in the t variable.

Add Multiple Documents

To add multiple documents, you can use the insertMany() method.

The following example will add multiple documents of the form:

{ "i" : value }

Create the documents in a loop.

List<Document> documents = new ArrayList<Document>();
for (int i = 0; i < 100; i++) {
    documents.add(new Document("i", i));
}

To insert these documents to the collection, pass the list of documents to the insertMany() method.

collection.insertMany(documents, new SingleResultCallback<Void>() {
    @Override
    public void onResult(final Void result, final Throwable t) {
        System.out.println("Documents inserted!");
    }
});

Count Documents in A Collection

Now that we’ve inserted 101 documents (the 100 we did in the loop, plus the first one), we can check to see if we have them all using the count() method. The following code should print 101.

collection.count(
  new SingleResultCallback<Long>() {
      @Override
      public void onResult(final Long count, final Throwable t) {
          System.out.println(count);
      }
  });

Query the Collection

Use the find() method to query the collection.

Find the First Document in a Collection

To get the first document in the collection, call the first() method on the find() operation. collection.find().first() returns the first document or null rather than a cursor. This is useful for queries that should only match a single document, or if you are interested in the first document only.

SingleResultCallback<Document> printDocument = new SingleResultCallback<Document>() {
    @Override
    public void onResult(final Document document, final Throwable t) {
        System.out.println(document.toJson());
    }
};

The following example passes the printDocument callback to the first method:

collection.find().first(printDocument);

The example will print the following document:

{ "_id" : { "$oid" : "551582c558c7b4fbacf16735" },
  "name" : "MongoDB", "type" : "database", "count" : 1,
  "info" : { "x" : 203, "y" : 102 } }

Find All Documents in a Collection

To retrieve all the documents in the collection, we will use the find() method. The find() method returns a FindIterable instance that provides a fluent interface for chaining or controlling find operations. Use the forEach() method to provide a Block to apply to each document and a callback that is run once the iteration has finished. The following code retrieves all documents in the collection and prints them out (101 documents) and then finally prints out “Operation Finished!”:

Block<Document> printDocumentBlock = new Block<Document>() {
    @Override
    public void apply(final Document document) {
        System.out.println(document.toJson());
    }
};
SingleResultCallback<Void> callbackWhenFinished = new SingleResultCallback<Void>() {
    @Override
    public void onResult(final Void result, final Throwable t) {
        System.out.println("Operation Finished!");
    }
};

collection.find().forEach(printDocumentBlock, callbackWhenFinished);

Get A Single Document with a Query Filter

We can create a filter to pass to the find() method to get a subset of the documents in our collection. For example, if we wanted to find the document for which the value of the “i” field is 71, we would do the following (reusing the printDocument callback):

import static com.mongodb.client.model.Filters.*;

collection.find(eq("i", 71)).first(printDocument);

will eventually print just one document:

{ "_id" : { "$oid" : "5515836e58c7b4fbc756320b" }, "i" : 71 }

Get a Set of Documents with a Query

We can use the query to get a set of documents from our collection. For example, if we wanted to get all documents where "i" > 50, we could write (reusing printDocumentBlock block and callbackWhenFinished callback):

// now use a range query to get a larger subset
collection.find(gt("i", 50)).forEach(printDocumentBlock, callbackWhenFinished);

which should print the documents where i > 50.

We could also get a range, say 50 < i <= 100:

collection.find(and(gt("i", 50), lte("i", 100))).forEach(printDocumentBlock, callbackWhenFinished);

Sorting documents

We can also use the Sorts helpers to sort documents. We add a sort to a find query by calling the sort() method on a FindIterable. Below we use the exists() helper and sort descending("i") helper to sort our documents:

collection.find(exists("i")).sort(descending("i")).first(printDocument);

Projecting fields

Sometimes we don’t need all the data contained in a document. The Projections helpers can be used to build the projection parameter for the find operation and limit the fields returned.
Below we’ll sort the collection, exclude the _id field and output the first matching document:

collection.find().projection(excludeId()).first(printDocument);

Aggregations

Sometimes we need to aggregate the data stored in MongoDB. The Aggregates helper provides builders for each of type of aggregation stage.

Below we’ll do a simple two step transformation that will calculate the value of i * 10. First we find all Documents where i > 0 by using the Aggregates.match helper. Then we reshape the document by using Aggregates.project in conjunction with the $multiply operator to calculate the “ITimes10” value:

collection.aggregate(asList(
    match(gt("i", 0)),
    project(Document.parse("{ITimes10: {$multiply: ['$i', 10]}}")))
).forEach(printDocumentBlock, callbackWhenFinished);

For $group operations use the Accumulators helper for any accumulator operations. Below we sum up all the values of i by using the Aggregates.group helper in conjunction with the Accumulators.sum helper:

collection.aggregate(singletonList(group(null, sum("total", "$i")))).first(printDocument);

Updating documents

There are numerous update operators supported by MongoDB.

To update at most a single document (may be 0 if none match the filter), use the updateOne method to specify the filter and the update document. Here we use the Updates.set helper to update the first document that meets the filter i equals 10 and set the value of i to 110:

collection.updateOne(eq("i", 10), set("i", 110),
    new SingleResultCallback<UpdateResult>() {
        @Override
        public void onResult(final UpdateResult result, final Throwable t) {
            System.out.println(result.getModifiedCount());
        }
    });

To update all documents matching the filter use the updateMany method. Here we use the Updates.inc helper to increment the value of i by 100 where i is less than 100.

collection.updateMany(lt("i", 100), inc("i", 100),
    new SingleResultCallback<UpdateResult>() {
        @Override
        public void onResult(final UpdateResult result, final Throwable t) {
            System.out.println(result.getModifiedCount());
        }
    });

The update methods return an UpdateResult, which provides information about the operation including the number of documents modified by the update.

Deleting documents

To delete at most a single document (may be 0 if none match the filter) use the deleteOne method:

collection.deleteOne(eq("i", 110), new SingleResultCallback<DeleteResult>() {
    @Override
    public void onResult(final DeleteResult result, final Throwable t) {
        System.out.println(result.getDeletedCount());
    }
});

To delete all documents matching the filter use the deleteMany method. Here we delete all documents where i is greater or equal to 100:

collection.deleteMany(gte("i", 100), new SingleResultCallback<DeleteResult>() {
    @Override
    public void onResult(final DeleteResult result, final Throwable t) {
        System.out.println(result.getDeletedCount());
    }
});

The delete methods return a DeleteResult, which provides information about the operation including the number of documents deleted.

Bulk operations

These commands allow for the execution of bulk insert/update/delete operations. There are two types of bulk operations:

1. Ordered bulk operations.

   Executes all the operation in order and error out on the first write error.

2. Unordered bulk operations.

   Executes all the operations and reports any the errors.

   Unordered bulk operations do not guarantee order of execution.

Let’s look at two simple examples using ordered and unordered operations:

SingleResultCallback<BulkWriteResult> printBatchResult = new SingleResultCallback<BulkWriteResult>() {
    @Override
    public void onResult(final BulkWriteResult result, final Throwable t) {
        System.out.println(result);
    }
};

// 2. Ordered bulk operation - order is guaranteed
collection.bulkWrite(
  Arrays.asList(new InsertOneModel<>(new Document("_id", 4)),
                new InsertOneModel<>(new Document("_id", 5)),
                new InsertOneModel<>(new Document("_id", 6)),
                new UpdateOneModel<>(new Document("_id", 1),
                                     new Document("$set", new Document("x", 2))),
                new DeleteOneModel<>(new Document("_id", 2)),
                new ReplaceOneModel<>(new Document("_id", 3),
                                      new Document("_id", 3).append("x", 4))),
  printBatchResult
);


 // 2. Unordered bulk operation - no guarantee of order of operation
collection.bulkWrite(
  Arrays.asList(new InsertOneModel<>(new Document("_id", 4)),
                new InsertOneModel<>(new Document("_id", 5)),
                new InsertOneModel<>(new Document("_id", 6)),
                new UpdateOneModel<>(new Document("_id", 1),
                                     new Document("$set", new Document("x", 2))),
                new DeleteOneModel<>(new Document("_id", 2)),
                new ReplaceOneModel<>(new Document("_id", 3),
                                      new Document("_id", 3).append("x", 4))),
  new BulkWriteOptions().ordered(false),
  printBatchResult
);