package com.angular.base.util.mongodb;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.regex.Pattern;
import org.bson.BSONObject;
import org.bson.types.ObjectId;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import com.angular.oborInfo.po.Kv;
import com.mongodb.BasicDBList;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.MapReduceOutput;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
public class MongoDbUtil {
private MongoClient mg=null; //连接mongo的主要工具
private MongoDbUtil(String host,int port,String database,String username,String password)
{
if (mg == null)
{
MongoClientOptions.Builder buide = new MongoClientOptions.Builder();
buide.connectionsPerHost(100);// 与目标数据库可以建立的最大链接数
buide.connectTimeout(1000 * 60 * 20);// 与数据库建立链接的超时时间
buide.maxWaitTime(100 * 60 * 5);// 一个线程成功获取到一个可用数据库之前的最大等待时间
buide.threadsAllowedToBlockForConnectionMultiplier(100);
// buide.maxAutoConnectRetryTime(0); //最大自动连接重试时间
buide.maxConnectionIdleTime(0); //最大连接 闲置时间
buide.maxConnectionLifeTime(0); // 最大连接生存时间
buide.socketTimeout(0);
buide.socketKeepAlive(true);
MongoClientOptions myOptions = buide.build();
try
{
ServerAddress sa = new ServerAddress(host, port);
List<MongoCredential> mongoCredentialList = new ArrayList<MongoCredential>();
mongoCredentialList.add(MongoCredential.createCredential(username, database, password.toCharArray()));
if(!"".equals(username)&&!"".equals(password)){
mg=new MongoClient(sa, mongoCredentialList,myOptions);
}else{
mg=new MongoClient(sa,myOptions);
}
} catch (Exception e)
{
e.printStackTrace();
}
}
}
//单例模式
public static MongoDbUtil getInstance(String host,int port,String database,String username,String password){
return new MongoDbUtil(host,port,database,username, password);
}
//查询所有的数据库
public List<String> getAllDB(){
List<String> list=new ArrayList<String>();
for (String name : mg.getDatabaseNames()) {
list.add(name);
}
return list;
}
//查询对应数据库的所有集合
public List<String> getTargetDB(String db){
List<String> list=new ArrayList<String>();
for (String name : this.mg.getDB(db).getCollectionNames()) {
list.add(name);
}
return list;
}
//得到指定数据库的指定集合
public DBCollection getCollection(String db,String collection){
return this.mg.getDB(db).getCollectionFromString(collection);
}
//判断指定集合指定字段是否有索引 有索引 则不创建索引 无的话则创建
public boolean judgeIndex(String db,String collection,String files){
String index=files+"_1";
int m=0;
List<DBObject> indexInfo = getCollection(db, collection).getIndexInfo();
for(DBObject o:indexInfo){
for(String keys:o.keySet()){
if(o.get(keys).equals(index)){
m=1;
}
}
}
if(m==0){
getCollection(db, collection).createIndex(new BasicDBObject(files, 1));
System.out.println(db+"-"+collection+"-"+files+"字段索引创建成功");
}else{
System.out.println(db+"-"+collection+"-"+files+"已经有索引");
}
return true;
}
//插入数据到指定数据库，指定集合 (单个插入)
public boolean insertOne(String db,String collection,DBObject o){
getCollection(db, collection).insert(o);
return true;
}
/**
* 批量插入
*
* @param collection
* @param list
* 插入的列表
*/
public void insertBatch(String db,String collection, List<DBObject> list) {
if (list == null || list.isEmpty()) {
return;
}
getCollection(db,collection).insert(list);
}
/**
* 删除
*
* @param collection
* @param q
* 查询条件
*/
public void delete(String db,String collection, DBObject q) {
getCollection(db,collection).remove(q);
}
/**
* 批量删除
*
* @param collection
* @param list
* 删除条件列表
*/
public void deleteBatch(String db,String collection, List<DBObject> list) {
if (list == null || list.isEmpty()) {
return;
}
for (int i = 0; i < list.size(); i++) {
getCollection(db,collection).remove(list.get(i));
}
}
/**
* 计算集合总条数
*
* @param collection
*/
public long getCount(String db,String collection) {
return getCollection(db,collection).find().count();
}
/**
* 计算满足条件条数
*
* @param collection
* @param q
* 查询条件
*/
public long getCount(String db,String collection, DBObject q) {
return getCollection(db,collection).getCount(q);
}
/**
* 更新
*
* @param collection
* @param q
* 查询条件
* @param setFields
* 更新对象
*/
public void update(String db,String collection, DBObject q, DBObject setFields) {
getCollection(db,collection).updateMulti(q,new BasicDBObject("$set", setFields));
}
/**
* 查找集合所有对象
*
* @param collection
*/
public List<DBObject> findAll(String db,String collection) {
return getCollection(db,collection).find().toArray();
}
/**
* 按顺序查找集合所有对象
*
* @param collection
* 数据集
* @param orderBy
* 排序
*/
public List<DBObject> findAll(String db,String collection, DBObject orderBy) {
return getCollection(db,collection).find().sort(orderBy).toArray();
}
/**
* 查找（返回一个对象）
*
* @param collection
* @param q
* 查询条件
*/
public DBObject findOne(String db,String collection, DBObject q) {
return getCollection(db,collection).findOne(q);
}
/**
* 查找（返回一个对象）
*
* @param collection
* @param q
* 查询条件
* @param fileds
* 返回字段
*/
public DBObject findOne(String db,String collection, DBObject q, DBObject fileds) {
return getCollection(db,collection).findOne(q, fileds);
}
/**
* 查找返回特定字段（返回一个List<DBObject>）
*
* @param collection
* @param q
* 查询条件
* @param fileds
* 返回字段
*/
public List<DBObject> findLess(String db,String collection, DBObject q, DBObject fileds) {
DBCursor c = getCollection(db,collection).find(q, fileds);
if (c != null)
return c.toArray();
else
return null;
}
/**
* 查找返回特定字段（返回一个List<DBObject>）
*
* @param collection
* @param q
* 查询条件
* @param fileds
* 返回字段
* @param orderBy
* 排序
*/
public List<DBObject> findLess(String db,String collection, DBObject q, DBObject fileds, DBObject orderBy) {
DBCursor c = getCollection(db,collection).find(q, fileds).sort(orderBy);
if (c != null)
return c.toArray();
else
return null;
}
/**
* 分页查找集合对象，返回特定字段
*
* @param collection
* @param q
* 查询条件
* @param fileds
* 返回字段
* @pageNo 第n页
* @perPageCount 每页记录数
*/
public List<DBObject> findLess(String db,String collection, DBObject q, DBObject fileds, int pageNo,
int perPageCount) {
return getCollection(db,collection).find(q, fileds)
.skip((pageNo - 1) * perPageCount).limit(perPageCount)
.toArray();
}
/**
* 按顺序分页查找集合对象，返回特定字段
*
* @param collection
* 集合
* @param q
* 查询条件
* @param fileds
* 返回字段
* @param orderBy
* 排序
* @param pageNo
* 第n页
* @param perPageCount
* 每页记录数
*/
public List<DBObject> findLess(String db,String collection, DBObject q, DBObject fileds, DBObject orderBy,
int pageNo, int perPageCount) {
return getCollection(db,collection).find(q, fileds)
.sort(orderBy).skip((pageNo - 1) * perPageCount)
.limit(perPageCount).toArray();
}
/**
* 查找（返回一个List<DBObject>）
*
* @param collection
* @param q
* 查询条件
*/
public List<DBObject> find(String db,String collection, DBObject q) {
DBCursor c = getCollection(db,collection).find(q);
if (c != null)
return c.toArray();
else
return null;
}
/**
* 按顺序查找（返回一个List<DBObject>）
*
* @param collection
* @param q
* 查询条件
* @param orderBy
* 排序
*/
public List<DBObject> find(String db,String collection, DBObject q, DBObject orderBy) {
DBCursor c = getCollection(db,collection).find(q).sort(orderBy);
if (c != null)
return c.toArray();
else
return null;
}
/**
* 分页查找集合对象
*
* @param collection
* @param q
* 查询条件
* @pageNo 第n页
* @perPageCount 每页记录数
*/
public List<DBObject> find(String db,String collection, DBObject q, int pageNo,
int perPageCount) {
return getCollection(db,collection).find(q)
.skip((pageNo - 1) * perPageCount).limit(perPageCount)
.toArray();
}
/**
* 按顺序分页查找集合对象
*
* @param collection
* 集合
* @param q
* 查询条件
* @param orderBy
* 排序
* @param pageNo
* 第n页
* @param perPageCount
* 每页记录数
*/
public List<DBObject> find(String db,String collection, DBObject q, DBObject orderBy,
int pageNo, int perPageCount) {
return getCollection(db,collection).find(q)
.sort(orderBy).skip((pageNo - 1) * perPageCount)
.limit(perPageCount).toArray();
}
/**
* distinct操作
*
* @param collection
* 集合
* @param field
* distinct字段名称
*/
public Object[] distinct(String db,String collection, String field) {
return getCollection(db,collection).distinct(field).toArray();
}
/**
* distinct操作
*
* @param collection
* 集合
* @param field
* distinct字段名称
* @param q
* 查询条件
*/
public Object[] distinct(String db,String collection, String field, DBObject q) {
return getCollection(db,collection).distinct(field, q).toArray();
}
/**
* group分组查询操作，返回结果少于10,000keys时可以使用
*
* @param collection
* 集合
* @param key
* 分组查询字段
* @param q
* 查询条件
* @param reduce
* reduce Javascript函数，如：function(obj, out){out.count++;out.csum=obj.c;}
* @param finalize
* reduce function返回结果处理Javascript函数，如：function(out){out.avg=out.csum/out.count;}
*/
public BasicDBList group(String db,String collection, DBObject key, DBObject q, DBObject initial, String reduce, String finalize) {
return ((BasicDBList)getCollection(db,collection).group(key, q, initial, reduce, finalize));
}
/**
* group分组查询操作，返回结果大于10,000keys时可以使用
*
* @param collection
* 集合
* @param map
* 映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
* @param reduce
* reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count; } return {count:total}; }
* @param q
* 分组查询条件
* @param orderBy
* 分组查询排序
*/
public Iterable<DBObject> mapReduce(String db,String collection, String map, String reduce, DBObject q, DBObject orderBy) {
//DBCollection coll =getCollection(db,collection);
//MapReduceCommand cmd = new MapReduceCommand(coll, map, reduce, null, MapReduceCommand.OutputType.INLINE, q);
//return coll.mapReduce(cmd).results();
MapReduceOutput out = getCollection(db,collection).mapReduce(map, reduce, null, q);
return out.getOutputCollection().find().sort(orderBy).toArray();
}
/**
* group分组分页查询操作，返回结果大于10,000keys时可以使用
*
* @param collection
* 集合
* @param map
* 映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
* @param reduce
* reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count; } return {count:total}; }
* @param q
* 分组查询条件
* @param orderBy
* 分组查询排序
* @param pageNo
* 第n页
* @param perPageCount
* 每页记录数
*/
public List<DBObject> mapReduce(String db,String collection, String map, String reduce,
DBObject q, DBObject orderBy, int pageNo, int perPageCount) {
MapReduceOutput out = getCollection(db,collection).mapReduce(map, reduce, null, q);
return out.getOutputCollection().find().sort(orderBy).skip((pageNo - 1) * perPageCount)
.limit(perPageCount).toArray();
}
/**
* group分组查询操作，返回结果大于10,000keys时可以使用
*
* @param collection
* 集合
* @param map
* 映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
* @param reduce
* reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count; } return {count:total}; }
* @param outputCollectionName
* 输出结果表名称
* @param q
* 分组查询条件
* @param orderBy
* 分组查询排序
*/
public List<DBObject> mapReduce(String db,String collection, String map, String reduce,
String outputCollectionName, DBObject q, DBObject orderBy) {
if (!this.mg.getDB(db).collectionExists(outputCollectionName)) {
getCollection(db,collection).mapReduce(map, reduce, outputCollectionName, q);
}
return getCollection(db,outputCollectionName).find(null,new BasicDBObject("_id",false)).sort(orderBy).toArray();
}
//查询给定两个数据之间的数据
public List<DBObject> findBetween(String db,String collection,String key,Object a,Object b){
BasicDBObject query = new BasicDBObject();
query.put("$gt",a);
query.put("$lt",b);
BasicDBObject query1 = new BasicDBObject();
query1.put(key, query);
return getCollection(db,collection).find(query1).toArray();
}
//查询大于给定参数
public List<DBObject> findGT(String db,String collection,String key,Object a){
BasicDBObject query = new BasicDBObject();
query.put("$gt",a);
BasicDBObject query1 = new BasicDBObject();
query1.put(key, query);
return getCollection(db,collection).find(query1).toArray();
}
//查询大于等于给定参数
public List<DBObject> findGTE(String db,String collection,String key,Object a){
BasicDBObject query = new BasicDBObject();
query.put("$gte",a);
BasicDBObject query1 = new BasicDBObject();
query1.put(key, query);
return getCollection(db,collection).find(query1).toArray();
}
//查询小于给定参数
public List<DBObject> findLT(String db,String collection,String key,Object a){
BasicDBObject query = new BasicDBObject();
query.put("$lt",a);
BasicDBObject query1 = new BasicDBObject();
query1.put(key, query);
return getCollection(db,collection).find(query1).toArray();
}
//查询小于等于给定参数
public List<DBObject> findLTE(String db,String collection,String key,Object a){
BasicDBObject query = new BasicDBObject();
query.put("$lte",a);
BasicDBObject query1 = new BasicDBObject();
query1.put(key, query);
return getCollection(db,collection).find(query1).toArray();
}
//模糊匹配
public List<DBObject> findByRegex(String db,String collection,List<Kv> conditions){
BasicDBObject query = new BasicDBObject();
Pattern pattern = null;
//List<Pattern> patList= new ArrayList<Pattern>();
for(Kv kv:conditions){
pattern = Pattern.compile("^.*"+kv.getValue()+".*$", Pattern.CASE_INSENSITIVE);
query.put(kv.getKey(), pattern);
}
return getCollection(db,collection).find(query).toArray();
}
//分页查询
public List<DBObject> getPagedata (String db,String collection,List<Kv> conditions,int page,int size){
DBObject query = new BasicDBObject();
DBCursor dbCursor;
Pattern pattern = null;
//List<Pattern> patList= new ArrayList<Pattern>();
for(Kv kv:conditions){
pattern = Pattern.compile("^.*"+kv.getValue()+".*$", Pattern.CASE_INSENSITIVE);
query.put(kv.getKey(), pattern);
}
dbCursor = getCollection(db,collection).find(query).sort(new BasicDBObject("crawl_time",-1)).skip(size * (page - 1)).limit(size);
return dbCursor.toArray();
}
}
