基于mongodb-java-driver 3.4 进行封装
<!-- https://mvnrepository.com/artifact/org.mongodb/mongo-java-driver -->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.4.2</version>
</dependency>
创建MongoDBUtil 封装创建连接
package com.jit.file.Utils;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.bson.types.ObjectId;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoClientOptions.Builder;
import com.mongodb.MongoClientURI;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.model.Filters;
import com.mongodb.client.result.DeleteResult;
/**
* MongoDB工具类 Mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个Mongo实例对我们来说已经足够了<br>
* 注意Mongo已经实现了连接池，并且是线程安全的。 <br>
* 设计为单例模式， 因 MongoDB的Java驱动是线程安全的，对于一般的应用，只要一个Mongo实例即可，<br>
* Mongo有个内置的连接池（默认为10个） 对于有大量写和读的环境中，为了确保在一个Session中使用同一个DB时，<br>
* DB和DBCollection是绝对线程安全的<br>
*
*/
public class MongoDBUtil {
static Logger log = LogManager.getLogger(MongoDBUtil.class);
//这里是指放在classes下，如果有包的话，前面加包名即可。例：/com/web/db.properties
static String fileName="/conf/mongodb.jdbc.properties";
private static MongoClient mongoClient;
private static String host = null;
private static String port = null;
private static String username = null;
private static String password = null;
private static String dbname = null;
private static String agreement = null;
private static int connectionsPerHost = 100;
private static int connectTimeout = 3000;
private static int maxWaitTime = 5000;
private static int socketTimeout = 0;
private static int threadsAllowedToBlockForConnectionMultiplier = 5000;
static {
log.info("===============MongoDBUtil初始化========================");
Properties p = new Properties();
try {
InputStream in = MongoDBUtil.class.getResourceAsStream(fileName);
p.load(in);
} catch (IOException e) {
log.error("获取mongo数据库连接属性异常 : com.jit.platform.basics.dao.MongoDBUtil");
e.printStackTrace();
}
// 从配置文件中获取属性值
host = p.getProperty("mongo.host");
port = p.getProperty("mongo.port");
username = p.getProperty("mongo.username");
password = p.getProperty("mongo.password");
dbname = p.getProperty("mongo.dbname");
agreement = p.getProperty("mongo.agreement");
connectionsPerHost = Integer.valueOf(p.getProperty("mongo.connectionsPerHost"));
connectTimeout = Integer.valueOf(p.getProperty("mongo.connectTimeout"));
maxWaitTime = Integer.valueOf(p.getProperty("mongo.maxWaitTime"));
socketTimeout = Integer.valueOf(p.getProperty("mongo.socketTimeout"));
threadsAllowedToBlockForConnectionMultiplier = Integer.valueOf(p.getProperty("mongo.threadsAllowedToBlockForConnectionMultiplier"));
// 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：
String url = "mongodb://"+username+":"+password+"@"+host+":"+port+"/"+dbname+"?authMechanism="+agreement+"&readPreference=primary";
MongoClientURI uri = new MongoClientURI(url);
mongoClient = new MongoClient(uri);
// boolean auth = db.authenticate(myUserName, myPassword);
Builder options = new MongoClientOptions.Builder();
// options.autoConnectRetry(true);// 自动重连true
// options.maxAutoConnectRetryTime(10); // the maximum auto connect retry time
options.connectionsPerHost(connectionsPerHost);// 连接池设置为300个连接,默认为100
options.connectTimeout(connectTimeout);// 连接超时，推荐>3000毫秒
options.maxWaitTime(maxWaitTime); //
options.socketTimeout(socketTimeout);// 套接字超时时间，0无限制
options.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlockForConnectionMultiplier);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。
options.build();
}
// ------------------------------------共用方法---------------------------------------------------
/**
* 获取DB实例 - 指定DB
*
* @param dbName
* @return
*/
@SuppressWarnings("deprecation")
public static DB getDB() {
if (dbname != null && !"".equals(dbname)) {
DB db = mongoClient.getDB(dbname);
//MongoDatabase database = mongoClient.getDatabase(dbname);
return db;
}
return null;
}
/**
* 获取collection对象 - 指定Collection
*
* @param collName
* @return
*/
@SuppressWarnings("deprecation")
public static DBCollection getCollection(String collName) {
if (null == collName || "".equals(collName)) {
return null;
}
return mongoClient.getDB(dbname).getCollection(collName);
}
/**
* 查找对象 - 根据主键_id
*
* @param collection
* @param id
* @return
*/
public Document findById(MongoCollection<Document> coll, 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;
}
/** 统计数 */
public int getCount(MongoCollection<Document> coll) {
int count = (int) coll.count();
return count;
}
/** 条件查询 */
public MongoCursor<Document> find(MongoCollection<Document> coll, Bson filter) {
return coll.find(filter).iterator();
}
/** 分页查询 */
public MongoCursor<Document> findByPage(MongoCollection<Document> coll, Bson filter, int pageNo, int pageSize) {
Bson orderBy = new BasicDBObject("_id", 1);
return coll.find(filter).sort(orderBy).skip((pageNo - 1) * pageSize).limit(pageSize).iterator();
}
/**
* 通过ID删除
*
* @param coll
* @param id
* @return
*/
public int deleteById(MongoCollection<Document> coll, 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;
}
/**
*
* @param coll
* @param id
* @param newdoc
* @return
*/
public Document updateById(MongoCollection<Document> coll, 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;
}
/**
* 关闭Mongodb
*/
public void close() {
if (mongoClient != null) {
mongoClient.close();
mongoClient = null;
}
}
/**
* 测试入口
*
* @param args
*/
public static void main(String[] args) {
try {
DBObject query = new BasicDBObject();
query.put("refId", "29ae5b393ca70a0a11cb33a1509c044b");
query.put("type", "1");
BasicDBObject update = new BasicDBObject();
BasicDBObject update_new = new BasicDBObject();
update.append("$set", update_new.append("fileName", "FFF.png"));
//更新文件内容
update_new.append("file", null);
//------------------------------------------
MongoDBUtil.getCollection("QYDJ_FJ_LC").update(query, update, false, false);
//------------------------------------------
} catch (Exception e) {
e.printStackTrace();
}
/*String collName = "ELComData_etl";
DBCollection coll = MongoDBUtil.getCollection(collName);*/
// 插入多条
// for (int i = 1; i <= 4; i++) {
// Document doc = new Document();
// doc.put("name", "zhoulf");
// doc.put("school", "NEFU" + i);
// Document interests = new Document();
// interests.put("game", "game" + i);
// interests.put("ball", "ball" + i);
// doc.put("interests", interests);
// coll.insertOne(doc);
// }
// // 根据ID查询
// String id = "556925f34711371df0ddfd4b";
// Document doc = MongoDBUtil2.findById(coll, id);
// System.out.println(doc);
// 查询多个
/* DBCursor cursor = coll.find();
while (cursor.hasNext()) {
DBObject obj = cursor.next();
System.out.println(obj.toString());
}
cursor.close();*/
// 查询多个
// MongoCursor<Person> cursor2 = coll.find(Person.class).iterator();
// 删除数据库
// MongoDBUtil2.dropDB("testdb");
// 删除表
// MongoDBUtil2.dropCollection(dbName, collName);
// 修改数据
// String id = "556949504711371c60601b5a";
// Document newdoc = new Document();
// newdoc.put("name", "时候");
// MongoDBUtil.updateById(coll, id, newdoc);
// 统计表
// System.out.println(MongoDBUtil.getCount(coll));
// 查询所有
//Bson filter = Filters.eq("count", 0);
// MongoDBUtil.find(coll, filter);
}
}
基础操作类
package com.jit.file.dao;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.apache.commons.beanutils.BeanUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;
import com.jit.file.Utils.BeanUtil;
import com.jit.file.Utils.MongoDBUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.gridfs.GridFS;
/**
* mongodb 基础操作类
* @author
* @param <T>
*/
@Repository
public class MongodbDao {
private static final Logger logger = LoggerFactory.getLogger(MongodbDao.class);
/**
* 根据对象 增
* @param Object instance
* @throws IllegalAccessException
* @throws IllegalArgumentException
*
*/
public void save(Object instance) throws Exception {
try {
logger.debug("save entity: {}", instance.toString());
MongoDBUtil.getCollection(instance.getClass().getSimpleName())
.insert(BeanUtil.bean2DBObject(instance));
} catch (RuntimeException re) {
logger.error("save failed", re);
throw re;
}
}
/**
* 根据对象 增 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param Object 对象
* @param temp 临时表后缀
*/
public void save(Object instance,String temp) throws Exception{
try {
logger.debug("save entity: {}", instance.toString());
MongoDBUtil.getCollection(instance.getClass().getSimpleName()+"_"+temp)
.insert(BeanUtil.bean2DBObject(instance));
} catch (RuntimeException re) {
logger.error("save failed", re);
throw re;
}
}
/**
* 根据对象 增 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param Object 对象
* @param temp 临时表后缀
*/
public void saveetl(Object instance) throws Exception{
try {
logger.debug("save entity: {}", instance.toString());
MongoDBUtil.getCollection(instance.getClass().getSimpleName().replace("_etl", ""))
.insert(BeanUtil.bean2DBObject(instance));
} catch (RuntimeException re) {
logger.error("save failed", re);
throw re;
}
}
/**
* 根据对象 增 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param Object 对象
* @param temp 临时表后缀
*/
public void saveetl_temp(Object instance) throws Exception{
try {
logger.debug("save entity: {}", instance.toString());
MongoDBUtil.getCollection(instance.getClass().getSimpleName().replace("_etl", "")+"_temp")
.insert(BeanUtil.bean2DBObject(instance));
} catch (RuntimeException re) {
logger.error("save failed", re);
throw re;
}
}
public GridFS connectDB(){
DB db = MongoDBUtil.getDB();
GridFS gridFS= new GridFS(db,"fs");
return gridFS;
}
public GridFS connectDB2(String db_name){
DB db = MongoDBUtil.getDB();
GridFS gridFS= new GridFS(db,db_name);
return gridFS;
}
// ＝＝＝＝＝＝＝ 删 ＝＝＝＝＝＝＝＝＝＝＝＝
/**
* 根据id 删除对象
* @param <T>
*
* @param id
*/
public <T> void deleteById(String id,T instance) throws Exception{
try {
logger.debug("delet entity: {}", instance.getClass().getSimpleName()+ " id : " + id);
DBObject query = new BasicDBObject();
query.put("_id", id);
MongoDBUtil.getCollection(instance.getClass().getSimpleName()).remove(query);
} catch (RuntimeException re) {
logger.error("delet failed", re);
throw re;
}
}
/**
* 根据id 删除对象 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param <T>
*
* @param id
*/
public <T> void deleteById(String id,T instance,String temp) throws Exception{
try {
logger.debug("delet entity: {}", instance.getClass().getSimpleName()+ " id : " + id);
DBObject query = new BasicDBObject();
query.put("_id", id);
MongoDBUtil.getCollection(instance.getClass().getSimpleName()+"_"+temp).remove(query);
} catch (RuntimeException re) {
logger.error("delet failed", re);
throw re;
}
}
/**
* 根据条件删除
*/
public <T> void delete(DBObject query,T instance) throws Exception{
try {
logger.debug("delet entity: {}", query);
MongoDBUtil.getCollection(instance.getClass().getSimpleName()).remove(query);
} catch (RuntimeException re) {
logger.error("delet failed", re);
throw re;
}
}
// ＝＝＝＝＝＝＝ 修改＝＝＝＝＝＝＝＝＝＝＝＝
/**
* 更新满足条件的所有记录
* @param <T>
* @param query
* @param update
*/
public <T> void updateMulti(DBObject query, DBObject update,Class<T> clazz) throws Exception{
try {
logger.debug("[Mongo Dao ]updateMulti:("+query+"),("+update+")");
MongoDBUtil.getCollection(clazz.getSimpleName()).updateMulti(query, update);
} catch (RuntimeException re) {
logger.error("updateMulti failed", re);
throw re;
}
}
/**
* 更新满足条件的所有记录 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param <T>
* @param query
* @param update
*/
public <T> void updateMulti(DBObject query, DBObject update,Class<T> clazz,String temp) throws Exception{
try {
logger.debug("[Mongo Dao ] updateMulti:("+query+"),("+update+")");
MongoDBUtil.getCollection(clazz.getSimpleName()+"_"+temp).updateMulti(query, update);
} catch (RuntimeException re) {
logger.error("updateMulti failed", re);
throw re;
}
}
/**
* 更新满足条件的所有记录（新）
* @param <T>
* @param query
* @param update
*/
public <T> void update(DBObject query, BasicDBObject update,Class<T> clazz,boolean multi) throws Exception{
try {
logger.debug("[Mongo Dao ]updateMulti:("+query+"),("+update+")");
MongoDBUtil.getCollection(clazz.getSimpleName()).update(query, update,false,multi);
} catch (RuntimeException re) {
logger.error("updateMulti failed", re);
throw re;
}
}
// ＝＝＝＝＝＝＝ 查 ＝＝＝＝＝＝＝＝＝＝＝＝
/**
* 根据查询query 查找list
* @param <T>
* @param query
* @return
*/
@SuppressWarnings("unchecked")
public <T> List<T> find(DBObject query,T bean) throws Exception {
try {
logger.debug("[Mongo Dao ] find:("+query+") ");
DBCursor find = MongoDBUtil.getCollection(bean.getClass().getSimpleName()).find(query);
Class<T> c = (Class<T>) bean.getClass();
List<T> list = new ArrayList<T>();
while (find.hasNext()) {
T o = c.newInstance();
DBObject dbObject = (DBObject) find.next();
T dbObjectToBean = dbObjectToBean(dbObject, o);
list.add(dbObjectToBean);
}
return list;
} catch (RuntimeException re) {
logger.error("find failed", re);
throw re;
}
}
/**
* 获取文件列表时不获取文件内容的方法，可以提高查询效率，需要新建没有文件的实体类，并传入表（集合）名
*/
@SuppressWarnings("unchecked")
public <T> List<T> findNoFile(DBObject query,T noFileBean,String beanName) throws Exception {
try {
logger.debug("[Mongo Dao ] find:("+query+") ");
DBCursor find = MongoDBUtil.getCollection(beanName).find(query);
Class<T> c = (Class<T>) noFileBean.getClass();
List<T> list = new ArrayList<T>();
while (find.hasNext()) {
T o = c.newInstance();
DBObject dbObject = (DBObject) find.next();
T dbObjectToBean = dbObjectToBean(dbObject, o);
list.add(dbObjectToBean);
}
return list;
} catch (RuntimeException re) {
logger.error("find failed", re);
throw re;
}
}
/**
* 根据查询query 查找一个对象
* @param <T>
* @param query
* @return
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
public <T> T findOne(DBObject query,T bean) throws Exception {
try {
logger.debug("[Mongo Dao ] findOne:("+query+") ");
DBObject dbObject = MongoDBUtil.getCollection(bean.getClass().getSimpleName()).findOne(query);
if(dbObject != null){
T dbObjectToBean = dbObjectToBean(dbObject, bean);
return dbObjectToBean;
}else{
return null;
}
} catch (RuntimeException re) {
logger.error("findOne failed", re);
throw re;
}
}
/**
* 根据查询query 查找一个对象 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param <T>
* @param query
* @return
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
public <T> T findOne(DBObject query,T bean,String temp) throws Exception {
try {
logger.debug("[Mongo Dao ] findOne:("+query+") ");
DBObject dbObject = MongoDBUtil.getCollection(bean.getClass().getSimpleName()+"_"+temp).findOne(query);
T dbObjectToBean = dbObjectToBean(dbObject, bean);
return dbObjectToBean;
} catch (RuntimeException re) {
logger.error("findOne failed", re);
throw re;
}
}
/**
* 根据查询query 查找一个对象 临时表（同一表对象存储 如：表A 存为 表A_temp）
* @param <T>
* @param query
* @return
* @throws NoSuchMethodException
* @throws InvocationTargetException
* @throws IllegalAccessException
*/
public <T> T findOneEtl(DBObject query,T bean) throws Exception {
try {
logger.debug("[Mongo Dao ] findOne:("+query+") ");
DBObject dbObject = MongoDBUtil.getCollection(bean.getClass().getSimpleName().replace("_etl", "")+"_temp").findOne(query);
T dbObjectToBean = dbObjectToBean(dbObject, bean);
return dbObjectToBean;
} catch (RuntimeException re) {
logger.error("findOne failed", re);
throw re;
}
}
/**
* 查询分页 tips：［不要skip 太多的页数，如果跳过太多会严重影响效率。最大不要skip 20000页］
* @param page
* @param query
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
public <T> Map findPage(DBObject query,DBObject orderBy,Object instance,int page,int rows) {
try {
logger.debug("[Mongo Dao ] findPage :("+query+"),("+orderBy+"),("+page+"),("+rows+") ");
//db.test.sort({"amount":1}).skip(100000).limit(10) //183ms
//db.test.find({amount:{$gt:2399927}}).sort({"amount":1}).limit(10) //53ms
//总页数
Long totalNum = getPageCount(query,instance);
int totalPage = (int) Math.ceil(totalNum / rows);
if((totalNum % rows)>0||totalNum < rows){
totalPage++;
}
DBCursor cursor = MongoDBUtil.getCollection(instance.getClass().getSimpleName())
.find(query).skip((page - 1) * rows)
.limit(rows).sort(orderBy);
//分页查询
List<DBObject> list = new ArrayList<DBObject>();
while (cursor.hasNext()) {
list.add(cursor.next());
}
//返回的结果
Map returnMap = new HashMap();
returnMap.put("result", list);
returnMap.put("totalNum",totalNum );
returnMap.put("totalPage", totalPage);
return returnMap;
} catch (RuntimeException re) {
logger.error("findPage failed", re);
throw re;
}
}
@SuppressWarnings({ "unused", "unchecked" })
public <T> List<T> findPage1(DBObject query,DBObject orderBy,Object instance,int page,int rows) throws InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchMethodException {
//db.test.sort({"amount":1}).skip(100000).limit(10) //183ms
//db.test.find({amount:{$gt:2399927}}).sort({"amount":1}).limit(10) //53ms
//总页数
Long totalNum = getPageCount(query,instance);
int totalPage = (int) Math.ceil(totalNum / rows);
if((totalNum % rows)>0||totalNum < rows){
totalPage++;
}
logger.info("[Mongo Dao ]queryPage:" + query);
DBCursor cursor =MongoDBUtil.getCollection(instance.getClass().getSimpleName())
.find(query).skip((page - 1) * rows)
.limit(rows).sort(orderBy);
Class<T> c = (Class<T>) instance.getClass();
List<T> list = new ArrayList<T>();
while (cursor.hasNext()) {
T o = c.newInstance();
DBObject dbObject = (DBObject) cursor.next();
T dbObjectToBean = dbObjectToBean(dbObject, o);
list.add(dbObjectToBean);
}
return list;
}
/**
* 根据条件查询库中符合记录的总数,为分页查询服务
*
* @param <T>
* @param query 查询条件
* @return 满足条件的记录总数
*/
public <T> Long getPageCount(DBObject query,Object instance){
logger.info("[Mongo Dao ]queryPageCount:" + query);
return MongoDBUtil.getCollection(instance.getClass().getSimpleName()).count(query);
}
/**
* 将DBObject转换成Bean对象
*
*/
public static <T> T dbObjectToBean(DBObject dbObject, T bean)
throws IllegalAccessException, InvocationTargetException,
NoSuchMethodException {
if (bean == null) {
return null;
}
Field[] fields = bean.getClass().getDeclaredFields();
for (Field field : fields) {
String varName = field.getName();
Object object = dbObject.get(varName);
if (object != null) {
BeanUtils.setProperty(bean, varName, object);
}
}
return bean;
}
// 取出Mongo中的属性值，为bean赋值
public static <T> void setProperty(T bean, String varName, T object) {
varName = varName.substring(0, 1).toUpperCase() + varName.substring(1);
try {
String type = object.getClass().getName();
// 类型为String
if (type.equals("java.lang.String")) {
Method m = bean.getClass().getMethod("get" + varName);
String value = (String) m.invoke(bean);
if (value == null) {
m = bean.getClass()
.getMethod("set" + varName, String.class);
m.invoke(bean, object);
}
}
// 类型为Integer
if (type.equals("java.lang.Integer")) {
Method m = bean.getClass().getMethod("get" + varName);
String value = (String) m.invoke(bean);
if (value == null) {
m = bean.getClass().getMethod("set" + varName,
Integer.class);
m.invoke(bean, object);
}
}
// 类型为Boolean
if (type.equals("java.lang.Boolean")) {
Method m = bean.getClass().getMethod("get" + varName);
String value = (String) m.invoke(bean);
if (value == null) {
m = bean.getClass().getMethod("set" + varName,
Boolean.class);
m.invoke(bean, object);
}
}
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (SecurityException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
/**
* 查询Etl
* @param query
* @return
*/
@SuppressWarnings("unchecked")
public <T> List<T> findEtl(DBObject query,DBObject orderBy,T instance,int skip) throws Exception{
logger.info("[Mongo Dao ]queryPage:" + query);
DBCursor cursor =MongoDBUtil.getCollection(instance.getClass().getSimpleName())
.find(query).skip(skip)
.limit(1000).sort(orderBy);
Class<T> c = (Class<T>) instance.getClass();
List<T> list = new ArrayList<T>();
while (cursor.hasNext()) {
T o = c.newInstance();
DBObject dbObject = (DBObject) cursor.next();
T dbObjectToBean = dbObjectToBean(dbObject, o);
list.add(dbObjectToBean);
}
return list;
}
}
实体bean对象转成DBObject
package com.jit.file.Utils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.util.Date;
import java.util.Map;
import org.apache.commons.beanutils.BeanUtils;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
public class BeanUtil {
/**
* 把实体bean对象转换成DBObject
* @param bean
* @return
* @throws IllegalArgumentException
* @throws IllegalAccessException
*/
@SuppressWarnings("rawtypes")
public static <T> DBObject bean2DBObject(T bean) throws IllegalArgumentException,IllegalAccessException {
if (bean == null) {
return null;
}
DBObject dbObject = new BasicDBObject();
// 获取对象对应类中的所有属性域
Field[] fields = bean.getClass().getDeclaredFields();
for (Field field : fields) {
// 获取属性名
String varName = field.getName();
// 修改访问控制权限
boolean accessFlag = field.isAccessible();
if (!accessFlag) {
field.setAccessible(true);
}
Object param = field.get(bean);
if(param == null) {
continue;
}else if ("serialVersionUID".equals(varName)) {
continue;
}else if (param instanceof Integer) {//判断变量的类型
int value = ((Integer) param).intValue();
dbObject.put(varName, value);
} else if (param instanceof String) {
String value = (String) param;
dbObject.put(varName, value);
} else if (param instanceof Double) {
double value = ((Double) param).doubleValue();
dbObject.put(varName, value);
} else if (param instanceof Float) {
float value = ((Float) param).floatValue();
dbObject.put(varName, value);
} else if (param instanceof Long) {
long value = ((Long) param).longValue();
dbObject.put(varName, value);
} else if (param instanceof Boolean) {
boolean value = ((Boolean) param).booleanValue();
dbObject.put(varName, value);
} else if (param instanceof Date) {
Date value = (Date) param;
dbObject.put(varName, value);
}else if (param instanceof Map) {
Map value = (Map) param;
dbObject.put(varName, value);
}else if (param instanceof byte[]) {
byte[] value = (byte[]) param;
dbObject.put(varName, value);
}
// 恢复访问控制权限
field.setAccessible(accessFlag);
}
return dbObject;
}
/**
* 把DBObject转换成bean对象
* @param dbObject
* @param bean
* @return
* @throws IllegalAccessException
* @throws InvocationTargetException
* @throws NoSuchMethodException
*/
public static <T> T dbObject2Bean(DBObject dbObject, T bean) throws IllegalAccessException,InvocationTargetException, NoSuchMethodException {
if (bean == null) {
return null;
}
Field[] fields = bean.getClass().getDeclaredFields();
for (Field field : fields) {
String varName = field.getName();
Object object = dbObject.get(varName);
if (object != null) {
BeanUtils.setProperty(bean, varName, object);
}
}
return bean;
}
}
186
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
