JAVA 操作mongo

                // 查询所有+
// 或条件
Bson star = Filters.or(Filters.eq("emali", "xdwlbs@163.com"), Filters.eq("zijin", "300 万人民币"));
// 或条件
Bson money = Filters.or(Filters.eq("companyType", "物流"), Filters.eq("rongzi", "已认证"));
// 全匹配
Bson allQuery = Filters.regex("address", "西安市未");
// 左匹配
Bson liftQuery = Filters.regex("address", "^地址：西安市未");
// 右匹配
Bson rightQuery = Filters.regex("legal_person", "帅$");
Bson starQuery = Filters.eq("time", 13);
Bson query = Filters.and(starQuery);

package com.LEO.automation.company.dao;

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


import org.apache.log4j.Logger;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;


import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.WriteConcern;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
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;


import cn.freecubs.freestruts.framework.action.annex.Paging;
import cn.freecubs.freestruts.framework.tool.PropertyParam;


public enum MongoTemplate {


/**
* 定义一个枚举的元素，它代表此类的一个实例
*/
instance;


// 从配置文件中获取属性值
private static String host = PropertyParam.getInstance().getValue("mongo.host");
private static int port = Integer.valueOf(PropertyParam.getInstance().getValue("mongo.port"));
private static String dbName = PropertyParam.getInstance().getValue("mongo.dbName");
private static String collName = PropertyParam.getInstance().getValue("mongo.collName");
private static MongoClient mongoClient;
private static MongoCollection<Document> coll = null;
private Logger logger = Logger.getLogger(MongoTemplate.class);
static {
mongoClient = new MongoClient(host, port);
// 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：
// boolean auth = db.authenticate(myUserName, myPassword);
Builder options = new MongoClientOptions.Builder();
options.connectionsPerHost(300);// 连接池设置为300个连接,默认为100
options.connectTimeout(15000);// 连接超时，推荐>3000毫秒
options.maxWaitTime(5000); //
options.socketTimeout(0);// 套接字超时时间，0无限制
options.threadsAllowedToBlockForConnectionMultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get
// db”错误。
options.writeConcern(WriteConcern.SAFE);//
options.build();


// 为空判断
dbName = dbName == null || "".equals(dbName) ? "localCompany" : dbName;
collName = collName == null || "".equals(collName) ? "localCompany" : collName;
coll = mongoClient.getDatabase(dbName).getCollection(collName);
}


// ------------------------------------共用方法---------------------------------------------------
/**
* 获取DB实例 - 指定DB
* 
* @param dbName
* @return
*/
public MongoDatabase getDB(String dbName) {
if (dbName != null && !"".equals(dbName)) {
MongoDatabase database = mongoClient.getDatabase(dbName);
return database;
}
return null;
}


/**
* 查询DB下的所有表名
*/
public List<String> getAllCollections(String dbName) {
MongoIterable<String> colls = getDB(dbName).listCollectionNames();
List<String> _list = new ArrayList<String>();
for (String s : colls) {
_list.add(s);
}
return _list;
}


/**
* 获取所有数据库名称列表
* 
* @return
*/
public MongoIterable<String> getAllDBNames() {
MongoIterable<String> s = mongoClient.listDatabaseNames();
return s;
}


/**
* 删除一个数据库
*/
public void dropDB(String dbName) {
getDB(dbName).drop();
}


/**
* 查找对象 - 根据主键_id
* 
* @param collection
* @param id
* @return
*/
public Document findById(String id) {
ObjectId _idobj = null;
try {
_idobj = new ObjectId(id);
} catch (Exception e) {
return null;
}
Document myDoc = coll.find(Filters.eq("_id", _idobj)).first();
return myDoc;
}


/**
* 统计条数
* 
* @param query
* @return
*/
public int getCount(Bson query) {
int count = 0;
if (query == null) {
count = (int) coll.count();
} else {
count = (int) coll.count(query);
}
return count;
}


/**
* 按照条件查询第一条数据
* 
* @param filter
* @return
*/
public Document findOneByQuery(Bson filter) {
return coll.find(filter).first();
}


/**
* 条件查询全部数据
* 
* @param filter
* @return
*/
public List<String> findAll(Bson filter) {
return cur2List(coll.find(filter).iterator());
}


/**
* 条件查询
* 
* @param filter
* @return
*/
public List<String> findByFiltersCount(Bson filter, int count) {
if (count < 0) {
count = 0;
}
return cur2List(coll.find(filter).limit(count).iterator());
}


/**
* 分页查询
* 
* @param filter
* @param page
* @param orderBy
* @return
*/
public List<String> findByPage(Bson filter, Paging page, Bson orderBy) {


// 添加页数
if (page.getRowsCount() == 0) {
page.setRowsCount(instance.getCount(filter));
}


MongoCursor<Document> cur = null;
if (filter != null) {
if (orderBy == null) {
cur = coll.find(filter).skip(page.getSkip()).limit(page.getRowsPerPage()).iterator();
} else {
cur = coll.find(filter).sort(orderBy).skip(page.getSkip()).limit(page.getRowsPerPage()).iterator();
}
} else {
if (orderBy == null) {
cur = coll.find().skip(page.getSkip()).limit(page.getRowsPerPage()).iterator();
} else {
cur = coll.find().sort(orderBy).skip(page.getSkip()).limit(page.getRowsPerPage()).iterator();
}
}
return cur2List(cur);
}


/**
* 数据库油标数据转成字符串list
* 
* @param cur
* @return
*/
private List<String> cur2List(MongoCursor<Document> cur) {
List<String> listData = new ArrayList<>();
while (cur.hasNext()) {
listData.add(cur.next().toJson());
}
return listData;
}


/**
* 通过ID删除
* 
* @param coll
* @param id
* @return
*/
public int deleteById(String id) {
int count = 0;
ObjectId _id = null;
try {
_id = new ObjectId(id);
} catch (Exception e) {
return 0;
}
Bson filter = Filters.eq("_id", _id);
DeleteResult deleteResult = coll.deleteOne(filter);
count = (int) deleteResult.getDeletedCount();
return count;
}


/**
* FIXME
* 
* @param coll
* @param id
* @param newdoc
* @return
*/
public Document updateById(String id, Document newdoc) {
ObjectId _idobj = null;
try {
_idobj = new ObjectId(id);
} catch (Exception e) {
return null;
}
Bson filter = Filters.eq("_id", _idobj);
// coll.replaceOne(filter, newdoc); // 完全替代
coll.updateOne(filter, new Document("$set", newdoc));
return newdoc;
}


public void updataInfo(Document newdoc) {
try {
ObjectId _id = new ObjectId(newdoc.get("id") + "");
Bson filter = Filters.eq("_id", _id);
UpdateResult result = coll.updateOne(filter, new Document("$set", newdoc));
this.logger.info(String.format("MongoTemplate：根据id更新结果%s", result.toString()));
} catch (Exception e) {
Object objectId = newdoc.get("_id");
if (objectId != null) {
ObjectId _id = new ObjectId(objectId + "");
Bson filter = Filters.eq("_id", _id);
UpdateResult result = coll.updateOne(filter, new Document("$set", newdoc));
this.logger.info(String.format("MongoTemplate：根据id更新结果%s", result.toString()));
} else {
String companyName = newdoc.get("companyName") + "";
Bson filter = Filters.eq("companyName", companyName);
UpdateResult result = coll.updateOne(filter, new Document("$set", newdoc));
this.logger.info(String.format("MongoTemplate：根据companyName更新结果%s", result.toString()));
}
}
}


/**
* 保存一条数据
* 
* @param newdoc
* @return
*/
public Document save(Document newdoc) {
try {
coll.insertOne(newdoc);
} catch (Exception e) {
String name = newdoc.getString("companyName");
// Bson filter = Filters.eq("_id", name);
Bson filter = Filters.eq("companyName", name);
newdoc.remove("_id");
UpdateResult result = coll.updateOne(filter, new Document("$set", newdoc));
this.logger.info(String.format("MongoTemplate：根据id更新结果%s", result.toString()));
}
return newdoc;
}


public void dropCollection(String dbName, String collName) {
getDB(dbName).getCollection(collName).drop();
}


/**
* 关闭Mongodb
*/
public void close() {
if (mongoClient != null) {
mongoClient.close();
mongoClient = null;
}
}
}