寫在前面：

實(shí)習(xí)期間做公司的任務(wù)，用的是MongoDB。剛接觸感覺很多東西都不會，現(xiàn)在任務(wù)做完了?；剡^頭來記錄和鞏固一下知識，也方面以后回來查閱。本篇博客只記錄Mongodb的查詢方法，方便查找！MongoDB 4.0以上版本!! 廢話不多說，直接開始記錄：

1. 查詢所有文檔

// 獲取集合
MongoCollection<User> collection = mongoDatabase.getCollection("users", User.class);
// 查詢所有文檔
List<User> userList = new ArrayList<>();
MongoCursor<User> cursor = collection.find().iterator();
while (cursor.hasNext()) {
    User user = cursor.next();
    userList.add(user);
}
 

在這個示例中，我們首先獲取了名為users的集合，并將其映射到User類。接著，我們使用find()方法查詢集合中的所有文檔，并使用iterator()方法獲取游標(biāo)對象。通過遍歷游標(biāo)對象中的結(jié)果，我們可以將每個文檔轉(zhuǎn)換為User對象，并將其添加到一個List中。最終，我們可以在userList中找到所有查詢結(jié)果。

2. 指定查詢條件

指定查詢條件可以使用find()方法的參數(shù)。該參數(shù)是一個Bson對象，用于指定查詢條件。Bson是MongoDB提供的一個接口，用于構(gòu)建查詢條件。

// 獲取集合
MongoCollection<User> collection = mongoDatabase.getCollection("users", User.class);
// 構(gòu)建查詢條件
Bson filter = Filters.eq("name", "John");
// 查詢文檔
List<User> userList = new ArrayList<>();
MongoCursor<User> cursor = collection.find(filter).iterator();
while (cursor.hasNext()) {
    User user = cursor.next();
    userList.add(user);
}

構(gòu)建查詢條件有很多種，以下分類：

等于：Filters.eq("name", "John")，用于查詢name屬性等于"John"的文檔。

不等于：Filters.ne("name", "John")，用于查詢name屬性不等于"John"的文檔。

大于：Filters.gt("age", 18)，用于查詢age屬性大于18的文檔。

大于等于：Filters.gte("age", 18)，用于查詢age屬性大于等于18的文檔。

小于：Filters.lt("age", 30)，用于查詢age屬性小于30的文檔。

小于等于：Filters.lte("age", 30)，用于查詢age屬性小于等于30的文檔。

包含：Filters.in("name", Arrays.asList("John", "Mike"))，用于查詢name屬性包含在"John"和"Mike"中的文檔。 

不包含：Filters.nin("name", Arrays.asList("John", "Mike"))，用于查詢name屬性不包含在"John"和"Mike"中的文檔。

正則表達(dá)式：Filters.regex("name", "^J.*n$")，用于查詢name屬性匹配正則表達(dá)式"^J.*n$"的文檔。

與：Filters.and(Filters.eq("name", "John"), Filters.gt("age", 18))，用于查詢name屬性等于"John"且age屬性大于18的文檔。

或：Filters.or(Filters.eq("name", "John"), Filters.gt("age", 18))，用于查詢name屬性等于"John"或age屬性大于18的文檔。

存在：Filters.exists("name", true)，用于查詢存在name屬性的文檔。

不存在：Filters.exists("name", false)，用于查詢不存在name屬性的文檔。

使用and()和or()方法來組合多個條件，例如：

類似于sql:`name = "john" and (age > 18 or age < 30)`

Bson filter = Filters.and(
    Filters.eq("name", "John"),
    Filters.or(
        Filters.gt("age", 18),
        Filters.lt("age", 30)
    )
);

3. 指定查詢返回的字段

在 MongoDB 中，可以使用 projection 對查詢返回的字段進(jìn)行指定。通過指定 projection，可以過濾掉不需要的字段，提高查詢效率，并減小數(shù)據(jù)傳輸?shù)拇笮　?/p>

在 Java 中，可以使用 Projections 類來進(jìn)行字段的指定。該類提供了一些靜態(tài)方法，可以方便地創(chuàng)建不同類型的投影表達(dá)式。以下是一些常用的示例：

返回指定字段

List<Document> results = collection.find().projection(Projections.include("name", "age")).into(new ArrayList<>());

上述代碼中的 Projections.include("name", "age") 指定了只返回 name 和 age 兩個字段。

排除指定字段

List<Document> results = collection.find().projection(Projections.exclude("address")).into(new ArrayList<>());

上述代碼中的 Projections.exclude("address") 指定了不返回 address 字段。

限制返回字段

List<Document> results = collection.find().projection(Projections.slice("comments", 5)).into(new ArrayList<>());

上述代碼中的 Projections.slice("comments", 5) 指定了只返回 comments 字段中的前五個元素。

進(jìn)行計算并返回結(jié)果

List<Document> results = collection.find().projection(Projections.fields(Projections.include("name"), Projections.computed("agePlus10", "$age + 10"))).into(new ArrayList<>());

上述代碼中的 Projections.computed("agePlus10", "$age + 10") 指定了將 age 字段加上 10 并將結(jié)果保存到名為 agePlus10 的新字段中。

其他的限制操作

1. Projections.elemMatch(String field, Bson filter)

該方法用于返回某個數(shù)組字段中符合特定條件的子文檔。參數(shù) field 指定了要查詢的數(shù)組字段，filter 指定了查詢條件。以下是一個示例：

List<Document> results = collection.find().projection(Projections.elemMatch("comments", Filters.eq("author", "John Doe"))).into(new ArrayList<>());

上述代碼中，Projections.elemMatch("comments", Filters.eq("author", "John Doe")) 表示查詢 comments 數(shù)組字段中 author 為 John Doe 的子文檔，并返回符合條件的子文檔。

2. Projections.metaTextScore(String metaTextScoreField)

該方法用于返回使用 $meta 操作符計算出來的文本搜索相關(guān)度得分。參數(shù) metaTextScoreField 指定了保存文本搜索相關(guān)度得分的字段名稱。以下是一個示例：

List<Document> results = collection.find(Filters.text("Java")).projection(Projections.metaTextScore("score")).sort(Sorts.metaTextScore("score")).into(new ArrayList<>());

上述代碼中，Projections.metaTextScore("score") 表示使用 $meta 操作符計算出來的文本搜索相關(guān)度得分保存到 score 字段中。

3. Projections.excludeId()

該方法用于排除 _id 字段。以下是一個示例：

List<Document> results = collection.find().projection(Projections.excludeId()).into(new ArrayList<>());

4. Projections.excludeFields(Bson... fields)

該方法用于排除指定的字段。參數(shù) fields 指定了要排除的字段列表。以下是一個示例：

List<Document> results = collection.find().projection(Projections.excludeFields("password", "email")).into(new ArrayList<>());

上述代碼中，Projections.excludeFields("password", "email") 表示排除 password 和 email 兩個字段。

4. 限制返回文檔的數(shù)量

在 MongoDB 中，可以通過 limit() 方法來限制查詢結(jié)果返回的文檔數(shù)量。

limit() 方法接受一個整數(shù)參數(shù)，表示返回的文檔數(shù)量。例如，以下代碼限制查詢結(jié)果只返回前 10 條文檔：

FindIterable<Document> iterable = collection.find();
iterable.limit(10);

如果查詢結(jié)果包含的文檔數(shù)量小于指定的限制數(shù)，則返回實(shí)際包含的文檔數(shù)。例如，如果查詢結(jié)果只包含 5 個文檔，但是限制返回文檔數(shù)量為 10，則只會返回這 5 個文檔。

跳過指定數(shù)量的文檔

skip() 方法接受一個整數(shù)參數(shù)，表示要跳過的文檔數(shù)量。例如，以下代碼跳過查詢結(jié)果中的前 5 個文檔：

FindIterable<Document> iterable = collection.find();
iterable.skip(5);

如果查詢結(jié)果包含的文檔數(shù)量小于指定的跳過數(shù)，則返回一個空的文檔集合。例如，如果查詢結(jié)果只包含 3 個文檔，但是要求跳過前 5 個文檔，則返回一個空的文檔集合。

分頁查詢：

FindIterable<Document> iterable = collection.find().sort(Sorts.descending("age"));
iterable.skip(5).limit(10);

上述代碼會先按照年齡逆序排序，然后跳過前 5 個文檔，最后限制返回結(jié)果最多只有 10 個文檔。

5. 排序

sort() 方法接受一個 Bson 對象作為參數(shù)，表示排序的規(guī)則。通常，可以使用 Sorts 類提供的靜態(tài)方法來創(chuàng)建 Bson 對象，例如：

collection.find().sort(Sorts.ascending("age"));

上述代碼會按照年齡升序排序查詢結(jié)果。

collection.find().sort(Sorts.descending("age"));

上述代碼會按照年齡降序排序查詢結(jié)果。

在 MongoDB 中，可以按照多個屬性進(jìn)行排序。例如，以下代碼會先按照年齡升序排序，然后按照名稱降序排序：

collection.find().sort(Sorts.ascending("age").descending("name"));

除了使用 Sorts 類提供的靜態(tài)方法外，還可以使用 OrderBy 類的方法來創(chuàng)建排序規(guī)則。例如，以下代碼與前面的代碼等效：

collection.find().sort(OrderBy.asc("age").desc("name"));

sort() 方法也可以和其他查詢條件一起使用。例如，以下代碼會查詢年齡大于 18 歲的文檔，并且按照年齡降序排序：

collection.find(Filters.gt("age", 18)).sort(Sorts.descending("age"));

6. 匹配嵌套文檔

在 MongoDB 中，文檔可以包含嵌套的文檔，也就是一個文檔中的某個字段的值是一個文檔。查詢這種嵌套文檔需要使用嵌套查詢操作符，例如 $elemMatch。

        假設(shè)有一個 users 集合，每個文檔包含一個 name 字段和一個 favorites 字段，favorites 字段是一個數(shù)組，包含多個喜歡的電影名和電影類型：

{ "_id" : ObjectId("617f120110136e6f7c6e301d"), "name" : "Alice", "favorites" : [ { "title" : "Inception", "genre" : "Sci-Fi" }, { "title" : "The Shawshank Redemption", "genre" : "Drama" } ] }
{ "_id" : ObjectId("617f120110136e6f7c6e301e"), "name" : "Bob", "favorites" : [ { "title" : "The Godfather", "genre" : "Crime" }, { "title" : "The Dark Knight", "genre" : "Action" } ] }

要查詢 Alice 喜歡的所有科幻電影，可以使用 $elemMatch 操作符：

collection.find(Filters.and(Filters.eq("name", "Alice"), Filters.elemMatch("favorites", Filters.eq("genre", "Sci-Fi"))));

上述代碼會查詢 name 為 "Alice" 并且 favorites 數(shù)組中至少有一項的 genre 字段是 "Sci-Fi" 的文檔。

可以將 $elemMatch 操作符用在多層嵌套的文檔中。例如，假設(shè)有一個 products 集合，每個文檔包含一個 name 字段和一個 reviews 字段，reviews 字段是一個數(shù)組，包含多個評價文檔，每個評價文檔又包含一個 comments 字段和一個 score 字段：

{ "_id" : ObjectId("6181a77a2b59f5df0e13d7c4"), "name" : "iPhone", "reviews" : [ { "comments" : "Good", "score" : 8 }, { "comments" : "Bad", "score" : 2 } ] }
{ "_id" : ObjectId("6181a77a2b59f5df0e13d7c5"), "name" : "iPad", "reviews" : [ { "comments" : "Very good", "score" : 9 }, { "comments" : "Not bad", "score" : 6 } ] }

要查詢評分大于 7 分的 iPad 評價文檔的所有評論，可以使用多層嵌套的 $elemMatch 操作符：

collection.find(Filters.and(Filters.eq("name", "iPad"), Filters.elemMatch("reviews", Filters.elemMatch("comments", Filters.gt("score", 7)))));

7. 使用聚合管道

MongoDB聚合管道是指將多個數(shù)據(jù)處理操作組合在一起以形成數(shù)據(jù)處理管道，以便更有效地查詢和處理數(shù)據(jù)。聚合管道可以用于實(shí)現(xiàn)許多常見的數(shù)據(jù)處理操作，例如過濾、排序、分組、計數(shù)、平均值、求和、求最大/最小值等。

在Java中，我們可以使用MongoDB的聚合管道API來執(zhí)行聚合查詢。以下是一個使用聚合管道查詢的示例代碼：

MongoCollection<Document> collection = database.getCollection("users");
 
List<Document> pipeline = Arrays.asList(
    new Document("$match", new Document("age", new Document("$gt", 30))),
    new Document("$group", new Document("_id", "$gender").append("count", new Document("$sum", 1))),
    new Document("$sort", new Document("count", -1)),
    new Document("$limit", 10)
);
 
MongoCursor<Document> cursor = collection.aggregate(pipeline).iterator();
while (cursor.hasNext()) {
    Document doc = cursor.next();
    System.out.println(doc.toJson());
}

在這個示例中，我們首先獲取了名為“users”的集合，然后使用一個管道列表定義了我們的聚合查詢。該管道由四個操作組成：

• $match：過濾年齡大于30歲的文檔。
• $group：按性別分組，并計算每個組中文檔的數(shù)量。
• $sort：按文檔數(shù)量進(jìn)行排序，以便按數(shù)量最多的順序返回結(jié)果。
• $limit：限制結(jié)果數(shù)量為10。

最后，我們使用aggregate方法執(zhí)行查詢，并使用迭代器遍歷查詢結(jié)果并打印輸出。

8. 分組查詢

分組查詢是 MongoDB 中非常有用的一種聚合操作，它可以將文檔集合按照某個字段進(jìn)行分組，然后對每組進(jìn)行統(tǒng)計分析，例如計算每個分組內(nèi)文檔數(shù)量的總和、平均值、最大值、最小值等等。下面介紹如何在 Java 代碼中使用 MongoDB 進(jìn)行分組查詢。

首先，我們需要使用 Aggregation 類中的 group() 方法進(jìn)行分組操作。該方法接受一個 Bson 類型的參數(shù)，表示分組條件。例如，下面的代碼將按照 name 字段進(jìn)行分組：

Bson group = Aggregates.group("$name");

接下來，我們可以使用 Aggregation 類中的各種聚合方法對每個分組進(jìn)行統(tǒng)計分析。例如，下面的代碼將在每個分組中計算 age 字段的平均值：

Bson avgAge = Aggregates.avg("age", "$age");

最后，我們可以使用 Aggregation 類中的 pipeline() 方法將所有的聚合操作串聯(lián)起來，從而得到最終的結(jié)果。例如，下面的代碼將按照 name 字段進(jìn)行分組，并在每個分組中計算 age 字段的平均值：

List<Bson> pipeline = Arrays.asList(
    Aggregates.group("$name", Aggregates.avg("age", "$age"))
);
MongoCollection<Document> collection = database.getCollection("users");
MongoCursor<Document> cursor = collection.aggregate(pipeline).iterator();
while (cursor.hasNext()) {
    Document result = cursor.next();
    System.out.println(result.toJson());
}

在上面的代碼中，我們使用 pipeline() 方法將分組操作和計算平均值操作串聯(lián)起來，然后使用 aggregate() 方法執(zhí)行聚合操作，并將結(jié)果輸出到控制臺上。

除了平均值之外，Aggregation 類中還提供了各種聚合方法，例如 sum()、count()、max()、min() 等等，可以根據(jù)實(shí)際需求進(jìn)行選擇。

總結(jié)

到此這篇關(guān)于Java查詢MongoDB數(shù)據(jù)庫的文章就介紹到這了,更多相關(guān)Java查詢MongoDB案例內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論