com.jquicker.persistent.nosql.mongo.MongoDB Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jquicker-core Show documentation
There is a newer version: 1.1.0
package com.jquicker.persistent.nosql.mongo;

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

import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;

import com.jquicker.model.Pager;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.ListIndexesIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.MongoIterable;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;

/**
 * MongoDB无需预定义数据库和集合,在使用的时候会自动创建

 * 集合可以理解为关系型数据库中的表
 * 
 * @author OL
 */
public class MongoDB {

	private static Map pool = new HashMap();

	private MongoClient client;

	private MongoDatabase database;

	public MongoDB(String host, int port, String dbName) {
		String key = host + "-" + port;
		client = pool.get(key);
		if (client == null) {
			client = new MongoClient(host, port); // 实例化一个mongo客户端
			pool.put(key, client);
		}
		this.database(dbName);
	}

	/**
	 * 插入数据
	 * 
	 * @param collectionName
	 * @param docs
	 * @author OL
	 */
	public void insert(String collectionName, Document... docs) {
		List documents = new ArrayList();
		for (Document doc : docs) {
			documents.add(doc);
		}
		this.collection(collectionName).insertMany(documents);
	}

	/**
	 * 通过_id删除
	 * 
	 * @param collectionName
	 * @param id
	 * @return
	 * @author OL
	 */
	public DeleteResult deleteById(String collectionName, String id) {
		ObjectId _id = new ObjectId(id);
		return this.collection(collectionName).deleteOne(Filters.eq("_id", _id));
	}

	/**
	 * 删除符合条件的第一个文档

	 * filter参数可通过以下方式构造：

	 * 一：通过com.mongodb.client.model.Filters类的eq、ne、gt等方法

	 * 二：通过new BasicDBObject()对象
	 * 
	 * @param collectionName
	 * @param filter
	 * @author OL
	 */
	public DeleteResult deleteOne(String collectionName, Bson filter) {
		DeleteResult result = this.collection(collectionName).deleteOne(filter);
		return result;
	}

	/**
	 * 删除符合条件的所有文档
	 * 
	 * @param collectionName
	 * @param filter
	 * @author OL
	 */
	public DeleteResult deleteMany(String collectionName, Bson filter) {
		DeleteResult result = this.collection(collectionName).deleteMany(filter);
		return result;
	}

	/**
	 * 通过_id更新
	 * 
	 * @param collectionName
	 * @param id
	 * @param doc
	 * @return
	 * @author OL
	 */
	public UpdateResult updateById(String collectionName, String id, Document updateData) {
		ObjectId _id = new ObjectId(id);
		return this.collection(collectionName).updateOne(Filters.eq("_id", _id), new Document("$set", updateData));
	}

	/**
	 * 更新符合条件的第一个文档
	 * 
	 * @param collectionName
	 * @param filter
	 * @param updateData
	 * @author OL
	 */
	public UpdateResult updateOne(String collectionName, Bson filter, Document updateData) {
		UpdateResult result = this.collection(collectionName).updateOne(filter, new Document("$set", updateData));
		return result;
	}

	/**
	 * 更新符合条件的所有文档
	 * 
	 * @param collectionName
	 * @param filter
	 * @param updateData
	 * @return
	 * @author OL
	 */
	public UpdateResult updateMany(String collectionName, Bson filter, Document updateData) {
		UpdateResult result = this.collection(collectionName).updateMany(filter, new Document("$set", updateData));
		return result;
	}

	/**
	 * 替换符合条件的第一个文档
	 * 
	 * @param collectionName
	 * @param filter
	 * @param replacement
	 * @author OL
	 */
	public UpdateResult replaceOne(String collectionName, Bson filter, Document replacement) {
		UpdateResult result = this.collection(collectionName).replaceOne(filter, replacement);
		return result;
	}

	/**
	 * 查询总数
	 * 
	 * @param collectionName
	 * @return
	 * @author OL
	 */
	public long count(String collectionName) {
		return this.collection(collectionName).countDocuments();
	}

	/**
	 * 查询总数
	 * 
	 * @param collectionName
	 * @param filter
	 * @return
	 * @author OL
	 */
	public long count(String collectionName, Bson filter) {
		return this.collection(collectionName).countDocuments(filter);
	}

	/**
	 * 查询单条数据
	 * 
	 * @param collectionName
	 * @param filter
	 * @return
	 * @author OL
	 */
	public Document findOne(String collectionName, Bson filter) {
		return this.collection(collectionName).find(filter).first();
	}

	/**
	 * 通过_id查询
	 * 
	 * @param collectionName
	 * @param id
	 * @return
	 * @author OL
	 */
	public Document findById(String collectionName, String id) {
		ObjectId _id = new ObjectId(id);
		return this.collection(collectionName).find(Filters.eq("_id", _id)).first();
	}

	/**
	 * 查询数据
	 * 
	 * @param collectionName
	 * @return
	 * @author OL
	 */
	public FindIterable find(String collectionName) {
		return this.collection(collectionName).find();
	}

	/**
	 * 查询数据
	 * 
	 * @param collectionName
	 * @param limit
	 * @return
	 * @author OL
	 */
	public FindIterable find(String collectionName, int limit) {
		return this.collection(collectionName).find().limit(limit);
	}

	/**
	 * 查询数据
	 * 
	 * @param collectionName
	 * @param filter
	 * @return
	 * @author OL
	 */
	public FindIterable find(String collectionName, Bson filter) {
		return this.collection(collectionName).find(filter);
	}

	/**
	 * 查询数据
	 * 
	 * @param collectionName
	 * @param filter
	 * @param limit
	 * @return
	 * @author OL
	 */
	public FindIterable find(String collectionName, Bson filter, int limit) {
		return this.collection(collectionName).find(filter).limit(limit);
	}

	/**
	 * 分页查询数据
	 * 
	 * @param collectionName
	 * @param filter
	 * @param offset
	 * @param limit
	 * @return
	 * @author OL
	 */
	public Pager findPage(String collectionName, Bson filter, int offset, int size) {
		FindIterable iterable = this.collection(collectionName).find(filter).skip(offset).limit(size);
		long totalCount = this.count(collectionName, filter);
		List list = new ArrayList();
		for (Document document : iterable) {
			list.add(document);
		}
		Pager pager = new Pager();
		pager.setOffset(offset);
		pager.setPageSize(size);
		pager.setTotalSize(totalCount);
		pager.setRecords(list);
		return pager;
	}

	/**
	 * 查询数据并排序
	 * 
	 * @param collectionName
	 * @param sort
	 * @return
	 * @author OL
	 */
	public FindIterable sort(String collectionName, Bson sort) {
		return this.collection(collectionName).find().sort(sort);
	}

	/**
	 * 查询数据并排序
	 * 
	 * @param collectionName
	 * @param sort
	 * @param limit
	 * @return
	 * @author OL
	 */
	public FindIterable sort(String collectionName, Bson sort, int limit) {
		return this.collection(collectionName).find().sort(sort).limit(limit);
	}

	/**
	 * 查询数据并排序
	 * 
	 * @param collectionName
	 * @param filter
	 * @param sort
	 * @return
	 * @author OL
	 */
	public FindIterable sort(String collectionName, Bson filter, Bson sort) {
		return this.collection(collectionName).find(filter).sort(sort);
	}

	/**
	 * 查询数据并排序
	 * 
	 * @param collectionName
	 * @param filter
	 * @param sort
	 * @param limit
	 * @return
	 * @author OL
	 */
	public FindIterable sort(String collectionName, Bson filter, Bson sort, int limit) {
		return this.collection(collectionName).find(filter).sort(sort).limit(limit);
	}

	/**
	 * 分页查询数据并排序
	 * 
	 * @param collectionName
	 * @param filter
	 * @param sort
	 * @param offset
	 * @param limit
	 * @return
	 * @author OL
	 */
	public Pager sortPage(String collectionName, Bson filter, Bson sort, int offset, int size) {
		FindIterable iterable = this.collection(collectionName).find(filter).sort(sort).skip(offset).limit(size);
		long totalCount = this.count(collectionName, filter);
		List list = new ArrayList();
		for (Document document : iterable) {
			list.add(document);
		}
		Pager pager = new Pager();
		pager.setOffset(offset);
		pager.setPageSize(size);
		pager.setTotalSize(totalCount);
		pager.setRecords(list);
		return pager;
	}

	/**
	 * 聚合查询
	 * 
	 * @param collectionName
	 * @param pipeline
	 * @author OL
	 */
	public void aggregate(String collectionName, List pipeline) {
		this.collection(collectionName).aggregate(pipeline);
	}

	/**
	 * 创建索引

	 * 1.将等值索引放在最前面 

	 * 2.尽量将排序字段放在范围字段的后面 

	 * 3.$nin和$ne跟索引没有关系
	 * 
	 * @param collectionName
	 * @param keys
	 * @return 索引名称
	 * @author OL
	 */
	public String createIndex(String collectionName, Bson keys) {
		return this.collection(collectionName).createIndex(keys);
	}

	/**
	 * 返回指定集合的索引列表
	 * 
	 * @param collectionName
	 * @return
	 * @author OL
	 */
	public ListIndexesIterable listIndexes(String collectionName) {
		return this.collection(collectionName).listIndexes();
	}

	/**
	 * 实例化一个mongo数据库

	 * MongoDB无需预定义数据库和集合,在使用的时候会自动创建
	 * 
	 * @param dbName
	 * @return
	 * @author OL
	 */
	public MongoDatabase database(String dbName) {
		this.database = client.getDatabase(dbName);
		return database;
	}

	/**
	 * 返回指定数据库中的指定集合
	 * 
	 * @param collectionName
	 * @return
	 * @author OL
	 */
	public MongoCollection collection(String collectionName) {
		return database.getCollection(collectionName);
	}

	/**
	 * 返回当前数据库下所有集合名称
	 * 
	 * @param dbName
	 * @return
	 * @author OL
	 */
	public MongoIterable listCollectionNames() {
		return database.listCollectionNames();
	}

	/**
	 * 删除集合
	 * 
	 * @param collectionName
	 * @author OL
	 */
	public void dropCollection(String collectionName) {
		this.collection(collectionName).drop();
	}

	/**
	 * 删除数据库
	 * 
	 * @param dbName
	 * @author OL
	 */
	public void dropDatabase(String dbName) {
		database.drop();
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		String dbName = "test";
		String collectionName = "collection1";
		MongoDB mongo = new MongoDB("192.168.217.129", 27017, dbName);
		Map map1 = new HashMap();
		map1.put("name", "张三");
		map1.put("age", 18);
		mongo.insert(collectionName, new Document(map1));
		mongo.find(collectionName);
	}

}