MongoDB Java 教程

{% raw %}

MongoDB Java 教程

在本教程中，我们将展示如何在 Java 中使用 MongoDB。在 ZetCode 上有一个简洁的 Java 教程。

MongoDB 是 NoSQL 跨平台的面向文档的数据库。它是可用的最受欢迎的数据库之一。 MongoDB 由 MongoDB Inc. 开发，并作为免费和开源软件发布。

MongoDB 中的记录是一个文档，它是由字段和值对组成的数据结构。 MongoDB 文档与 JSON 对象相似。字段的值可以包括其他文档，数组和文档数组。 MongoDB 将文档存储在集合中。集合类似于关系数据库中的表以及行中的文档。

安装 MongoDB

以下命令可用于在基于 Debian 的 Linux 上安装 MongoDB。

$ sudo apt-get install mongodb

该命令将安装 MongoDB 随附的必要包。

$ sudo service mongodb status
mongodb start/running, process 975

使用sudo service mongodb status命令，我们检查mongodb服务器的状态。

$ sudo service mongodb start
mongodb start/running, process 6448

mongodb服务器由sudo service mongodb start命令启动。

建立数据库

mongo工具是 MongoDB 的交互式 JavaScript Shell 界面，它为系统管理员提供了一个界面，并为开发者提供了一种直接测试数据库查询和操作的方法。

$ mongo testdb
MongoDB shell version v4.0.7
connecting to: mongodb://127.0.0.1:27017/testdb?gssapiServiceName=mongodb
...
> db
testdb
> db.cars.insert({name: "Audi", price: 52642})
> db.cars.insert({name: "Mercedes", price: 57127})
> db.cars.insert({name: "Skoda", price: 9000})
> db.cars.insert({name: "Volvo", price: 29000})
> db.cars.insert({name: "Bentley", price: 350000})
> db.cars.insert({name: "Citroen", price: 21000})
> db.cars.insert({name: "Hummer", price: 41400})
> db.cars.insert({name: "Volkswagen", price: 21600})

我们创建一个testdb数据库，并在cars集合中插入八个文档。

Java MongoDB 驱动程序

我们使用以下 Maven 声明在项目中包括 MongoDB Java 驱动程序。

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>x.y.z</version>
</dependency>

它是一个多功能的 JAR，它嵌入了核心驱动程序和 BSON。 BSON 是 Binaryary JSON 的缩写，是类似于 JSON 的文档的二进制编码的序列化。

Java MongoDB 列出数据库集合

第一个示例连接到testdb数据库并检索其集合。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
         http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.zetcode</groupId>
    <artifactId>mongocommand</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>11</maven.compiler.source>
        <maven.compiler.target>11</maven.compiler.target>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongo-java-driver</artifactId>
            <version>3.10.2</version>
        </dependency>
    </dependencies>
</project>

这是我们的pom.xml文件。

com/zetcode/MongoListCollections.java

package com.zetcode;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoDatabase;
import java.util.logging.Level;
import java.util.logging.Logger;
public class MongoListCollections {
    public static void main(String[] args) {
        Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
        mongoLogger.setLevel(Level.SEVERE);
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            MongoDatabase database = mongoClient.getDatabase("testdb");
            for (String name : database.listCollectionNames()) {
                System.out.println(name);
            }
        }
    }
}

该示例连接到testdb数据库并检索其所有集合。

Logger mongoLogger = Logger.getLogger("org.mongodb.driver");
mongoLogger.setLevel(Level.SEVERE);

我们为 MongoDB 设置日志记录级别。我们仅显示严重错误消息。

try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {

MongoClient类用于连接到 MongoDB 服务器。它是通过MongoClients.create()方法调用创建的。 27017 是 MongoDB 服务器监听的默认端口。

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

使用getDatabase()方法，我们检索了testdb数据库。

for (String name : database.listCollectionNames()) {
    System.out.println(name);
}

listCollectionNames()方法在testdb数据库中找到所有集合。

cars
cities

在我们的数据库中，我们有这两个集合。

Java MongoDB 数据库统计

下一个示例连接到testdb数据库并获取其统计信息。

com/zetcode/MongoCommand.java

package com.zetcode;
import com.mongodb.client.MongoClients;
import org.bson.Document;
import java.util.Map;
public class MongoCommand {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            var stats = database.runCommand(new Document("dbstats", 1));
            for (Map.Entry<String, Object> set : stats.entrySet()) {
                System.out.format("%s: %s%n", set.getKey(), set.getValue());
            }
        }
    }
}

该示例连接到testdb数据库并执行dbstats命令。它显示了一些数据库统计信息。

var stats = database.runCommand(new Document("dbstats", 1));

使用runCommand()方法，执行dbstats命令。该命令返回Document，它表示 MongoDB 文档作为映射。

for (Map.Entry<String, Object> set : stats.entrySet()) {
    System.out.format("%s: %s%n", set.getKey(), set.getValue());
}

我们遍历文档的条目。

db: testdb
collections: 2
views: 0
objects: 9
avgObjSize: 48.111111111111114
dataSize: 433.0
storageSize: 57344.0
numExtents: 0
indexes: 2
indexSize: 57344.0
fsUsedSize: 1.4818904064E11
fsTotalSize: 2.547211264E11
ok: 1.0

这是一个示例输出。

Java MongoDB 读取数据

MongoCollection用于存储从集合返回的 mongo 文档。 MongoCursor是一个游标，用于遍历数据库查询的结果。确保在发生异常时将其关闭。

com/zetcode/MongoReadAll.java

package com.zetcode;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import org.bson.Document;
import java.util.ArrayList;
public class MongoReadAll {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            try (MongoCursor<Document> cur = collection.find().iterator()) {
                while (cur.hasNext()) {
                    var doc = cur.next();
                    var cars = new ArrayList<>(doc.values());
                    System.out.printf("%s: %s%n", cars.get(1), cars.get(2));
                }
            }
        }
    }
}

在示例中，我们遍历cars集合的所有数据。

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

我们使用getCollection()方法检索cars集合。

try (MongoCursor<Document> cur = collection.find().iterator()) {
    while (cur.hasNext()) {
        var doc = cur.next();
        var cars = new ArrayList<>(doc.values());
        System.out.printf("%s: %s%n", cars.get(1), cars.get(2));
    }
}

我们遍历集合的文档。 find()方法查找集合中的所有文档。

Audi: 52642.0
Mercedes: 57127.0
Skoda: 9000.0
Volvo: 29000.0
Bentley: 350000.0
Citroen: 21000.0
Hummer: 41400.0
Volkswagen: 21600.0

这是示例的输出。

Java MongoDB 查询运算符

可以使用 MongoDB 查询运算符（例如$gt，$lt或$ne）过滤数据。可以在BasicDBObject类中指定查询运算符。

com/zetcode/MongoReadGreaterThan.java

package com.zetcode;
import com.mongodb.BasicDBObject;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import java.util.function.Consumer;
public class MongoReadGreaterThan {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            var query = new BasicDBObject("price",
                    new BasicDBObject("$gt", 30000));
            collection.find(query).forEach((Consumer<Document>) doc ->
                     System.out.println(doc.toJson()));
        }
    }
}

该示例打印汽车价格大于 30,000 的所有文档。

var query = new BasicDBObject("price",
    new BasicDBObject("$gt", 30000));

我们使用$gt查询运算符。

collection.find(query).forEach((Consumer<Document>) doc ->
    System.out.println(doc.toJson()));

forEach()方法是一种语法糖，可以避免应用代码担心不必手动关闭游标。使用toJson()方法以 JSON 格式打印数据。

{"_id": {"$oid": "5d4d13d6463315268eb7376b"}, "name": "Audi", "price": 52642.0}
{"_id": {"$oid": "5d4d13f5463315268eb7376c"}, "name": "Mercedes", "price": 57127.0}
{"_id": {"$oid": "5d4d140d463315268eb7376f"}, "name": "Bentley", "price": 350000.0}
{"_id": {"$oid": "5d4d1415463315268eb73771"}, "name": "Hummer", "price": 41400.0}

这是 JSON 格式的示例输出。仅包括价格超过 30,000 的汽车。

Java MongoDB 工厂过滤器查询方法

Java MongoDB 驱动包含查询过滤器的工厂方法。

com/zetcode/MongoFilter.java

package com.zetcode;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import java.util.ArrayList;
import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.gt;
import static com.mongodb.client.model.Filters.lt;
public class MongoFilter {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            FindIterable fit = collection.find(and(lt("price", 50000),
                    gt("price", 20000))).sort(new Document("price", -1));
            var docs = new ArrayList<Document>();
            fit.into(docs);
            for (Document doc : docs) {
                System.out.println(doc);
            }
        }
    }
}

在示例中，我们检索价格在 20,000 到 50,000 之间的汽车。

FindIterable fit = collection.find(and(lt("price", 50000),
    gt("price", 20000))).sort(new Document("price", -1));

and()，gt()和lt()是工厂过滤方法。此外，数据使用sort()方法排序。

Document{{_id=5d4d1415463315268eb73771, name=Hummer, price=41400.0}}
Document{{_id=5d4d1408463315268eb7376e, name=Volvo, price=29000.0}}
Document{{_id=5d4d1419463315268eb73772, name=Volkswagen, price=21600.0}}
Document{{_id=5d4d1411463315268eb73770, name=Citroen, price=21000.0}}

This is the output of the example.

Java MongoDB 投影

Projections类为所有 MongoDB 投影运算符提供了静态工厂方法。默认情况下，将投影每个文档的所有字段。我们可以使用include和exclude()方法来确定应将哪些字段投影到我们的输出中。

com/zetcode/MongoProjection.java

package com.zetcode;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import java.util.ArrayList;
import static com.mongodb.client.model.Projections.excludeId;
public class MongoProjection {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            FindIterable it = collection.find().projection(excludeId());
            var docs = new ArrayList<Document>();
            it.into(docs);
            for (Document doc : docs) {
                System.out.println(doc);
            }
        }
    }
}

该示例从输出中排除_id字段。

FindIterable it = collection.find().projection(excludeId());

projection()方法设置一个文档，该文档描述要为所有匹配的文档返回的字段。 excludeId()是exclude("_id")的同义词。

Document{{name=Audi, price=52642.0}}
Document{{name=Mercedes, price=57127.0}}
Document{{name=Skoda, price=9000.0}}
Document{{name=Volvo, price=29000.0}}
Document{{name=Bentley, price=350000.0}}
Document{{name=Citroen, price=21000.0}}
Document{{name=Hummer, price=41400.0}}
Document{{name=Volkswagen, price=21600.0}}

这是示例的输出。

Java MongoDB 限制数据输出

limit查询选项指定要返回的文档数量，skip()选项指定某些文档。

com/zetcode/MongoSkipLimit.java

package com.zetcode;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import java.util.function.Consumer;
public class MongoSkipLimit {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            FindIterable<Document> fit = collection.find().skip(2).limit(5);
            fit.forEach((Consumer<Document>) System.out::println);
        }
    }
}

该示例从testdb.cars集合中读取，跳过前两个文档，并将输出限制为五个文档。

FindIterable<Document> fit = collection.find().skip(2).limit(5);

FindIterable的skip()方法跳过前两个文档，limit()方法将输出限制为五个文档。

fit.forEach((Consumer<Document>) System.out::println);

在这里，我们使用 Java8 构造来打印文档。

Document{{_id=5d4d13fb463315268eb7376d, name=Skoda, price=9000.0}}
Document{{_id=5d4d1408463315268eb7376e, name=Volvo, price=29000.0}}
Document{{_id=5d4d140d463315268eb7376f, name=Bentley, price=350000.0}}
Document{{_id=5d4d1411463315268eb73770, name=Citroen, price=21000.0}}
Document{{_id=5d4d1415463315268eb73771, name=Hummer, price=41400.0}}

This is the output of the example.

Java MongoDB 创建集合

MongoDatabase的createCollection()方法在数据库中创建一个新集合。 MongoCollection的insertMany()方法将一个或多个文档插入到集合中。

com/zetcode/MongoCreateCollection.java

package com.zetcode;
import com.mongodb.MongoCommandException;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import java.util.ArrayList;
public class MongoCreateCollection {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            try {
                database.createCollection("cars");
            } catch (MongoCommandException e) {
                database.getCollection("cars").drop();
            }
            var docs = new ArrayList<Document>();
            MongoCollection<Document> collection = database.getCollection("cars");
            var d1 = new Document("_id", 1);
            d1.append("name", "Audi");
            d1.append("price", 52642);
            docs.add(d1);
            var d2 = new Document("_id", 2);
            d2.append("name", "Mercedes");
            d2.append("price", 57127);
            docs.add(d2);
            var d3 = new Document("_id", 3);
            d3.append("name", "Skoda");
            d3.append("price", 9000);
            docs.add(d3);
            var d4 = new Document("_id", 4);
            d4.append("name", "Volvo");
            d4.append("price", 29000);
            docs.add(d4);
            var d5 = new Document("_id", 5);
            d5.append("name", "Bentley");
            d5.append("price", 350000);
            docs.add(d5);
            var d6 = new Document("_id", 6);
            d6.append("name", "Citroen");
            d6.append("price", 21000);
            docs.add(d6);
            var d7 = new Document("_id", 7);
            d7.append("name", "Hummer");
            d7.append("price", 41400);
            docs.add(d7);
            var d8 = new Document("_id", 8);
            d8.append("name", "Volkswagen");
            d8.append("price", 21600);
            docs.add(d8);
            collection.insertMany(docs);
        }
    }
}

该示例创建一个cars集合并将 9 个文档插入其中。

try {
    database.createCollection("cars");
} catch (MongoCommandException e) {
    database.getCollection("cars").drop();
}

使用createCollection()方法创建一个新集合。如果该集合已经存在，则将其删除。

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

使用getCollection()方法创建文档的MongoCollection。

var d1 = new Document("_id", 1);
d1.append("name", "Audi");
d1.append("price", 52642);
docs.add(d1);

创建一个新的Document。它包含有关汽车的信息，包括其 ID，名称和价格。

collection.insertMany(docs);

使用insertMany()方法将文档写入集合。

Java MongoDB 从 JSON 创建集合

JSON类具有用于解析 JSON 文档的方法。 JSON （JavaScript 对象表示法）是一种轻量级的数据交换格式。人类易于阅读和书写。

com/zetcode/MongoCollectionFromJSON.java

package com.zetcode;
import com.mongodb.BasicDBObject;
import com.mongodb.client.MongoClients;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import org.bson.types.ObjectId;
public class MongoCollectionFromJSON {
    public static void main(String[] args) {
        try (var mongoClient = MongoClients.create("mongodb://localhost:27017")) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("continents");
            var africa = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Africa'}");
            var asia = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Asia'}");
            var europe = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Europe'}");
            var america = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'America'}");
            var australia = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Australia'}");
            var antarctica = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Antarctica'}");
            collection.insertOne(new Document(africa));
            collection.insertOne(new Document(asia));
            collection.insertOne(new Document(europe));
            collection.insertOne(new Document(america));
            collection.insertOne(new Document(australia));
            collection.insertOne(new Document(antarctica));
        }
    }
}

该示例从 JSON 数据创建continents集合。

var africa = BasicDBObject.parse("{_id : '" + ObjectId.get() + "', name : 'Africa'}");

JSON 数据使用BasicDBObject.parse方法进行解析。

collection.insertOne(new Document(africa));

BasicDBObject传递到Document，并通过insertOne()方法插入到集合中。

> db.continents.find()
{ "_id" : "5d4af89645ffb636567b6448", "name" : "Africa" }
{ "_id" : "5d4af89645ffb636567b6449", "name" : "Asia" }
{ "_id" : "5d4af89645ffb636567b644a", "name" : "Europe" }
{ "_id" : "5d4af89645ffb636567b644b", "name" : "America" }
{ "_id" : "5d4af89645ffb636567b644c", "name" : "Australia" }
{ "_id" : "5d4af89645ffb636567b644d", "name" : "Antarctica" }

我们用mongo显示创建的集合。

Java MongoDB 修改文件

MongoCollection的deleteOne()方法用于删除文档，updateOne()用于更新文档。

com/zetcode/MongoModify.java

package com.zetcode;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import org.bson.Document;
import static com.mongodb.client.model.Filters.eq;
public class MongoModify {
    public static void main(String[] args) {
        try (var mongoClient = new MongoClient("localhost", 27017)) {
            var database = mongoClient.getDatabase("testdb");
            MongoCollection<Document> collection = database.getCollection("cars");
            collection.deleteOne(eq("name", "Skoda"));
            collection.updateOne(new Document("name", "Audi"),
                    new Document("$set", new Document("price", 52000)));
        }
    }
}

该示例删除包含 Skoda 的文档并更新 Audi 的价格。

collection.deleteOne(eq("name", "Skoda"));

deleteOne()删除Skoda的文档。 eq()创建一个与所有文档匹配的过滤器，其中字段名称的值等于指定的值。

collection.updateOne(new Document("name", "Audi"),
    new Document("$set", new Document("price", 52000)));

通过updateOne()方法将 Audi 的价格更改为 52,000。

> db.cars.find()
{ "_id" : ObjectId("5d4d13d6463315268eb7376b"), "name" : "Audi", "price" : 52000 }
{ "_id" : ObjectId("5d4d13f5463315268eb7376c"), "name" : "Mercedes", "price" : 57127 }
{ "_id" : ObjectId("5d4d1408463315268eb7376e"), "name" : "Volvo", "price" : 29000 }
{ "_id" : ObjectId("5d4d140d463315268eb7376f"), "name" : "Bentley", "price" : 350000 }
{ "_id" : ObjectId("5d4d1411463315268eb73770"), "name" : "Citroen", "price" : 21000 }
{ "_id" : ObjectId("5d4d1415463315268eb73771"), "name" : "Hummer", "price" : 41400 }
{ "_id" : ObjectId("5d4d1419463315268eb73772"), "name" : "Volkswagen", "price" : 21600 }

我们使用mongo工具确认更改。

在本教程中，我们使用了 MongoDB 和 Java。您可能也对 Spring Boot MongoDB 教程， MySQL Java 教程或 PostgreSQL Java 教程感兴趣。

列出所有 Java 教程。

{% endraw %}

ZetCode 中文系列教程

27.md