本文導讀

• 相比 Java 操作 關係型資料庫(如 Mysql) 而言，Java  操作 noSql 更加簡單，因為沒有事務這些操作
• Java 操作 Mysql 資料庫需要 Mysql 的連線驅動包，同理 Java 操作 MongoDB 也需要連線驅動包，叫 mongo-java-driver ！
• 本文將詳細介紹如何下載驅動包 mongoDB-Java-Driver ，以及資料庫操作、集合操作，對於文件操作將新開一篇進行介紹，可以參考《 MongoDB 通過 Java 程式碼 CRUD 文件》

環境準備

mongo-java-driver 獲取

• 先選擇中間的 “ mongo-java-driver ”，後面的下拉框可以選擇相應的版本
• 如果使用 Maven 專案，則可以直接複製文字域中的值
• 如果使用手動 匯入開發包的方式，則可以點選左上角的 “ DOWNLOAD” 按鈕進行下載，如下所示：

新建專案

• 新建 Java SE 專案，不使用  Maven 管理，採用手動 導包的方式，進行  API 操作學習
• 使用 Java  JDK 1.8、MongoDB 4.0.2、Mongo-Java-Driver-3.8.1.jar

開啟 MongoDB 服務端

• 如下所示，使用免安全認證執行 MongoDB 伺服器，使用預設埠 27017，MongoDB 版本為 4.0.2

C:\Users\Administrator.SC-201707281232>mongod --dbpath=D:\MongoDB\Data
2018-09-15T15:00:14.055+0800 I CONTROL  [main] Automatically disabling TLS 1.0, to force-enable TLS 1.0 specify --sslDisabledProtocols 'none'
2018-09-15T15:00:14.424+0800 I CONTROL  [initandlisten] MongoDB starting : pid=10980 port=27017 dbpath=D:\MongoDB\Data 64-bit host=SC-201707281232
2018-09-15T15:00:14.424+0800 I CONTROL  [initandlisten] targetMinOS: Windows 7/Windows Server 2008 R2
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] db version v4.0.2-rc0
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] git version: fc1573ba18aee42f97a3bb13b67af7d837826b47
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] allocator: tcmalloc
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] modules: none
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] build environment:
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten]     distmod: 2008plus-ssl
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten]     distarch: x86_64
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten]     target_arch: x86_64
2018-09-15T15:00:14.425+0800 I CONTROL  [initandlisten] options: { storage: { dbPath: "D:\MongoDB\Data" } }
2018-09-15T15:00:14.492+0800 I STORAGE  [initandlisten] Detected data files in D:\MongoDB\Data created by the 'wiredTiger' storage engine, so setting the active storage engine to 'wiredTiger'.
2018-09-15T15:00:14.492+0800 I STORAGE  [initandlisten] wiredtiger_open config: create,cache_size=3552M,session_max=200
.............
 

CRUD

資料庫操作

• 資料庫操作包括：MongoDB 服務端連線，查詢資料庫、刪除資料庫，建立資料庫

• 客戶端連線 MongoDB 資料庫分為兩種，當 MongoDB 伺服器開啟了安全認證時，則客戶端必須進行安全認證連線
• 當 MongoDB 伺服器沒進行安全認證時，則客戶端可以免密連線，如下所示為 MongoDB 服務端未開啟安全認證時：

package com.lct;

import com.mongodb.*;

/**
 * Created by Administrator on 2018/9/15 0015.
 * java 程式碼 操作  mongodb 資料庫
 */
public class MongoDBDaoImpl {

    /**
     * 連線沒有進行安全認證的 MongoDB 伺服器
     *
     * @return
     */
    public static MongoClient getMongoClientNoCheck() {
        /**MongoClient 是執行緒安全的，可以在多個執行緒中共享同一個例項
         * 一個 MongoClient 相當於一個客戶端，一個客戶端可以有多個連線*/
        MongoClient mongoClient = null;
        try {
            /** new MongoClient 建立客戶端的時候，可以傳入 MongoClientOptions 客戶端配置選項
             * 所以可以將設定全部事先設定好
             */
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            /**與目標資料庫能夠建立的最大連線數為50*/
            build.connectionsPerHost(50);

            /**如果當前所有的連線都在使用中，則每個連線上可以有50個執行緒排隊等待*/
            build.threadsAllowedToBlockForConnectionMultiplier(50);

            /**一個執行緒訪問資料庫的時候，在成功獲取到一個可用資料庫連線之前的最長等待時間為，此處為 2分鐘
             * 如果超過 maxWaitTime 都沒有獲取到連線的話，該執行緒就會丟擲 Exception
             * */
            build.maxWaitTime(1000 * 60 * 2);

            /**設定與資料庫建立連線時最長時間為1分鐘*/
            build.connectTimeout(1000 * 60 * 1);
            MongoClientOptions mongoClientOptions = build.build();

            /** 將 MongoDB 伺服器的 ip 與埠先封裝好
             * 連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * */
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);

            /**
             * 通過 ServerAddress 與 MongoClientOptions 建立連線到 MongoDB 的資料庫例項
             * MongoClient(String host, int port)：
             *      1）host：MongoDB 服務端 IP
             *      2）port：MongoDB 服務端 埠，預設為 27017
             *      3）即使 MongoDB 服務端關閉，此時也不會丟擲異常，只有到真正呼叫方法是才會
             *      4）連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * MongoClient(final ServerAddress addr, final MongoClientOptions options)
             * 過載了很多構造方法，這只是其中兩個常用的
             *      */
            mongoClient = new MongoClient(serverAddress, mongoClientOptions);
        } catch (MongoException e) {
            e.printStackTrace();
        }
        return mongoClient;
    }
  
    public static void main(String[] args) {
        MongoClient mongoClient = getMongoClientNoCheck();
        int size = mongoClient.getMaxBsonObjectSize();
        System.out.println("MaxBsonObjectSize >>>" + size);
        System.out.println("MongoDB 服務端地址：" + mongoClient.getAddress().toString());
    }
}
 

控制檯輸出如下：

資訊: Monitor thread successfully connected to server with description ServerDescription{address=localhost:27017, type=STANDALONE, state=CONNECTED, ok=true, version=ServerVersion{versionList=[4, 0, 2]}, minWireVersion=0, maxWireVersion=7, maxDocumentSize=16777216, logicalSessionTimeoutMinutes=30, roundTripTimeNanos=2454952}
MaxBsonObjectSize >>>16777216
MongoDB 服務端地址：localhost:27017

Process finished with exit code 0

• 如果 MongoDB 開啟安全認證，則使用如下方式進行連線（MongoDB 未開啟安全認證也可以使用）：

    /**
     * 連線進行安全認證的 MongoDB 伺服器，此時需要驗證賬號密碼
     * 1）注意：如果 MongoDB 伺服器未開啟安全認證，則即使連線的時候使用了 賬號密碼，則也不受影響，同樣成功
     *
     * @return
     */
    public static MongoClient getMongoClientCheck() {
        /**MongoClient 是執行緒安全的，可以在多個執行緒中共享同一個例項
         * 一個 MongoClient 相當於一個客戶端，一個客戶端可以有多個連線
         * */
        MongoClient mongoClient = null;
        try {
            /** new MongoClient 建立客戶端的時候，可以傳入 MongoClientOptions 客戶端配置選項
             * 所以可以將設定全部事先設定好
             */
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            /**與目標資料庫能夠建立的最大連線數為50*/
            build.connectionsPerHost(50);

            /**如果當前所有的連線都在使用中，則每個連線上可以有50個執行緒排隊等待*/
            build.threadsAllowedToBlockForConnectionMultiplier(50);

            /**一個執行緒訪問資料庫的時候，在成功獲取到一個可用資料庫連線之前的最長等待時間為，此處為 2分鐘
             * 如果超過 maxWaitTime 都沒有獲取到連線的話，該執行緒就會丟擲 Exception
             * */
            build.maxWaitTime(1000 * 60 * 2);

            /**設定與資料庫建立連線時最長時間為1分鐘*/
            build.connectTimeout(1000 * 60 * 1);
            MongoClientOptions mongoClientOptions = build.build();

            /** 將 MongoDB 伺服器的 ip 與埠先封裝好
             * 連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * */
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);

            /** MongoCredential：表示 MongoDB 憑據、證書
             * createScramSha1Credential(final String userName, final String source, final char[] password)
             *      1）userName：登入的使用者名稱
             *      2）source：使用者需要驗證的資料庫名稱，注意賬號當時在哪個資料庫下建立，則此時就去哪個庫下面進行驗證，否則即使賬號密碼正確也無濟於事
             *      3）password：使用者的密碼
             *      4）實際開發中也應該放到配置檔案中進行配置
             * 同理還有：
             * createCredential(final String userName, final String database, final char[] password)
             * createScramSha256Credential(final String userName, final String source, final char[] password)
             * createMongoCRCredential(final String userName, final String database, final char[] password)
             * createMongoX509Credential(final String userName)
             * createMongoX509Credential()
             * createPlainCredential(final String userName, final String source, final char[] password)
             * createGSSAPICredential(final String userName)
             * A、如果 MongoDB 服務端未開啟安全認證，這裡設定的賬號密碼連線時也不受影響，同樣連線成功
             * B、如果 MongoDB 服務端開啟了安全認證，但是賬號密碼是錯誤的，則此時不會裡面拋異常，等到正在 CRUD 時就會拋異常：Exception authenticating
             * C、如下所示，這是事項在 admin 資料庫中建立好的 管理員賬號 root
             */
            MongoCredential credential = MongoCredential.createCredential(
                    "root", "admin", "root".toCharArray());
            /** MongoClient(final ServerAddress addr, final MongoCredential credential, final MongoClientOptions options)
             * 1）addr：MongoDB 伺服器地址
             * 2）credential：MongoDB 安全認證證書
             * 3）options：MongoDB 客戶端配置選項
             */
            mongoClient = new MongoClient(serverAddress, credential, mongoClientOptions);
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
        return mongoClient;
    } 

    public static void main(String[] args) {
        MongoClient mongoClient = getMongoClientCheck();
        int size = mongoClient.getMaxBsonObjectSize();
        System.out.println("MaxBsonObjectSize >>>" + size);
        System.out.println("MongoDB 服務端地址：" + mongoClient.getAddress().toString());
    }

控制檯輸出：

MaxBsonObjectSize >>>16777216
MongoDB 服務端地址：localhost:27017

Process finished with exit code 0

• 如下所示，可以使用 com.mongodb.MongoClient 的 API 獲取 MongoDB 的相關資訊：

/**
     * 獲取 MongoDB 的一些資訊
     * 可以使用 com.mongodb.MongoClient 的 API 來獲取一些資訊
     */
    public static void showMongoDBInfo() {
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);
        ServerAddress serverAddress = mongoClient.getAddress();
        System.out.println("serverAddress>>>" + serverAddress);//輸出：127.0.0.1:27017

        String connectPoint = mongoClient.getConnectPoint();
        System.out.println("connectPoint>>>" + connectPoint);

        int bsonObjectSize = mongoClient.getMaxBsonObjectSize();
        System.out.println("bsonObjectSize>>>" + bsonObjectSize);

        mongoClient.close();
    }

    public static void main(String[] args) {
        showMongoDBInfo();
    }

控制檯輸出：

serverAddress>>>127.0.0.1:27017
connectPoint>>>127.0.0.1:27017
bsonObjectSize>>>16777216

• 如下所示，刪除資料庫方式如下：

package com.lct;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

/**
 * Created by Administrator on 2018/9/17 0017.
 * MongoDB 資料庫測試
 */
public class MongoDBTest {

    /**
     * 刪除指定資料庫
     * 使用 com.mongodb.client.MongoDatabase#drop() 進行刪除
     *
     * @param databaseName 被刪除資料庫名稱，存在時會被刪除(連同資料庫中的資料一併刪除)；不存在時不受影響
     */
    public static void dropDatabase(String databaseName) {
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 伺服器地址配置在配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             *
             * 注意 MongoDatabase 相當於一個 MongoDB 連線，連線可以有多個
             * MongoClient 相當於一個客戶端，客戶端可以只有一個，也可有多個
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**刪除當前所在的資料庫
             * 1）即使資料庫中有集合，集合中有文件，整個資料庫都會刪除，show dbs 不會再有
             * 2）如果待刪除的資料庫實際沒有存在，即 show dbs 看不到，也不影響，不拋異常
             *
             * 也可以使用 MongoClient 的 dropDatabase(String dbName) 方法進行刪除
             */
            mongoDatabase.drop();

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }


    /**
     * 刪除指定資料庫
     * 使用 com.mongodb.Mongo#dropDatabase(java.lang.String) 進行刪除
     *
     * @param databaseName 被資料庫的名稱，存在時，連同資料庫中的內容一併刪除，不存在時不受影響
     */
    public static void delDatabase(String databaseName) {
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /** dropDatabase(String dbName) :刪除 MongoDB 下的指定資料庫
             * 資料庫中內容全部會被刪除，show dbs 也不會再有
             * 也可以使用 MongoDatabase 的 drop() 方法，刪除當前資料庫
             * 方法一執行，資料庫 show dbs 就不會再有
             * */
            mongoClient.dropDatabase(databaseName);

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }

    public static void main(String[] args) {
        delDatabase("java");
    }
}

• 如果需要查詢 MongoDB 服務端所有的資料庫名稱或資料庫詳細資訊，則方式如下：

 /**
     * 獲取 MongoDB 服務端所有資料庫名字
     * 使用：com.mongodb.MongoClient#listDatabaseNames()
     *
     * @return
     */
    public static List<String> findAllDBNames() {
        List<String> dbNameList = new ArrayList<String>();
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

        /**getDatabase(String databaseName)：獲取指定的資料庫
         * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
         * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
         * listDatabaseNames()：獲取 MongoDB 服務端所有資料庫
         * 先返回 迭代器 MongoIterable，在根據迭代器獲取 遊標 MongoCursor
         * 最後遍歷遊標進行取值
         * */
        MongoIterable<String> mongoIterable = mongoClient.listDatabaseNames();
        MongoCursor<String> mongoCursor = mongoIterable.iterator();
        while (mongoCursor.hasNext()) {
            String dbName = mongoCursor.next();
            System.out.println("dbName>>>" + dbName);
            dbNameList.add(dbName);
        }
        /**
         * 控制檯輸出示例：
         * dbName>>>admin
         * dbName>>>config
         * dbName>>>java
         * dbName>>>local
         */
        mongoClient.close();
        return dbNameList;
    }

    public static void main(String[] args) {
        List<String> dbNameList = findAllDBNames();
        System.out.println(Arrays.toString(dbNameList.toArray()));
    }

控制檯輸出：

dbName>>>admin
dbName>>>config
dbName>>>local
dbName>>>mydb1
dbName>>>mydb2
[admin, config, local, mydb1, mydb2]

 /**
     * 獲取 MongoDB 服務端所有資料庫 文件物件
     * 使用 com.mongodb.MongoClient#listDatabases()
     *
     * @return ：返回的 Document 包含了資料庫的詳細資訊
     */
    public static List<Document> findAllDBs() {
        List<Document> dbList = new ArrayList<Document>();
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

        /**getDatabase(String databaseName)：獲取指定的資料庫
         * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
         * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
         * listDatabaseNames()：獲取 MongoDB 服務端所有資料庫
         * 先返回 迭代器 MongoIterable，在根據迭代器獲取 遊標 MongoCursor
         * 最後便利遊標進行取值
         * mongoClient.listDatabases()：原理同上，只是返回的最終結果不是 String,而是 Document
         * */

        ListDatabasesIterable<Document> databasesIterable = mongoClient.listDatabases();
        MongoCursor<Document> mongoCursor = databasesIterable.iterator();
        while (mongoCursor.hasNext()) {
            Document db = mongoCursor.next();
            System.out.println(db.toJson());
            dbList.add(db);
        }
        /**
         * 輸出內容示例：
         * { "name" : "admin", "sizeOnDisk" : 32768.0, "empty" : false }
         * { "name" : "config", "sizeOnDisk" : 73728.0, "empty" : false }
         * { "name" : "local", "sizeOnDisk" : 73728.0, "empty" : false }
         * { "name" : "mydb1", "sizeOnDisk" : 65536.0, "empty" : false }
         * { "name" : "mydb2", "sizeOnDisk" : 1.99491584E8, "empty" : false }
         */
        mongoClient.close();
        return dbList;
    }

集合操作

• 集合操作同樣包括 集合建立、查詢、刪除 等
• 如下所示為顯示的 建立集合。隱式建立 集合 與 隱式建立資料庫一致，直接新增資料就會自動建立。

package com.lct;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

/**
 * Created by Administrator on 2018/9/17 0017.
 * MongoDB 集合測試
 */
public class MongoCollectionTest {

    /**
     * 顯示的為指定資料庫建立集合
     *
     * @param databaseName   資料庫名稱，如 java，不存在時會自動建立，存在時不受影響
     * @param collectionName 集合名詞，如 c1，不存在時會自動建立，存在時則會丟擲異常： already exists'
     */
    public static void createCollectionByShow(String databaseName, String collectionName) {
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**createCollection(String var1)：顯示建立集合，此時 java 資料庫下會立即建立 c1 集合
             * 注意如果 資料庫中已經存在此 集合，則會丟擲異常： already exists'
             *
             * 執行完成後，MongoDB  客戶端可以用命令檢視：
             * > show dbs
             * admin   0.000GB
             * config  0.000GB
             * java    0.000GB
             * local   0.000GB
             * > use java
             * switched to db java
             * > show tables
             * c1
             * */
            mongoDatabase.createCollection(collectionName);

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }

    public static void main(String[] args) {
        createCollectionByShow("java","c1");
    }
}

• 如下所示，通過 MongoDB 客戶端連線，使用命令檢視，建立成功，如果 Java 資料庫之前不存在，則會隱式一併建立，
• 當 c1 集合已經存在，再次顯示建立會報錯！

> show dbs
admin   0.000GB
config  0.000GB
java    0.000GB
local   0.000GB
mydb1   0.000GB
mydb2   0.186GB
> use java
switched to db java
> show tables
c1
>

• 如下獲取指定資料庫下的集合：

  /**
     * 獲取指定資料庫下的指定集合
     *
     * @param databaseName   資料庫名稱，不存在時，MongoCollection 大小為 0
     * @param collectionName 獲取的集合名稱,不存在時，MongoCollection 大小為 0
     */
    public static MongoCollection<Document> getCollectionByName(String databaseName, String collectionName) {
        MongoCollection<Document> mongoCollection = null;
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**獲取資料庫中的集合
             * 如果集合不存在，則返回的 MongoCollection<Document> 文件個數為0，不會為 null*/
            mongoCollection = mongoDatabase.getCollection(collectionName);
        }
        return mongoCollection;
    }

    public static void main(String[] args) {
        MongoCollection<Document> mongoCollection = getCollectionByName("java2", "c2");
        Long documentSize = mongoCollection.countDocuments();
        System.out.println("集合中文件總數：documentSize >>> " + documentSize);
    }

集合中文件總數：documentSize >>> 6

Process finished with exit code 0

• 如下所示，可以獲取指定資料庫下的所有集合名稱：

   /**
     * 獲取指定資料庫下的所有集合名稱
     *
     * @param databaseName 資料庫名稱
     * @return 返回集合名稱的列表
     */
    public static List<String> getAllCollectionNames(String databaseName) {
        List<String> collectionNameList = new ArrayList<String>();
        if (databaseName != null && !"".equals(databaseName)) {

            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /** listCollectionNames()：獲取整個資料庫下集合名稱列表*/
            MongoIterable<String> mongoIterable = mongoDatabase.listCollectionNames();

            /** first()：獲取資料庫下第一個集合名稱
             * 不存在時返回 null */
            String first = mongoIterable.first();
            System.out.println("first collectionName>>>" + first);

            /**獲取它的遊標進行迭代集合名稱
             * 資料庫下沒有集合時，則大小為空，不會為 null
             * */
            MongoCursor<String> mongoCursor = mongoIterable.iterator();
            while (mongoCursor.hasNext()) {
                String collectionName = mongoCursor.next();
                collectionNameList.add(collectionName);
            }
            /**關閉遊標*/
            mongoCursor.close();

            /**關閉 MongoDB 客戶端連線*/
            mongoClient.close();
        }
        return collectionNameList;
    }

    public static void main(String[] args) {
        List<String> collectionNameList = getAllCollectionNames("java");
        System.out.println(Arrays.toString(collectionNameList.toArray()));
    }

控制檯輸出：

first collectionName>>>c2
[c2, c1, c3]

MongoDB 客戶端命令列：

> db
java
> show tables
c1
c2
c3
>

• 如下所示，可以獲取資料庫下所有集合的詳細資訊：

 /**
     * 獲取指定資料庫下的所有集合
     * 使用：com.mongodb.client.MongoDatabase#listCollections()
     *
     * @param databaseName 資料庫名稱
     * @return 返回集合的 Document 物件，此物件包含集合的完整資訊
     */
    public static List<Document> getAllCollection(String databaseName) {
        List<Document> collectionList = new ArrayList<Document>();
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /** mongoDatabase.listCollections()：獲取當前資料庫下所有的集合列表
             * ListCollectionsIterable<Document> 與 MongoCollection<Document> 不同
             */
            ListCollectionsIterable<Document> collectionsIterable = mongoDatabase.listCollections();

            /** collectionsIterable.first()：返回第一個集合的 Document 物件，包含集合詳細資訊
             * 集合不存在時，返回 null
             */
            Document firstDocument = collectionsIterable.first();
            if (firstDocument != null) {
                System.out.println("first collection >>>" + firstDocument.toJson());
            }

            /** collectionsIterable.iterator() 獲取 MongoCursor<Document> 遊標
             * 不用擔心空指標異常*/
            MongoCursor<Document> mongoCursor = collectionsIterable.iterator();
            while (mongoCursor.hasNext()) {
                Document loopDocument = mongoCursor.next();
                System.out.println("loop collection >>>" + loopDocument.toJson());
                collectionList.add(loopDocument);
            }
            /**關閉遊標*/
            mongoCursor.close();
            /**關閉 MongoDB 客戶端連線*/
            mongoClient.close();
        }
        return collectionList;
    }

    public static void main(String[] args) {
        getAllCollection("java");
    }

控制檯輸出：

first collection >>>{ "name" : "c2", "type" : "collection", "options" : { }, "info" : { "readOnly" : false, "uuid" : { "$binary" : "z0ETnmcJlA3ZWjRJe7ozoQ==", "$type" : "03" } }, "idIndex" : { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "java.c2" } }
loop collection >>>{ "name" : "c2", "type" : "collection", "options" : { }, "info" : { "readOnly" : false, "uuid" : { "$binary" : "z0ETnmcJlA3ZWjRJe7ozoQ==", "$type" : "03" } }, "idIndex" : { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "java.c2" } }
loop collection >>>{ "name" : "c1", "type" : "collection", "options" : { }, "info" : { "readOnly" : false, "uuid" : { "$binary" : "2EQ+qlLfXxXjO4zbt707gQ==", "$type" : "03" } }, "idIndex" : { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "java.c1" } }
loop collection >>>{ "name" : "c3", "type" : "collection", "options" : { }, "info" : { "readOnly" : false, "uuid" : { "$binary" : "uUaQNmZPkjjGJXgROKl+lg==", "$type" : "03" } }, "idIndex" : { "v" : 2, "key" : { "_id" : 1 }, "name" : "_id_", "ns" : "java.c3" } }

• 如下所示，刪除資料庫下的指定集合

 /**
     * 刪除指定資料庫下的指定集合，如果資料庫中不存在此集合，則不會做任何處理
     * 使用：com.mongodb.client.MongoCollection#drop()
     *
     * @param databaseName   資料庫名稱
     * @param collectionName 獲取的集合名稱
     */
    public static void delCollection(String databaseName, String collectionName) {
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             *  實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**獲取資料庫中的集合*/
            MongoCollection<Document> mongoCollection = mongoDatabase.getCollection(collectionName);

            /**刪除當前集合，如果集合不存在，則不做任何處理，不會拋異常*/
            mongoCollection.drop();
            mongoClient.close();
        }
    }
    public static void main(String[] args) {
        delCollection("java","c3");
    }

文件檔案內容

MongoDBTest

package com.lct;

import com.mongodb.*;
import com.mongodb.client.ListDatabasesIterable;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import org.bson.Document;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2018/9/17 0017.
 * MongoDB 資料庫測試---包括 MongoDB 服務端連線，資料庫新建、查詢、刪除 等
 */
public class MongoDBTest {

    /**
     * 連線沒有進行安全認證的 MongoDB 伺服器
     *
     * @return
     */
    public static MongoClient getMongoClientNoCheck() {
        /**MongoClient 是執行緒安全的，可以在多個執行緒中共享同一個例項
         * 一個 MongoClient 相當於一個客戶端，一個客戶端可以有多個連線*/
        MongoClient mongoClient = null;
        try {
            /** new MongoClient 建立客戶端的時候，可以傳入 MongoClientOptions 客戶端配置選項
             * 所以可以將設定全部事先設定好
             */
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            /**與目標資料庫能夠建立的最大連線數為50*/
            build.connectionsPerHost(50);

            /**如果當前所有的連線都在使用中，則每個連線上可以有50個執行緒排隊等待*/
            build.threadsAllowedToBlockForConnectionMultiplier(50);

            /**一個執行緒訪問資料庫的時候，在成功獲取到一個可用資料庫連線之前的最長等待時間為，此處為 2分鐘
             * 如果超過 maxWaitTime 都沒有獲取到連線的話，該執行緒就會丟擲 Exception
             * */
            build.maxWaitTime(1000 * 60 * 2);

            /**設定與資料庫建立連線時最長時間為1分鐘*/
            build.connectTimeout(1000 * 60 * 1);
            MongoClientOptions mongoClientOptions = build.build();

            /** 將 MongoDB 伺服器的 ip 與埠先封裝好
             * 連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * */
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);

            /**
             * 通過 ServerAddress 與 MongoClientOptions 建立連線到 MongoDB 的資料庫例項
             * MongoClient(String host, int port)：
             *      1）host：MongoDB 服務端 IP
             *      2）port：MongoDB 服務端 埠，預設為 27017
             *      3）即使 MongoDB 服務端關閉，此時也不會丟擲異常，只有到真正呼叫方法是才會
             *      4）連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * MongoClient(final ServerAddress addr, final MongoClientOptions options)
             * 過載了很多構造方法，這只是其中兩個常用的
             *      */
            mongoClient = new MongoClient(serverAddress, mongoClientOptions);
        } catch (MongoException e) {
            e.printStackTrace();
        }
        return mongoClient;
    }

    /**
     * 連線進行安全認證的 MongoDB 伺服器，此時需要驗證賬號密碼
     * 1）注意：如果 MongoDB 伺服器未開啟安全認證，則即使連線的時候使用了 賬號密碼，則也不受影響，同樣成功
     *
     * @return
     */
    public static MongoClient getMongoClientCheck() {
        /**MongoClient 是執行緒安全的，可以在多個執行緒中共享同一個例項
         * 一個 MongoClient 相當於一個客戶端，一個客戶端可以有多個連線
         * */
        MongoClient mongoClient = null;
        try {
            /** new MongoClient 建立客戶端的時候，可以傳入 MongoClientOptions 客戶端配置選項
             * 所以可以將設定全部事先設定好
             */
            MongoClientOptions.Builder build = new MongoClientOptions.Builder();
            /**與目標資料庫能夠建立的最大連線數為50*/
            build.connectionsPerHost(50);

            /**如果當前所有的連線都在使用中，則每個連線上可以有50個執行緒排隊等待*/
            build.threadsAllowedToBlockForConnectionMultiplier(50);

            /**一個執行緒訪問資料庫的時候，在成功獲取到一個可用資料庫連線之前的最長等待時間為，此處為 2分鐘
             * 如果超過 maxWaitTime 都沒有獲取到連線的話，該執行緒就會丟擲 Exception
             * */
            build.maxWaitTime(1000 * 60 * 2);

            /**設定與資料庫建立連線時最長時間為1分鐘*/
            build.connectTimeout(1000 * 60 * 1);
            MongoClientOptions mongoClientOptions = build.build();

            /** 將 MongoDB 伺服器的 ip 與埠先封裝好
             * 連線 MongoDB 服務端地址，實際專案中應該放到配置檔案進行配置
             * */
            ServerAddress serverAddress = new ServerAddress("localhost", 27017);

            /** MongoCredential：表示 MongoDB 憑據、證書
             * createScramSha1Credential(final String userName, final String source, final char[] password)
             *      1）userName：登入的使用者名稱
             *      2）source：使用者需要驗證的資料庫名稱，注意賬號當時在哪個資料庫下建立，則此時就去哪個庫下面進行驗證，否則即使賬號密碼正確也無濟於事
             *      3）password：使用者的密碼
             *      4）實際開發中也應該放到配置檔案中進行配置
             * 同理還有：
             * createCredential(final String userName, final String database, final char[] password)
             * createScramSha256Credential(final String userName, final String source, final char[] password)
             * createMongoCRCredential(final String userName, final String database, final char[] password)
             * createMongoX509Credential(final String userName)
             * createMongoX509Credential()
             * createPlainCredential(final String userName, final String source, final char[] password)
             * createGSSAPICredential(final String userName)
             * A、如果 MongoDB 服務端未開啟安全認證，這裡設定的賬號密碼連線時也不受影響，同樣連線成功
             * B、如果 MongoDB 服務端開啟了安全認證，但是賬號密碼是錯誤的，則此時不會裡面拋異常，等到正在 CRUD 時就會拋異常：Exception authenticating
             * C、如下所示，這是事項在 admin 資料庫中建立好的 管理員賬號 root
             */
            MongoCredential credential = MongoCredential.createCredential(
                    "root", "admin", "root".toCharArray());
            /** MongoClient(final ServerAddress addr, final MongoCredential credential, final MongoClientOptions options)
             * 1）addr：MongoDB 伺服器地址
             * 2）credential：MongoDB 安全認證證書
             * 3）options：MongoDB 客戶端配置選項
             */
            mongoClient = new MongoClient(serverAddress, credential, mongoClientOptions);
        } catch (Exception e) {
            System.err.println(e.getClass().getName() + ": " + e.getMessage());
        }
        return mongoClient;
    }

    /**
     * 獲取 MongoDB 的一些資訊
     * 可以使用 com.mongodb.MongoClient 的 API 來獲取一些資訊
     */
    public static void showMongoDBInfo() {
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);
        ServerAddress serverAddress = mongoClient.getAddress();
        System.out.println("serverAddress>>>" + serverAddress);//輸出：127.0.0.1:27017

        String connectPoint = mongoClient.getConnectPoint();
        System.out.println("connectPoint>>>" + connectPoint);

        int bsonObjectSize = mongoClient.getMaxBsonObjectSize();
        System.out.println("bsonObjectSize>>>" + bsonObjectSize);

        mongoClient.close();
    }

    /**
     * 刪除指定資料庫
     * 使用 com.mongodb.client.MongoDatabase#drop() 進行刪除
     *
     * @param databaseName 被刪除資料庫名稱，存在時會被刪除(連同資料庫中的資料一併刪除)；不存在時不受影響
     */
    public static void dropDatabase(String databaseName) {
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 伺服器地址配置在配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             *
             * 注意 MongoDatabase 相當於一個 MongoDB 連線，連線可以有多個
             * MongoClient 相當於一個客戶端，客戶端可以只有一個，也可有多個
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**刪除當前所在的資料庫
             * 1）即使資料庫中有集合，集合中有文件，整個資料庫都會刪除，show dbs 不會再有
             * 2）如果待刪除的資料庫實際沒有存在，即 show dbs 看不到，也不影響，不拋異常
             *
             * 也可以使用 MongoClient 的 dropDatabase(String dbName) 方法進行刪除
             */
            mongoDatabase.drop();

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }


    /**
     * 刪除指定資料庫
     * 使用 com.mongodb.Mongo#dropDatabase(java.lang.String) 進行刪除
     *
     * @param databaseName 被資料庫的名稱，存在時，連同資料庫中的內容一併刪除，不存在時不受影響
     */
    public static void delDatabase(String databaseName) {
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /** dropDatabase(String dbName) :刪除 MongoDB 下的指定資料庫
             * 資料庫中內容全部會被刪除，show dbs 也不會再有
             * 也可以使用 MongoDatabase 的 drop() 方法，刪除當前資料庫
             * 方法一執行，資料庫 show dbs 就不會再有
             * */
            mongoClient.dropDatabase(databaseName);

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }

    /**
     * 獲取 MongoDB 服務端所有資料庫名字
     * 使用：com.mongodb.MongoClient#listDatabaseNames()
     *
     * @return
     */
    public static List<String> findAllDBNames() {
        List<String> dbNameList = new ArrayList<String>();
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

        /**getDatabase(String databaseName)：獲取指定的資料庫
         * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
         * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
         * listDatabaseNames()：獲取 MongoDB 服務端所有資料庫
         * 先返回 迭代器 MongoIterable，在根據迭代器獲取 遊標 MongoCursor
         * 最後遍歷遊標進行取值
         * */
        MongoIterable<String> mongoIterable = mongoClient.listDatabaseNames();
        MongoCursor<String> mongoCursor = mongoIterable.iterator();
        while (mongoCursor.hasNext()) {
            String dbName = mongoCursor.next();
            System.out.println("dbName>>>" + dbName);
            dbNameList.add(dbName);
        }
        /**
         * 控制檯輸出示例：
         * dbName>>>admin
         * dbName>>>config
         * dbName>>>java
         * dbName>>>local
         */
        mongoClient.close();
        return dbNameList;
    }

    /**
     * 獲取 MongoDB 服務端所有資料庫 文件物件
     * 使用 com.mongodb.MongoClient#listDatabases()
     *
     * @return ：返回的 Document 包含了資料庫的詳細資訊
     */
    public static List<Document> findAllDBs() {
        List<Document> dbList = new ArrayList<Document>();
        /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
         * 實際開發中應該將 MongoDB 伺服器地址配置在配置檔案中*/
        MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

        /**getDatabase(String databaseName)：獲取指定的資料庫
         * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
         * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
         * listDatabaseNames()：獲取 MongoDB 服務端所有資料庫
         * 先返回 迭代器 MongoIterable，在根據迭代器獲取 遊標 MongoCursor
         * 最後便利遊標進行取值
         * mongoClient.listDatabases()：原理同上，只是返回的最終結果不是 String,而是 Document
         * */

        ListDatabasesIterable<Document> databasesIterable = mongoClient.listDatabases();
        MongoCursor<Document> mongoCursor = databasesIterable.iterator();
        while (mongoCursor.hasNext()) {
            Document db = mongoCursor.next();
            System.out.println(db.toJson());
            dbList.add(db);
        }
        /**
         * 輸出內容示例：
         * { "name" : "admin", "sizeOnDisk" : 32768.0, "empty" : false }
         * { "name" : "config", "sizeOnDisk" : 73728.0, "empty" : false }
         * { "name" : "local", "sizeOnDisk" : 73728.0, "empty" : false }
         * { "name" : "mydb1", "sizeOnDisk" : 65536.0, "empty" : false }
         * { "name" : "mydb2", "sizeOnDisk" : 1.99491584E8, "empty" : false }
         */
        mongoClient.close();
        return dbList;
    }

    public static void main(String[] args) {
        findAllDBs();
    }
}

MongoCollectionTest

package com.lct;

import com.mongodb.MongoClient;
import com.mongodb.client.*;
import org.bson.Document;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by Administrator on 2018/9/17 0017.
 * MongoDB 集合測試
 */
public class MongoCollectionTest {

    /**
     * 顯示的為指定資料庫建立集合
     *
     * @param databaseName   資料庫名稱，如 java，不存在時會自動建立，存在時不受影響
     * @param collectionName 集合名詞，如 c1，不存在時會自動建立，存在時則會丟擲異常： already exists'
     */
    public static void createCollectionByShow(String databaseName, String collectionName) {
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**createCollection(String var1)：顯示建立集合，此時 java 資料庫下會立即建立 c1 集合
             * 注意如果 資料庫中已經存在此 集合，則會丟擲異常： already exists'
             *
             * 執行完成後，MongoDB  客戶端可以用命令檢視：
             * > show dbs
             * admin   0.000GB
             * config  0.000GB
             * java    0.000GB
             * local   0.000GB
             * > use java
             * switched to db java
             * > show tables
             * c1
             * */
            mongoDatabase.createCollection(collectionName);

            /**關閉 MongoDB 客戶端連線，釋放資源*/
            mongoClient.close();
        }
    }

    /**
     * 獲取指定資料庫下的指定集合
     *
     * @param databaseName   資料庫名稱，不存在時，MongoCollection 大小為 0
     * @param collectionName 獲取的集合名稱,不存在時，MongoCollection 大小為 0
     */
    public static MongoCollection<Document> getCollectionByName(String databaseName, String collectionName) {
        MongoCollection<Document> mongoCollection = null;
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**獲取資料庫中的集合
             * 如果集合不存在，則返回的 MongoCollection<Document> 文件個數為0，不會為 null*/
            mongoCollection = mongoDatabase.getCollection(collectionName);
        }
        return mongoCollection;
    }

    /**
     * 獲取指定資料庫下的所有集合名稱
     *
     * @param databaseName 資料庫名稱
     * @return 返回集合名稱的列表
     */
    public static List<String> getAllCollectionNames(String databaseName) {
        List<String> collectionNameList = new ArrayList<String>();
        if (databaseName != null && !"".equals(databaseName)) {

            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /** listCollectionNames()：獲取整個資料庫下集合名稱列表*/
            MongoIterable<String> mongoIterable = mongoDatabase.listCollectionNames();

            /** first()：獲取資料庫下第一個集合名稱
             * 不存在時返回 null */
            String first = mongoIterable.first();
            System.out.println("first collectionName>>>" + first);

            /**獲取它的遊標進行迭代集合名稱
             * 資料庫下沒有集合時，則大小為空，不會為 null
             * */
            MongoCursor<String> mongoCursor = mongoIterable.iterator();
            while (mongoCursor.hasNext()) {
                String collectionName = mongoCursor.next();
                collectionNameList.add(collectionName);
            }
            /**關閉遊標*/
            mongoCursor.close();

            /**關閉 MongoDB 客戶端連線*/
            mongoClient.close();
        }
        return collectionNameList;
    }

    /**
     * 獲取指定資料庫下的所有集合
     * 使用：com.mongodb.client.MongoDatabase#listCollections()
     *
     * @param databaseName 資料庫名稱
     * @return 返回集合的 Document 物件，此物件包含集合的完整資訊
     */
    public static List<Document> getAllCollection(String databaseName) {
        List<Document> collectionList = new ArrayList<Document>();
        if (databaseName != null && !"".equals(databaseName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             * 實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /** mongoDatabase.listCollections()：獲取當前資料庫下所有的集合列表
             * ListCollectionsIterable<Document> 與 MongoCollection<Document> 不同
             */
            ListCollectionsIterable<Document> collectionsIterable = mongoDatabase.listCollections();

            /** collectionsIterable.first()：返回第一個集合的 Document 物件，包含集合詳細資訊
             * 集合不存在時，返回 null
             */
            Document firstDocument = collectionsIterable.first();
            if (firstDocument != null) {
                System.out.println("first collection >>>" + firstDocument.toJson());
            }

            /** collectionsIterable.iterator() 獲取 MongoCursor<Document> 遊標
             * 不用擔心空指標異常*/
            MongoCursor<Document> mongoCursor = collectionsIterable.iterator();
            while (mongoCursor.hasNext()) {
                Document loopDocument = mongoCursor.next();
                System.out.println("loop collection >>>" + loopDocument.toJson());
                collectionList.add(loopDocument);
            }
            /**關閉遊標*/
            mongoCursor.close();
            /**關閉 MongoDB 客戶端連線*/
            mongoClient.close();
        }
        return collectionList;
    }


    /**
     * 刪除指定資料庫下的指定集合，如果資料庫中不存在此集合，則不會做任何處理
     * 使用：com.mongodb.client.MongoCollection#drop()
     *
     * @param databaseName   資料庫名稱
     * @param collectionName 獲取的集合名稱
     */
    public static void delCollection(String databaseName, String collectionName) {
        if (databaseName != null && !"".equals(databaseName) && collectionName != null && !"".equals(collectionName)) {
            /** MongoClient(String host, int port)：直接指定 MongoDB IP 與埠進行連線
             *  實際應用中應該將 MongoDB 服務端地址配置在 配置檔案中*/
            MongoClient mongoClient = new MongoClient("127.0.0.1", 27017);

            /**getDatabase(String databaseName)：獲取指定的資料庫
             * 如果此資料庫不存在，則會自動建立，此時存在記憶體中，伺服器不會存在真實的資料庫檔案，show dbs 命令 看不到
             * 如果再往其中新增資料，伺服器則會生成資料庫檔案，磁碟中會真實存在，show dbs 命令 可以看到
             * */
            MongoDatabase mongoDatabase = mongoClient.getDatabase(databaseName);

            /**獲取資料庫中的集合*/
            MongoCollection<Document> mongoCollection = mongoDatabase.getCollection(collectionName);

            /**刪除當前集合，如果集合不存在，則不做任何處理，不會拋異常*/
            mongoCollection.drop();
            mongoClient.close();
        }
    }
    public static void main(String[] args) {
        delCollection("java","c3");
    }
}