MongoDB——JavaAPI详解

环境配置

引入MongoDB驱动：

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongo-java-driver</artifactId>
    <version>3.8.2</version>
</dependency>

连接数据库

public class BaseDemo {
    public static void main(String[] args) {
        //创建连接对象
        MongoClient client = new MongoClient("127.0.0.1", 27017);
        //获取数据库
        MongoDatabase db = client.getDatabase("test");
        //获取集合
        MongoCollection<Document> book = db.getCollection("book");
        client.close();
    }
}

封装成工具类：

public class MongoDBUtil {

    private  static MongoClient client = null;

    static {
        if (client == null) {
            client = new MongoClient("127.0.0.1", 27017);
        }
    }

    //获取数据库
    public static MongoDatabase getDatabase(String dbName) {
        return client.getDatabase(dbName);
    }

    //获取集合
    public static MongoCollection getCollection(String dbName, String collName){
        return getDatabase(dbName).getCollection(collName);
    }

    public static void main(String[] args) {
        MongoDBUtil.getCollection("test", "person");
        System.out.println("ok");
    }
}

带用户认证的工具类：

public class MongoDBAuthUtil {

    private static MongoClient client = null;

    static {
        if (client == null) {
            //创建一个封装用户认证信息
            MongoCredential credential = MongoCredential.createCredential("root", "test", "123456".toCharArray());
            //封装mongoDB的地址与端口
            ServerAddress address = new ServerAddress("127.0.0.1", 27017);
            client = new MongoClient(address, credential, MongoClientOptions.builder().build());
        }
    }

    //获取数据库
    public static MongoDatabase getDatabse(String dbName){
        return client.getDatabase(dbName);
    }

    //获取集合
    public static MongoCollection getCollection(String dbName, String collName) {
        MongoDatabase databse = getDatabse(dbName);
        return databse.getCollection(collName);
    }

    public static void main(String[] args) {
        MongoDBAuthUtil.getDatabse("test");
        System.out.println("ok");
    }
}

带用户认证的连接池：

public class MongoDBAuthPoolUtil {

    private static MongoClient client = null;

    static {
        if (client == null) {
            MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
            builder.connectionsPerHost(10);//每个地址的最大连接数
            builder.connectTimeout(5000);//连接超时时间
            builder.socketTimeout(5000);//读写操作超时时间
            MongoCredential credential = MongoCredential.createCredential("root", "test", "123456".toCharArray());
            ServerAddress address = new ServerAddress("127.0.0.1", 27017);
            client = new com.mongodb.MongoClient(address, credential, builder.build());
        }
    }

    //获取MongoDB数据库
    public static MongoDatabase getDatabase(String dbName) {
        return client.getDatabase(dbName);
    }

    //获取MongoDb集合
    public static MongoCollection getCollection(String dbName, String collName) {
        return getDatabase(dbName).getCollection(collName);
    }


    //创建集合
    public static void createCollection(String dbName, String collName) {
        getDatabase(dbName).createCollection(collName);
    }

    //删除集合
    public static void dropCollection(MongoCollection coll) {
        coll.drop();
    }
}

集合操作

public class CollectionDemo {
    public static void main(String[] args) {
        // 创建 MongoDB 连接
        MongoClient mongo = new MongoClient( "localhost" , 27017 );

        //访问数据库
        MongoDatabase db = mongo.getDatabase("test");

        //创建集合
        //CreateCollectionOptions可以指定参数，比如最大文档数、文档大小等等...
        CreateCollectionOptions cco = new CreateCollectionOptions();
        db.createCollection("ceshi", cco);

        //检索集合
        MongoCollection<Document> col = db.getCollection("ceshi");

        //查看所有集合
        MongoIterable<String> nameList = db.listCollectionNames();
        for (String name : nameList)
            System.out.println(name);
        ListCollectionsIterable<Document> docList = db.listCollections();
        for (Document doc : docList)
            System.out.println(doc.toString() + " " + doc.size());

        //删除集合
        col.drop();

        mongo.close();
    }
}

文档操作

1、插入

public class InsertDocument {


    public static void main(String[] args) {
        InsertDocument insertDocument = new InsertDocument();
        insertDocument.insertSingleDocument();
        insertDocument.insertManyDocument();
    }


    /**
     * 添加单个文档
     */
    public void insertSingleDocument() {
        //获取集合
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        // {} ---> Dcument
        // append(Stirng key, Object value) ----> {key: value}
        Document document = new Document();
        document.append("name", "三国演义").append("price", 22.6);
        //插入参数配置对象
        InsertOneOptions iop = new InsertOneOptions();
        collection.insertOne(document, iop);
    }

    /**
     * 文档的批量添加
     */
    public void insertManyDocument() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        List<Document> list = new ArrayList<Document>();
        for (int i = 0; i < 5; i++) {
            Document document = new Document();
            document.append("name", "哈利波特" + i)
                    .append("price", 66.3 + i);
            list.add(document);
        }
        //插入参数配置对象
        InsertManyOptions imo = new InsertManyOptions();
        collection.insertMany(list, imo);
    }
}

2、查询文档

public class FindDocment {

    public static void main(String[] args) {
        FindDocment findDocment = new FindDocment();
        // findDocment.selectDocumentById();
        // findDocment.selectDocumentConditionByGt();
        // findDocment.selectDocumentConditionByType();
        // findDocment.selectDocumentConditionByIn();
        // findDocment.selectDocumentConditionByRegex();
        // findDocment.selectDocumentConditionUseAnd();
        // findDocment.selectDocumentConditionUseOr();
        // findDocment.selectDocumentConditionUseAndOr();
        findDocment.selectDocumentSorting();
    }

    /**
     * 根据_id查询文档
     * db.class.find("1")
     */
    public void selectDocumentById() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "class");
        FindIterable<Document> iterable = collection.find(Filters.eq("_id", 1));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            Document document = cursor.next();
            System.out.println(document.get("_id"));
            System.out.println(document.get("name"));
            System.out.println(document.get("student"));
        }
    }

    /**
     * 查询多个文档
     * db.book.find({price:{$gt: 10}})
     */
    public void selectDocumentConditionByGt() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.gt("price", 10));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 查询多个文档 $type
     * db.book.find({price: {$type: "number"}})
     */
    public void selectDocumentConditionByType() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.type("price", "number"));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 查询多个文档
     * db.book.find({name: {$in:["三国演义", "说文解字"]}})
     */
    public void selectDocumentConditionByIn() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.in("name", "三国演义", "说文解字"));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 查询多个文档
     * db.book.find({name: {$regex: /^哈利波特/}})
     */
    public void selectDocumentConditionByRegex() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.regex("name", Pattern.compile("^哈利波特")));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 逻辑运算符 $and
     * db.book.find({$and:[{name: {$regex:/^哈利波特/}}, {price: 11.1}]})
     */
    public void selectDocumentConditionUseAnd() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.and(Filters.regex("name", Pattern.compile("^哈利波特")),
                Filters.eq("price", 11.1)));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }

    }

    /**
     * 逻辑运算符 $or
     * db.book.find($or: [{name: {$regex:/^哈利波特/}}, {price:22.6}])
     */
    public void selectDocumentConditionUseOr() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.or(Filters.regex("name", Pattern.compile("^哈利波特")),
                Filters.eq("price", 22.6)));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 逻辑运算符 $and和$or联合使用
     * db.book.find({$or: [{$and:[{name:"说文解字"},{price:23.4}]},{name:{$regex:"^哈利波特"}}]})
     */
    public void selectDocumentConditionUseAndOr() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find(Filters.or(
                Filters.and(Filters.eq("name", "说文解字"), Filters.eq("price", 23.4)),
                Filters.regex("name", Pattern.compile("^哈利波特"))
        ));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }

    /**
     * 排序处理
     * db.book.find().sort(price: -1)
     */
    public void selectDocumentSorting() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        FindIterable<Document> iterable = collection.find().sort(new Document("price", -1));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }
}

3、更新文档

public class UpdateDocument {


    public static void main(String[] args) {
        UpdateDocument updateDocument = new UpdateDocument();
        updateDocument.updateSingleDocumentSingleKey();
        updateDocument.updateSingleDocumentManyKey();
        updateDocument.updateManyDocumentSingleKey();
        updateDocument.updateManyDocumentManyKey();
        updateDocument.updateDocumentArray();
    }

    /**
     * 更新单个文档单个键
     * db.book.update({name:{$eq:"哈利波特1"}, {$set: {price:99.9}}})
     */
    public void updateSingleDocumentSingleKey() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        //更新文档，下面二者等价
        //collection.updateOne(Filters.eq("name", "哈利波特1"), new Document("$set", new Document("price", 99.9)));
        collection.updateOne(Filters.eq("name", "哈利波特1"), Updates.set("price", 99.9));
    }

    /**
     * 更新单个文档多个键
     * db.book.update({name:{$eq:"哈利波特1"}, {$set:{price:111, count:50}}})
     */
    public void updateSingleDocumentManyKey() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        // 下面二者等价
        // collection.updateOne(Filters.eq("name", "哈利波特1"), new Document("$set", new Document("price", 111).append("count", 50)));
        UpdateResult updateResult = collection.updateOne(Filters.eq("name", "哈利波特1"), Updates.combine(Updates.set("price", 111), Updates.set("count", 50)));
        System.out.println(updateResult.getMatchedCount());
    }

    /**
     * 跟新多个文档中的单个键
     * db.book.update({name:{$regex:"^哈利波特"}}, {$set: {count: 88}})
     */
    public void updateManyDocumentSingleKey() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        collection.updateMany(Filters.regex("name", "^哈利波特"), new Document("$set", new Document("count", 88)));
    }

    /**
     * 更新多个文档中的多个键
     * db.book.update({name:{$regex: "^哈利波特"}}, {$set: {count: 99, price:11.1}})
     */
    public void updateManyDocumentManyKey() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");
        collection.updateMany(Filters.regex("name", "^哈利波特"), new Document("$set", new Document("count", 99).append("price", 11.1)));
    }


    /**
     * 跟新文档中的数组
     * db.array.update({_id:1}, {$push: {char: z}})
     */
    public void updateDocumentArray() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "array");
        collection.updateOne(Filters.eq("_id", 1), new Document("$push", new Document("char", "z")));
    }

}

4、删除文档

public class RemoveDocument {
    public static void main(String[] args) {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");

        //删除单个文档
        DeleteResult deleteResult = collection.deleteOne(Filters.eq("name", "tom"));
        System.out.println(deleteResult.getDeletedCount());

        //删除多个文档
        DeleteResult dr = collection.deleteMany(Filters.regex("name", Pattern.compile("^哈利波特")));
        System.out.println(dr.getDeletedCount());
    }
}

5、Date相关

public class DateUtil {


    /**
     * Date To String
     */
    public static String dateToString(String parten, Date date) {
        SimpleDateFormat format = new SimpleDateFormat(parten);
        return format.format(date);
    }

    /**
     * String To Date
     */
    public static Date stringToDate(String parten, String date) {
        SimpleDateFormat format = new SimpleDateFormat(parten);
        Date d = null;
        try {
            d = format.parse(date);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return d;
    }
}

public class DateDocument {

    public static void main(String[] args) {
        DateDocument dateDocument = new DateDocument();
        dateDocument.insertDocumentSystemDate();
        dateDocument.selectDocumentDateUseEq();
    }


    /**
     * 插入系统当前日期
     * db.birthday.insert({_id:1, datetime: new Date()})
     */
    public void insertDocumentSystemDate() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "birthday");
        collection.insertOne(new Document("_id", 1).append("datetime", new Date()));
    }

    /**
     * 查询日期；查询生日为2019-05-01 13:32:13的用户信息
     * db.birthday.find({datetime: {$eq:new Date("2019-05-01 13:32:13")}})
     */
    public void selectDocumentDateUseEq() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "birthday");
        Date date = DateUtil.stringToDate("yyyy-MM-dd HH:mm:ss", "2019-05-01 13:32:13");
        FindIterable<Document> iterable = collection.find(Filters.eq("birthday", date));
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }
}

6、聚合

public class AggregateDocument {
    public static void main(String[] args) {
        AggregateDocument aggregateDocument = new AggregateDocument();
        aggregateDocument.selectDocumentAggregateCount();
        aggregateDocument.selectDocumentAggregateSum();
    }

    /**
     * 查询集合中的文档数量
     * db.book.aggregate([{$group:{_id:null, count:{$sum:1}}}])
     */
    public void selectDocumentAggregateCount() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");

        Document sum = new Document();
        sum.put("$sum", 1);
        Document count = new Document();
        count.put("_id", null);
        count.put("count", sum);

        Document group = new Document();
        group.put("$group", count);

        List<Document> list = new ArrayList<Document>();
        list.add(group);

        AggregateIterable iterable = collection.aggregate(list);
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()){
            System.out.println(cursor.next());
        }
    }

    /**
     * 查询集合中所有price键中的值的总和
     * db.books.aggregate([{$group: {_id:null, totalPrice: {$sum:"$price"}}}])
     */
    public void selectDocumentAggregateSum() {
        MongoCollection collection = MongoDBUtil.getCollection("test", "book");

        Document sum = new Document("$sum", "$price");
        Document totalPrice = new Document("totalPrice", sum).append("_id", null);
        Document group = new Document("$group", totalPrice);
        List<Document> list = new ArrayList<Document>();
        list.add(group);
        AggregateIterable<Document> iterable = collection.aggregate(list);
        MongoCursor<Document> cursor = iterable.iterator();
        while (cursor.hasNext()) {
            System.out.println(cursor.next());
        }
    }
}