MongoDB 通过 Java 代码 CRUD 数据库与集合

其他 2018-09-18 10:19:07 阅读次数: 0

本文导读

  • 相比 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");
    }
}

猜你喜欢

转载自blog.csdn.net/wangmx1993328/article/details/82711570
今日推荐
周排行
rac环境打PSU补丁ERROR:This patch is not applicable to GI home.
科学活动《离园倒计时》（时间）
Windows 沙箱开发踩坑
secureCRT 改变显示宽度
hdu多校第六场1008 （hdu6641）TDL 暴力
【low向】注册用户时密码强度的判定
__int64
context-params与init-params
JS三个编码函数和net编码System.Web.HttpUtility.UrlEncode比较
springboot通过重写addResourceHandlers拦截请求访问本地资源
每日归档
更多
2024-08-08(0)
2024-08-07(0)
2024-08-06(0)
2024-08-05(0)
2024-08-04(0)
2024-08-03(0)
2024-08-02(0)
2024-08-01(0)
2024-07-31(0)
2024-07-30(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022