Getting Started with MongoDB and Java - CRUD Operations Tutorial

1
git clone git@github.com:mongodb-developer/java-quick-start.git

1
java-quick-start/
2
├── pom.xml
3
└── src
4
    └── main
5
        └── java
6
            └── com
7
                └── mongodb
8
                    └── quickstart

1
<?xml version="1.0" encoding="UTF-8"?>
2
<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
         xmlns="http://maven.apache.org/POM/4.0.0"
4
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
5
    <modelVersion>4.0.0</modelVersion>
6
7
    <groupId>com.mongodb</groupId>
8
    <artifactId>java-quick-start</artifactId>
9
    <version>1.0-SNAPSHOT</version>
10
11
    <properties>
12
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
13
        <maven-compiler-plugin.source>21</maven-compiler-plugin.source>
14
        <maven-compiler-plugin.target>21</maven-compiler-plugin.target>
15
        <maven-compiler-plugin.version>3.12.1</maven-compiler-plugin.version>
16
        <mongodb-driver-sync.version>5.0.0</mongodb-driver-sync.version>
17
        <mongodb-crypt.version>1.8.0</mongodb-crypt.version>
18
        <!-- Keeping 1.2.13 until mongodb-crypt makes slf4j-api an optional dependency -->
19
        <!-- https://jira.mongodb.org/browse/MONGOCRYPT-602 -->
20
        <logback-classic.version>1.2.13</logback-classic.version>
21
        <exec-maven-plugin.version>3.1.1</exec-maven-plugin.version>
22
    </properties>
23
24
    <dependencies>
25
        <dependency>
26
            <groupId>org.mongodb</groupId>
27
            <artifactId>mongodb-driver-sync</artifactId>
28
            <version>${mongodb-driver-sync.version}</version>
29
        </dependency>
30
        <dependency>
31
            <groupId>org.mongodb</groupId>
32
            <artifactId>mongodb-crypt</artifactId>
33
            <version>${mongodb-crypt.version}</version>
34
        </dependency>
35
        <dependency>
36
            <groupId>ch.qos.logback</groupId>
37
            <artifactId>logback-classic</artifactId>
38
            <version>${logback-classic.version}</version>
39
        </dependency>
40
    </dependencies>
41
42
    <build>
43
        <plugins>
44
            <plugin>
45
                <groupId>org.apache.maven.plugins</groupId>
46
                <artifactId>maven-compiler-plugin</artifactId>
47
                <version>${maven-compiler-plugin.version}</version>
48
                <configuration>
49
                    <source>${maven-compiler-plugin.source}</source>
50
                    <target>${maven-compiler-plugin.target}</target>
51
                </configuration>
52
            </plugin>
53
            <plugin>
54
                <!-- Adding this plugin, so we don't need to add -Dexec.cleanupDaemonThreads=false in the mvn cmd line -->
55
                <!-- to avoid the IllegalThreadStateException when running with Maven -->
56
                <groupId>org.codehaus.mojo</groupId>
57
                <artifactId>exec-maven-plugin</artifactId>
58
                <version>${exec-maven-plugin.version}</version>
59
                <configuration>
60
                    <cleanupDaemonThreads>false</cleanupDaemonThreads>
61
                </configuration>
62
            </plugin>
63
        </plugins>
64
    </build>
65
66
</project>

1
package com.mongodb.quickstart;
2
3
public class HelloMongoDB {
4
5
    public static void main(String[] args) {
6
        System.out.println("Hello MongoDB!");
7
    }
8
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.HelloMongoDB"

1
[INFO] Scanning for projects...
2
[INFO] 
3
[INFO] --------------------< com.mongodb:java-quick-start >--------------------
4
[INFO] Building java-quick-start 1.0-SNAPSHOT
5
[INFO] --------------------------------[ jar ]---------------------------------
6
[INFO] 
7
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ java-quick-start ---
8
[INFO] Using 'UTF-8' encoding to copy filtered resources.
9
[INFO] Copying 1 resource
10
[INFO] 
11
[INFO] --- maven-compiler-plugin:3.12.1:compile (default-compile) @ java-quick-start ---
12
[INFO] Nothing to compile - all classes are up to date.
13
[INFO] 
14
[INFO] --- exec-maven-plugin:3.1.1:java (default-cli) @ java-quick-start ---
15
Hello MongoDB!
16
[INFO] ------------------------------------------------------------------------
17
[INFO] BUILD SUCCESS
18
[INFO] ------------------------------------------------------------------------
19
[INFO] Total time:  0.634 s
20
[INFO] Finished at: 2024-02-19T18:12:22+01:00
21
[INFO] ------------------------------------------------------------------------

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import org.bson.Document;
6
import org.bson.json.JsonWriterSettings;
7
8
import java.util.ArrayList;
9
import java.util.List;
10
11
public class Connection {
12
13
    public static void main(String[] args) {
14
        String connectionString = System.getProperty("mongodb.uri");
15
        try (MongoClient mongoClient = MongoClients.create(connectionString)) {
16
            System.out.println("=> Connection successful: " + preFlightChecks(mongoClient));
17
            System.out.println("=> Print list of databases:");
18
            List<Document> databases = mongoClient.listDatabases().into(new ArrayList<>());
19
            databases.forEach(db -> System.out.println(db.toJson()));
20
        }
21
    }
22
23
    static boolean preFlightChecks(MongoClient mongoClient) {
24
        Document pingCommand = new Document("ping", 1);
25
        Document response = mongoClient.getDatabase("admin").runCommand(pingCommand);
26
        System.out.println("=> Print result of the '{ping: 1}' command.");
27
        System.out.println(response.toJson(JsonWriterSettings.builder().indent(true).build()));
28
        return response.get("ok", Number.class).intValue() == 1;
29
    }
30
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.Connection" -Dmongodb.uri="mongodb+srv://username:password@cluster0-abcde.mongodb.net/test?w=majority"

1
{"name": "admin", "sizeOnDisk": 303104.0, "empty": false}
2
{"name": "config", "sizeOnDisk": 147456.0, "empty": false}
3
{"name": "local", "sizeOnDisk": 5.44731136E8, "empty": false}
4
{"name": "sample_airbnb", "sizeOnDisk": 5.761024E7, "empty": false}
5
{"name": "sample_geospatial", "sizeOnDisk": 1384448.0, "empty": false}
6
{"name": "sample_mflix", "sizeOnDisk": 4.583424E7, "empty": false}
7
{"name": "sample_supplies", "sizeOnDisk": 1339392.0, "empty": false}
8
{"name": "sample_training", "sizeOnDisk": 7.4801152E7, "empty": false}
9
{"name": "sample_weatherdata", "sizeOnDisk": 5103616.0, "empty": false}

1
MongoDB Enterprise Cluster0-shard-0:PRIMARY> db.grades.findOne({student_id: 0, class_id: 339})
2
{
3
    "_id" : ObjectId("56d5f7eb604eb380b0d8d8ce"),
4
    "student_id" : 0,
5
    "scores" : [
6
        {
7
            "type" : "exam",
8
            "score" : 78.40446309504266
9
        },
10
        {
11
            "type" : "quiz",
12
            "score" : 73.36224783231339
13
        },
14
        {
15
            "type" : "homework",
16
            "score" : 46.980982486720535
17
        },
18
        {
19
            "type" : "homework",
20
            "score" : 76.67556138656222
21
        }
22
    ],
23
    "class_id" : 339
24
}

1
{
2
    "_id": {
3
        "$oid": "56d5f7eb604eb380b0d8d8ce"
4
    },
5
    "student_id": {
6
        "$numberDouble": "0"
7
    },
8
    "scores": [{
9
        "type": "exam",
10
        "score": {
11
            "$numberDouble": "78.40446309504266"
12
        }
13
    }, {
14
        "type": "quiz",
15
        "score": {
16
            "$numberDouble": "73.36224783231339"
17
        }
18
    }, {
19
        "type": "homework",
20
        "score": {
21
            "$numberDouble": "46.980982486720535"
22
        }
23
    }, {
24
        "type": "homework",
25
        "score": {
26
            "$numberDouble": "76.67556138656222"
27
        }
28
    }],
29
    "class_id": {
30
        "$numberDouble": "339"
31
    }
32
}

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import org.bson.Document;
8
9
public class Create {
10
11
    public static void main(String[] args) {
12
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
13
14
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
15
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
16
17
        }
18
    }
19
}

1
Random rand = new Random();
2
Document student = new Document("_id", new ObjectId());
3
student.append("student_id", 10000d)
4
       .append("class_id", 1d)
5
       .append("scores", List.of(new Document("type", "exam").append("score", rand.nextDouble() * 100),
6
                                 new Document("type", "quiz").append("score", rand.nextDouble() * 100),
7
                                 new Document("type", "homework").append("score", rand.nextDouble() * 100),
8
                                 new Document("type", "homework").append("score", rand.nextDouble() * 100)));

1
gradesCollection.insertOne(student);

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import org.bson.Document;
8
import org.bson.types.ObjectId;
9
10
import java.util.List;
11
import java.util.Random;
12
13
public class Create {
14
15
    public static void main(String[] args) {
16
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
17
18
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
19
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
20
21
            Random rand = new Random();
22
            Document student = new Document("_id", new ObjectId());
23
            student.append("student_id", 10000d)
24
                   .append("class_id", 1d)
25
                   .append("scores", List.of(new Document("type", "exam").append("score", rand.nextDouble() * 100),
26
                                             new Document("type", "quiz").append("score", rand.nextDouble() * 100),
27
                                             new Document("type", "homework").append("score", rand.nextDouble() * 100),
28
                                             new Document("type", "homework").append("score", rand.nextDouble() * 100)));
29
30
            gradesCollection.insertOne(student);
31
        }
32
    }
33
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.Create" -Dmongodb.uri="mongodb+srv://USERNAME:PASSWORD@cluster0-abcde.mongodb.net/test?w=majority"

1
{
2
    "_id": {
3
        "$oid": "5d97c375ded5651ea3462d0f"
4
    },
5
    "student_id": {
6
        "$numberDouble": "10000"
7
    },
8
    "class_id": {
9
        "$numberDouble": "1"
10
    },
11
    "scores": [{
12
        "type": "exam",
13
        "score": {
14
            "$numberDouble": "4.615256396625178"
15
        }
16
    }, {
17
        "type": "quiz",
18
        "score": {
19
            "$numberDouble": "73.06173415145801"
20
        }
21
    }, {
22
        "type": "homework",
23
        "score": {
24
            "$numberDouble": "19.378205578990727"
25
        }
26
    }, {
27
        "type": "homework",
28
        "score": {
29
            "$numberDouble": "82.3089189278531"
30
        }
31
    }]
32
}

1
Random rand = new Random();
2
Document student = new Document("_id", new ObjectId());
3
student.append("student_id", 10000d)
4
       .append("scores", List.of(new Document("type", "exam").append("score", rand.nextDouble() * 100),
5
                                 new Document("type", "quiz").append("score", rand.nextDouble() * 100),
6
                                 new Document("type", "homework").append("score", rand.nextDouble() * 100),
7
                                 new Document("type", "homework").append("score", rand.nextDouble() * 100)))
8
       .append("class_id", 1d);

1
private static final Random rand = new Random();

1
private static Document generateNewGrade(double studentId, double classId) {
2
    List<Document> scores = List.of(new Document("type", "exam").append("score", rand.nextDouble() * 100),
3
                                    new Document("type", "quiz").append("score", rand.nextDouble() * 100),
4
                                    new Document("type", "homework").append("score", rand.nextDouble() * 100),
5
                                    new Document("type", "homework").append("score", rand.nextDouble() * 100));
6
    return new Document("_id", new ObjectId()).append("student_id", studentId)
7
                                              .append("class_id", classId)
8
                                              .append("scores", scores);
9
}

1
List<Document> grades = new ArrayList<>();
2
for (double classId = 1d; classId <= 10d; classId++) {
3
    grades.add(generateNewGrade(10001d, classId));
4
}
5
6
gradesCollection.insertMany(grades, new InsertManyOptions().ordered(false));

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import com.mongodb.client.model.InsertManyOptions;
8
import org.bson.Document;
9
import org.bson.types.ObjectId;
10
11
import java.util.ArrayList;
12
import java.util.List;
13
import java.util.Random;
14
15
public class Create {
16
17
    private static final Random rand = new Random();
18
19
    public static void main(String[] args) {
20
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
21
22
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
23
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
24
25
            insertOneDocument(gradesCollection);
26
            insertManyDocuments(gradesCollection);
27
        }
28
    }
29
30
    private static void insertOneDocument(MongoCollection<Document> gradesCollection) {
31
        gradesCollection.insertOne(generateNewGrade(10000d, 1d));
32
        System.out.println("One grade inserted for studentId 10000.");
33
    }
34
35
    private static void insertManyDocuments(MongoCollection<Document> gradesCollection) {
36
        List<Document> grades = new ArrayList<>();
37
        for (double classId = 1d; classId <= 10d; classId++) {
38
            grades.add(generateNewGrade(10001d, classId));
39
        }
40
41
        gradesCollection.insertMany(grades, new InsertManyOptions().ordered(false));
42
        System.out.println("Ten grades inserted for studentId 10001.");
43
    }
44
45
    private static Document generateNewGrade(double studentId, double classId) {
46
        List<Document> scores = List.of(new Document("type", "exam").append("score", rand.nextDouble() * 100),
47
                                        new Document("type", "quiz").append("score", rand.nextDouble() * 100),
48
                                        new Document("type", "homework").append("score", rand.nextDouble() * 100),
49
                                        new Document("type", "homework").append("score", rand.nextDouble() * 100));
50
        return new Document("_id", new ObjectId()).append("student_id", studentId)
51
                                                  .append("class_id", classId)
52
                                                  .append("scores", scores);
53
    }
54
}

1
MongoDB Enterprise Cluster0-shard-0:PRIMARY> db.grades.findOne({"student_id":10000})
2
{
3
    "_id" : ObjectId("5daa0e274f52b44cfea94652"),
4
    "student_id" : 10000,
5
    "class_id" : 1,
6
    "scores" : [
7
        {
8
            "type" : "exam",
9
            "score" : 39.25175977753478
10
        },
11
        {
12
            "type" : "quiz",
13
            "score" : 80.2908713167313
14
        },
15
        {
16
            "type" : "homework",
17
            "score" : 63.5444978481843
18
        },
19
        {
20
            "type" : "homework",
21
            "score" : 82.35202261582563
22
        }
23
    ]
24
}

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.*;
4
import org.bson.Document;
5
6
import java.util.ArrayList;
7
import java.util.List;
8
9
import static com.mongodb.client.model.Filters.*;
10
import static com.mongodb.client.model.Projections.*;
11
import static com.mongodb.client.model.Sorts.descending;
12
13
public class Read {
14
15
    public static void main(String[] args) {
16
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
17
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
18
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
19
20
            // find one document with new Document
21
            Document student1 = gradesCollection.find(new Document("student_id", 10000)).first();
22
            System.out.println("Student 1: " + student1.toJson());
23
        }
24
    }
25
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.Read" -Dmongodb.uri="mongodb+srv://USERNAME:PASSWORD@cluster0-abcde.mongodb.net/test?w=majority"

1
Student 1: {"_id": {"$oid": "5daa0e274f52b44cfea94652"},
2
    "student_id": 10000.0,
3
    "class_id": 1.0,
4
    "scores": [
5
        {"type": "exam", "score": 39.25175977753478},
6
        {"type": "quiz", "score": 80.2908713167313},
7
        {"type": "homework", "score": 63.5444978481843},
8
        {"type": "homework", "score": 82.35202261582563}
9
    ]
10
}

1
gradesCollection.find(eq("student_id", 10000)).first();

1
import static com.mongodb.client.model.Filters.eq;

1
// without helpers
2
gradesCollection.find(new Document("student_id", new Document("$gte", 10000)));
3
// with the Filters.gte() helper
4
gradesCollection.find(gte("student_id", 10000));

1
FindIterable<Document> iterable = gradesCollection.find(gte("student_id", 10000));
2
MongoCursor<Document> cursor = iterable.iterator();
3
System.out.println("Student list with cursor: ");
4
while (cursor.hasNext()) {
5
    System.out.println(cursor.next().toJson());
6
}

1
List<Document> studentList = gradesCollection.find(gte("student_id", 10000)).into(new ArrayList<>());
2
System.out.println("Student list with an ArrayList:");
3
for (Document student : studentList) {
4
    System.out.println(student.toJson());
5
}

1
Consumer<Document> printConsumer = document -> System.out.println(document.toJson());
2
gradesCollection.find(gte("student_id", 10000)).forEach(printConsumer);

1
List<Document> docs = gradesCollection.find(and(eq("student_id", 10001), lte("class_id", 5)))
2
                                                  .projection(fields(excludeId(),
3
                                                                     include("class_id",
4
                                                                             "student_id")))
5
                                                  .sort(descending("class_id"))
6
                                                  .skip(2)
7
                                                  .limit(2)
8
                                                  .into(new ArrayList<>());
9
10
System.out.println("Student sorted, skipped, limited and projected: ");
11
for (Document student : docs) {
12
    System.out.println(student.toJson());
13
}

1
{"student_id": 10001.0, "class_id": 3.0}
2
{"student_id": 10001.0, "class_id": 2.0}

1
db.grades.createIndex({"student_id": 1, "class_id": -1})

1
"winningPlan" : {
2
            "stage" : "LIMIT",
3
            "limitAmount" : 2,
4
            "inputStage" : {
5
                "stage" : "PROJECTION_COVERED",
6
                "transformBy" : {
7
                    "_id" : 0,
8
                    "class_id" : 1,
9
                    "student_id" : 1
10
                },
11
                "inputStage" : {
12
                    "stage" : "SKIP",
13
                    "skipAmount" : 2,
14
                    "inputStage" : {
15
                        "stage" : "IXSCAN",
16
                        "keyPattern" : {
17
                            "student_id" : 1,
18
                            "class_id" : -1
19
                        },
20
                        "indexName" : "student_id_1_class_id_-1",
21
                        "isMultiKey" : false,
22
                        "multiKeyPaths" : {
23
                            "student_id" : [ ],
24
                            "class_id" : [ ]
25
                        },
26
                        "isUnique" : false,
27
                        "isSparse" : false,
28
                        "isPartial" : false,
29
                        "indexVersion" : 2,
30
                        "direction" : "forward",
31
                        "indexBounds" : {
32
                            "student_id" : [
33
                                "[10001.0, 10001.0]"
34
                            ],
35
                            "class_id" : [
36
                                "[5.0, -inf.0]"
37
                            ]
38
                        }
39
                    }
40
                }
41
            }
42
        }

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.*;
4
import org.bson.Document;
5
6
import java.util.ArrayList;
7
import java.util.List;
8
import java.util.function.Consumer;
9
10
import static com.mongodb.client.model.Filters.*;
11
import static com.mongodb.client.model.Projections.*;
12
import static com.mongodb.client.model.Sorts.descending;
13
14
public class Read {
15
16
    public static void main(String[] args) {
17
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
18
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
19
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
20
21
            // find one document with new Document
22
            Document student1 = gradesCollection.find(new Document("student_id", 10000)).first();
23
            System.out.println("Student 1: " + student1.toJson());
24
25
            // find one document with Filters.eq()
26
            Document student2 = gradesCollection.find(eq("student_id", 10000)).first();
27
            System.out.println("Student 2: " + student2.toJson());
28
29
            // find a list of documents and iterate throw it using an iterator.
30
            FindIterable<Document> iterable = gradesCollection.find(gte("student_id", 10000));
31
            MongoCursor<Document> cursor = iterable.iterator();
32
            System.out.println("Student list with a cursor: ");
33
            while (cursor.hasNext()) {
34
                System.out.println(cursor.next().toJson());
35
            }
36
37
            // find a list of documents and use a List object instead of an iterator
38
            List<Document> studentList = gradesCollection.find(gte("student_id", 10000)).into(new ArrayList<>());
39
            System.out.println("Student list with an ArrayList:");
40
            for (Document student : studentList) {
41
                System.out.println(student.toJson());
42
            }
43
44
            // find a list of documents and print using a consumer
45
            System.out.println("Student list using a Consumer:");
46
            Consumer<Document> printConsumer = document -> System.out.println(document.toJson());
47
            gradesCollection.find(gte("student_id", 10000)).forEach(printConsumer);
48
49
            // find a list of documents with sort, skip, limit and projection
50
            List<Document> docs = gradesCollection.find(and(eq("student_id", 10001), lte("class_id", 5)))
51
                                                  .projection(fields(excludeId(), include("class_id", "student_id")))
52
                                                  .sort(descending("class_id"))
53
                                                  .skip(2)
54
                                                  .limit(2)
55
                                                  .into(new ArrayList<>());
56
57
            System.out.println("Student sorted, skipped, limited and projected:");
58
            for (Document student : docs) {
59
                System.out.println(student.toJson());
60
            }
61
        }
62
    }
63
}

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import com.mongodb.client.model.FindOneAndUpdateOptions;
8
import com.mongodb.client.model.ReturnDocument;
9
import com.mongodb.client.model.UpdateOptions;
10
import com.mongodb.client.result.UpdateResult;
11
import org.bson.Document;
12
import org.bson.conversions.Bson;
13
import org.bson.json.JsonWriterSettings;
14
15
import static com.mongodb.client.model.Filters.and;
16
import static com.mongodb.client.model.Filters.eq;
17
import static com.mongodb.client.model.Updates.*;
18
19
public class Update {
20
21
    public static void main(String[] args) {
22
        JsonWriterSettings prettyPrint = JsonWriterSettings.builder().indent(true).build();
23
24
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
25
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
26
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
27
28
            // update one document
29
            Bson filter = eq("student_id", 10000);
30
            Bson updateOperation = set("comment", "You should learn MongoDB!");
31
            UpdateResult updateResult = gradesCollection.updateOne(filter, updateOperation);
32
            System.out.println("=> Updating the doc with {\"student_id\":10000}. Adding comment.");
33
            System.out.println(gradesCollection.find(filter).first().toJson(prettyPrint));
34
            System.out.println(updateResult);
35
        }
36
    }
37
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.Update" -Dmongodb.uri="mongodb+srv://USERNAME:PASSWORD@cluster0-abcde.mongodb.net/test?w=majority"

1
=> Updating the doc with {"student_id":10000}. Adding comment.
2
{
3
  "_id": {
4
    "$oid": "5dd5c1f351f97d4a034109ed"
5
  },
6
  "student_id": 10000.0,
7
  "class_id": 1.0,
8
  "scores": [
9
    {
10
      "type": "exam",
11
      "score": 21.580800815091415
12
    },
13
    {
14
      "type": "quiz",
15
      "score": 87.66967927111044
16
    },
17
    {
18
      "type": "homework",
19
      "score": 96.4060480668003
20
    },
21
    {
22
      "type": "homework",
23
      "score": 75.44966835508427
24
    }
25
  ],
26
  "comment": "You should learn MongoDB!"
27
}
28
AcknowledgedUpdateResult{matchedCount=1, modifiedCount=1, upsertedId=null}

1
filter = and(eq("student_id", 10002d), eq("class_id", 10d));
2
updateOperation = push("comments", "You will learn a lot if you read the MongoDB blog!");
3
UpdateOptions options = new UpdateOptions().upsert(true);
4
updateResult = gradesCollection.updateOne(filter, updateOperation, options);
5
System.out.println("\n=> Upsert document with {\"student_id\":10002.0, \"class_id\": 10.0} because it doesn't exist yet.");
6
System.out.println(updateResult);
7
System.out.println(gradesCollection.find(filter).first().toJson(prettyPrint));

1
=> Upsert document with {"student_id":10002.0, "class_id": 10.0} because it doesn't exist yet.
2
AcknowledgedUpdateResult{matchedCount=0, modifiedCount=0, upsertedId=BsonObjectId{value=5ddeb7b7224ad1d5cfab3733}}
3
{
4
  "_id": {
5
    "$oid": "5ddeb7b7224ad1d5cfab3733"
6
  },
7
  "class_id": 10.0,
8
  "student_id": 10002.0,
9
  "comments": [
10
    "You will learn a lot if you read the MongoDB blog!"
11
  ]
12
}

1
filter = eq("student_id", 10001);
2
updateResult = gradesCollection.updateMany(filter, updateOperation);
3
System.out.println("\n=> Updating all the documents with {\"student_id\":10001}.");
4
System.out.println(updateResult);

1
=> Updating all the documents with {"student_id":10001}.
2
AcknowledgedUpdateResult{matchedCount=10, modifiedCount=10, upsertedId=null}

1
// findOneAndUpdate
2
filter = eq("student_id", 10000);
3
Bson update1 = inc("x", 10); // increment x by 10. As x doesn't exist yet, x=10.
4
Bson update2 = rename("class_id", "new_class_id"); // rename variable "class_id" in "new_class_id".
5
Bson update3 = mul("scores.0.score", 2); // multiply the first score in the array by 2.
6
Bson update4 = addToSet("comments", "This comment is uniq"); // creating an array with a comment.
7
Bson update5 = addToSet("comments", "This comment is uniq"); // using addToSet so no effect.
8
Bson updates = combine(update1, update2, update3, update4, update5);
9
// returns the old version of the document before the update.
10
Document oldVersion = gradesCollection.findOneAndUpdate(filter, updates);
11
System.out.println("\n=> FindOneAndUpdate operation. Printing the old version by default:");
12
System.out.println(oldVersion.toJson(prettyPrint));
13
14
// but I can also request the new version
15
filter = eq("student_id", 10001);
16
FindOneAndUpdateOptions optionAfter = new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER);
17
Document newVersion = gradesCollection.findOneAndUpdate(filter, updates, optionAfter);
18
System.out.println("\n=> FindOneAndUpdate operation. But we can also ask for the new version of the doc:");
19
System.out.println(newVersion.toJson(prettyPrint));

1
=> FindOneAndUpdate operation. Printing the old version by default:
2
{
3
  "_id": {
4
    "$oid": "5dd5d46544fdc35505a8271b"
5
  },
6
  "student_id": 10000.0,
7
  "class_id": 1.0,
8
  "scores": [
9
    {
10
      "type": "exam",
11
      "score": 69.52994626959251
12
    },
13
    {
14
      "type": "quiz",
15
      "score": 87.27457417188077
16
    },
17
    {
18
      "type": "homework",
19
      "score": 83.40970667948744
20
    },
21
    {
22
      "type": "homework",
23
      "score": 40.43663797673247
24
    }
25
  ],
26
  "comment": "You should learn MongoDB!"
27
}
28
29
=> FindOneAndUpdate operation. But we can also ask for the new version of the doc:
30
{
31
  "_id": {
32
    "$oid": "5dd5d46544fdc35505a82725"
33
  },
34
  "student_id": 10001.0,
35
  "scores": [
36
    {
37
      "type": "exam",
38
      "score": 138.42535412437857
39
    },
40
    {
41
      "type": "quiz",
42
      "score": 84.66740178906916
43
    },
44
    {
45
      "type": "homework",
46
      "score": 36.773091359279675
47
    },
48
    {
49
      "type": "homework",
50
      "score": 14.90842128691825
51
    }
52
  ],
53
  "comments": [
54
    "You will learn a lot if you read the MongoDB blog!",
55
    "This comment is uniq"
56
  ],
57
  "new_class_id": 10.0,
58
  "x": 10
59
}

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import com.mongodb.client.model.FindOneAndUpdateOptions;
8
import com.mongodb.client.model.ReturnDocument;
9
import com.mongodb.client.model.UpdateOptions;
10
import com.mongodb.client.result.UpdateResult;
11
import org.bson.Document;
12
import org.bson.conversions.Bson;
13
import org.bson.json.JsonWriterSettings;
14
15
import static com.mongodb.client.model.Filters.and;
16
import static com.mongodb.client.model.Filters.eq;
17
import static com.mongodb.client.model.Updates.*;
18
19
public class Update {
20
21
    public static void main(String[] args) {
22
        JsonWriterSettings prettyPrint = JsonWriterSettings.builder().indent(true).build();
23
24
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
25
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
26
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
27
28
            // update one document
29
            Bson filter = eq("student_id", 10000);
30
            Bson updateOperation = set("comment", "You should learn MongoDB!");
31
            UpdateResult updateResult = gradesCollection.updateOne(filter, updateOperation);
32
            System.out.println("=> Updating the doc with {\"student_id\":10000}. Adding comment.");
33
            System.out.println(gradesCollection.find(filter).first().toJson(prettyPrint));
34
            System.out.println(updateResult);
35
36
            // upsert
37
            filter = and(eq("student_id", 10002d), eq("class_id", 10d));
38
            updateOperation = push("comments", "You will learn a lot if you read the MongoDB blog!");
39
            UpdateOptions options = new UpdateOptions().upsert(true);
40
            updateResult = gradesCollection.updateOne(filter, updateOperation, options);
41
            System.out.println("\n=> Upsert document with {\"student_id\":10002.0, \"class_id\": 10.0} because it doesn't exist yet.");
42
            System.out.println(updateResult);
43
            System.out.println(gradesCollection.find(filter).first().toJson(prettyPrint));
44
45
            // update many documents
46
            filter = eq("student_id", 10001);
47
            updateResult = gradesCollection.updateMany(filter, updateOperation);
48
            System.out.println("\n=> Updating all the documents with {\"student_id\":10001}.");
49
            System.out.println(updateResult);
50
51
            // findOneAndUpdate
52
            filter = eq("student_id", 10000);
53
            Bson update1 = inc("x", 10); // increment x by 10. As x doesn't exist yet, x=10.
54
            Bson update2 = rename("class_id", "new_class_id"); // rename variable "class_id" in "new_class_id".
55
            Bson update3 = mul("scores.0.score", 2); // multiply the first score in the array by 2.
56
            Bson update4 = addToSet("comments", "This comment is uniq"); // creating an array with a comment.
57
            Bson update5 = addToSet("comments", "This comment is uniq"); // using addToSet so no effect.
58
            Bson updates = combine(update1, update2, update3, update4, update5);
59
            // returns the old version of the document before the update.
60
            Document oldVersion = gradesCollection.findOneAndUpdate(filter, updates);
61
            System.out.println("\n=> FindOneAndUpdate operation. Printing the old version by default:");
62
            System.out.println(oldVersion.toJson(prettyPrint));
63
64
            // but I can also request the new version
65
            filter = eq("student_id", 10001);
66
            FindOneAndUpdateOptions optionAfter = new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER);
67
            Document newVersion = gradesCollection.findOneAndUpdate(filter, updates, optionAfter);
68
            System.out.println("\n=> FindOneAndUpdate operation. But we can also ask for the new version of the doc:");
69
            System.out.println(newVersion.toJson(prettyPrint));
70
        }
71
    }
72
}

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import com.mongodb.client.result.DeleteResult;
8
import org.bson.Document;
9
import org.bson.conversions.Bson;
10
11
import static com.mongodb.client.model.Filters.eq;
12
import static com.mongodb.client.model.Filters.gte;
13
14
public class Delete {
15
16
    public static void main(String[] args) {
17
18
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
19
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
20
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
21
22
            // delete one document
23
            Bson filter = eq("student_id", 10000);
24
            DeleteResult result = gradesCollection.deleteOne(filter);
25
            System.out.println(result);
26
        }
27
    }
28
}

1
mvn compile exec:java -Dexec.mainClass="com.mongodb.quickstart.Delete" -Dmongodb.uri="mongodb+srv://USERNAME:PASSWORD@cluster0-abcde.mongodb.net/test?w=majority"

1
AcknowledgedDeleteResult{deletedCount=1}

1
Bson filter = eq("student_id", 10002);
2
Document doc = gradesCollection.findOneAndDelete(filter);
3
System.out.println(doc.toJson(JsonWriterSettings.builder().indent(true).build()));

1
{
2
  "_id": {
3
    "$oid": "5ddec378224ad1d5cfac02b8"
4
  },
5
  "class_id": 10.0,
6
  "student_id": 10002.0,
7
  "comments": [
8
    "You will learn a lot if you read the MongoDB blog!"
9
  ]
10
}

1
Bson filter = gte("student_id", 10000);
2
DeleteResult result = gradesCollection.deleteMany(filter);
3
System.out.println(result);

1
AcknowledgedDeleteResult{deletedCount=10}

1
gradesCollection.drop();

1
package com.mongodb.quickstart;
2
3
import com.mongodb.client.MongoClient;
4
import com.mongodb.client.MongoClients;
5
import com.mongodb.client.MongoCollection;
6
import com.mongodb.client.MongoDatabase;
7
import com.mongodb.client.result.DeleteResult;
8
import org.bson.Document;
9
import org.bson.conversions.Bson;
10
import org.bson.json.JsonWriterSettings;
11
12
import static com.mongodb.client.model.Filters.eq;
13
import static com.mongodb.client.model.Filters.gte;
14
15
public class Delete {
16
17
    public static void main(String[] args) {
18
        try (MongoClient mongoClient = MongoClients.create(System.getProperty("mongodb.uri"))) {
19
            MongoDatabase sampleTrainingDB = mongoClient.getDatabase("sample_training");
20
            MongoCollection<Document> gradesCollection = sampleTrainingDB.getCollection("grades");
21
22
            // delete one document
23
            Bson filter = eq("student_id", 10000);
24
            DeleteResult result = gradesCollection.deleteOne(filter);
25
            System.out.println(result);
26
27
            // findOneAndDelete operation
28
            filter = eq("student_id", 10002);
29
            Document doc = gradesCollection.findOneAndDelete(filter);
30
            System.out.println(doc.toJson(JsonWriterSettings.builder().indent(true).build()));
31
32
            // delete many documents
33
            filter = gte("student_id", 10000);
34
            result = gradesCollection.deleteMany(filter);
35
            System.out.println(result);
36
37
            // delete the entire collection and its metadata (indexes, chunk metadata, etc).
38
            gradesCollection.drop();
39
        }
40
    }
41
}