Mongodb系列- java客户端简单使用(CRUD)

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

import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.CreateCollectionOptions;
import com.mongodb.client.result.DeleteResult;
/**
 * MongoDB管理类
 * @author jiangyuechao
 *
 */
public class MongoDBHelper {
    static Logger logger = LoggerFactory.getLogger(MongoDBHelper.class);

    static String ip = "10.80.18.1";
    //10.80.21.41 10.80.18.1
    static MongoClient mongoClient = new MongoClient(ip, 27017);
    //MongoDatabase实例是不可变的
    static MongoDatabase database;
    //firstDB
    public static void connect(String databaseName){
        database = mongoClient.getDatabase(databaseName);
    }
    
    public static MongoCollection<Document> getCollection(String collectionName){
        //MongoCollection实例是不可变的
        if(!collectionExists(collectionName)){
            return null;
        }
        MongoCollection<Document> collection = database.getCollection(collectionName);
        return collection;
    }
    
    public static boolean collectionExists(final String collectionName) {
         boolean collectionExists = database.listCollectionNames()
                .into(new ArrayList<String>()).contains(collectionName);
        return collectionExists;
        /*MongoIterable<String> mongoIterable = database.listCollectionNames();
        for (Iterator<String> iterator = mongoIterable.iterator(); iterator.hasNext();) {
            String name = iterator.next();
            logger.info("name:{}", name);
            if(name.equals(collectionName)){
                return true;
            }
        }
        return false;*/
    }
    
    public static void getAllDocuments(MongoCollection<Document> collection){
        MongoCursor<Document> cursor = collection.find().iterator();
        try {
            while (cursor.hasNext()) {
                System.out.println(cursor.next().toJson());
            }
        } finally {
            cursor.close();
        }
    }
    
    public static String getDocumentFirst(MongoCollection<Document> collection){
        Document myDoc = collection.find().first();
        return myDoc.toJson();
    }
    
    public static void createDocument(MongoCollection<Document> collection,Map<String,Object> map){
        System.out.println("--------------------");
        map.forEach((k,v)->{ System.out.println("Key : " + k + " Value : " + v);});
    }
    /**
     * 插入一个Document
     * @param collection
     * @param doc
     */
    public static void insertDocument(MongoCollection<Document> collection,Document doc){
        collection.insertOne(doc);
    }
    /**
     * 插入多个Document
     * @param collection
     * @param documents
     */
    public static void insertManyDocument(MongoCollection<Document> collection,List<Document> documents){
        collection.insertMany(documents);
    }
    /**
     * 显示创建集合
     */
    public static void explicitlyCreateCollection(String collectionName){
        database.createCollection(collectionName,
                new CreateCollectionOptions().capped(false));
    }

    // 删除集合的所有文档
    public static long deleteAllDocument(MongoCollection<Document> collection) {
        DeleteResult deleteResult = collection.deleteMany(new Document());
        long count = deleteResult.getDeletedCount();
        return count;
    }

    // 删除集合
    public static void deleteCollection(MongoCollection<Document> collection) {
        collection.drop();
    }

    /**
     * <p>
     * 关闭客户端
     * </p>
     * 
     * @author jiangyuechao 2018年4月9日 上午11:23:36
     */
    public static void closeDb() {
        mongoClient.close();
    }
}

package com.chaochao.mongodb;
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Filters.gte;
import static com.mongodb.client.model.Filters.lt;

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

import org.bson.Document;

import com.mongodb.client.MongoCollection;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

public class QuickTour {
    static String databaseName = "firstDB";
    static String collectionName = "firstCollection1";
    static MongoCollection<Document> firstCollection;
    
    public static void main(String[] args) {
        QuickTour  quickTour = new QuickTour();
        quickTour.setUp();
//        quickTour.updateMultipleDoc();
//        quickTour.deleteMultiple();
        quickTour.getAllDocuments();
    }
    
    /**
     * 连接数据库
     */
    public void setUp(){
        MongoDBHelper.connect(databaseName);
        firstCollection =  MongoDBHelper.getCollection(collectionName);
    }
    public void getAllDocuments(){
        MongoDBHelper.getAllDocuments(firstCollection);
    }
    
    public void getDocumentFirst(){
        MongoDBHelper.connect(databaseName);
        MongoCollection<Document> collection = MongoDBHelper.getCollection(collectionName);
        String json = MongoDBHelper.getDocumentFirst(collection);
        System.out.println(json);
    }
    
    /**
     * 返回符合匹配条件的第一个doc
     * @param collection
     */
    public void getDocMatcheFilter(){
        Document myDoc = firstCollection.find(eq("y", 2)).first();
        System.out.println(myDoc.toJson());
    }
    
    public void getAllDocMatcheFilter(){
        firstCollection.find(Filters.gt("i", 10)).forEach((Document document)->{System.out.println(document.toJson());});
    }
    
    public void updateOneDoc(){
        UpdateResult updateResult = firstCollection.updateOne(Filters.eq("i", 12), new Document("$set", new Document("i", 21)));
        System.out.println(updateResult.getModifiedCount());
    }
    public void updateMultipleDoc(){
        UpdateResult updateResult = firstCollection.updateMany(lt("i", 100), new Document("$inc", new Document("i", 100)));
        System.out.printf("count:%s,insertedId:%s",updateResult.getModifiedCount(),updateResult.getUpsertedId());
        System.out.println();
    }
    
    public void deleteOne(){
        DeleteResult deleteResult = firstCollection.deleteOne(eq("i", 121));
        System.out.println(deleteResult.getDeletedCount());
    }
    public void deleteMultiple(){
        DeleteResult deleteResult = firstCollection.deleteMany(gte("i", 100));
        System.out.println(deleteResult.getDeletedCount());
    }
    
    /**
     * 插入一个doc
     * @param collection
     */
    public void insertDocument(){
        Document doc = new Document("name", "MongoDB")
                    .append("type", "database")
                    .append("count", 1)
                    .append("versions", Arrays.asList("v3.2", "v3.0", "v2.6"))
                    .append("info", new Document("x", 203).append("y", 102));
        MongoDBHelper.insertDocument(firstCollection, doc);
    }
    /**
     * 插入多个doc
     * @param collection
     */
    public void insertMultipleDoc(){
        List<Document> documents = new ArrayList<Document>();
        for (int i = 0; i < 100; i++) {
            documents.add(new Document("i", i));
        }

        MongoDBHelper.insertManyDocument(firstCollection, documents);
    }
    
    public void countDocs(){
        System.out.println(firstCollection.getNamespace().getCollectionName()+"-count:"+firstCollection.count());
    }
    
}