java-Mongo的工具

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();
    
    
}


}