目录

环境准备

mongo-java-driver 获取

新建项目

开启 MongoDB 服务端

CRUD

数据库操作

集合操作

文档文件内容

MongoDBTest

MongoCollectionTest

本文导读

相比 Java 操作 关系型数据库(如 Mysql) 而言，Java  操作 noSql 更加简单，因为没有事务这些操作

Java 操作 Mysql 数据库需要 Mysql 的连接驱动包，同理 Java 操作 MongoDB 也需要连接驱动包，叫 mongo-java-driver ！

本文将详细介绍如何下载驱动包 mongoDB-Java-Driver ，以及数据库操作、集合操作，对于文档操作将新开一篇进行介绍，可以参考《 MongoDB 通过 Java 代码 CRUD 文档》

环境准备

mongo-java-driver 获取

MongoDB 官网：https://www.mongodb.com/ 

MongoDB-Java-Driver 项目官方 GitHub 托管地址：https://github.com/mongodb/mongo-java-driver

MongoDB-Java-Driver 文档、API、Maven依赖，Jar 包获取地址：https://mongodb.github.io/mongo-java-driver/

先选择中间的 “ mongo-java-driver ”，后面的下拉框可以选择相应的版本。如果使用 Maven 项目，则可以直接复制文本域中的值

如果使用手动 导入开发包的方式，则可以点击左上角的 “ DOWNLOAD” 按钮进行下载，如下所示：

../
mongodb-driver-sync-3.10.1-javadoc.jar            2019-02-11 17:27    509375      
mongodb-driver-sync-3.10.1-javadoc.jar.asc        2019-02-11 17:27       475      
mongodb-driver-sync-3.10.1-javadoc.jar.asc.md...  2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1-javadoc.jar.asc.sh...  2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1-javadoc.jar.md5        2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1-javadoc.jar.sha1       2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1-sources.jar            2019-02-11 17:27     97451      
mongodb-driver-sync-3.10.1-sources.jar.asc        2019-02-11 17:27       475      
mongodb-driver-sync-3.10.1-sources.jar.asc.md...  2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1-sources.jar.asc.sh...  2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1-sources.jar.md5        2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1-sources.jar.sha1       2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1.jar                    2019-02-11 17:27    119701      
mongodb-driver-sync-3.10.1.jar.asc                2019-02-11 17:27       475      
mongodb-driver-sync-3.10.1.jar.asc.md5            2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1.jar.asc.sha1           2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1.jar.md5                2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1.jar.sha1               2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1.pom                    2019-02-11 17:27      1677      
mongodb-driver-sync-3.10.1.pom.asc                2019-02-11 17:27       475      
mongodb-driver-sync-3.10.1.pom.asc.md5            2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1.pom.asc.sha1           2019-02-11 17:27        40      
mongodb-driver-sync-3.10.1.pom.md5                2019-02-11 17:27        32      
mongodb-driver-sync-3.10.1.pom.sha1               2019-02-11 17:27        40      

新建项目

新建 Java SE 项目，不使用  Maven 管理，采用手动 导包的方式，进行  API 操作学习

本文使用 Java  JDK 1.8、MongoDB 4.0.2、Mongo-Java-Driver-3.8.1.jar。

现在最新版本分为 sync、async、legacy等版本，本文写的时候，最新版还是 3.8.1，需要的可以从百度网盘获取：https://pan.baidu.com/s/1j-wWb2pdb0dU7gz8Np_Cnw       提取码：a3hk 

开启 MongoDB 服务端

如下所示，使用免安全认证运行 MongoDB 服务器，使用默认端口 27017，MongoDB 版本为 4.0.2

C:UsersAdministrator.SC-201707281232>mongod --dbpath=D:MongoDBData
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:MongoDBData 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:MongoDBData" } }
2018-09-15T15:00:14.492+0800 I STORAGE  [initandlisten] Detected data files in D:MongoDBData 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 服务端未开启安全认证时：

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

如下所示，删除数据库方式如下：

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;
    }

集合操作

集合操作同样包括 集合创建、查询、删除 等

如下所示为显示的 创建集合。隐式创建 集合 与 隐式创建数据库一致，直接添加数据就会自动创建。

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

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

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 databaseN