`

java操作MongoDB工具类分享

MongoDBjava 
阅读更多

最近做了个用MongoDB存储的项目，由于MongoDB对开发人员不开放，由DBA统一管理。因此，自己抽时间写了个MongoDB的查询机。便于查询项目中的数据，方便维护和分析问题。总结了一些java操作MongoDB的方法。本文没有使用spring-data来操作MongoDB。而是直接使用MongoDB for java的原始API。现在介绍一下工具类。

1.准备工作

MongoDB的安装，不多做介绍。

MongoDB的java驱动

 

      <dependency>
            <groupId>org.mongodb</groupId>
            <artifactId>mongo-java-driver</artifactId>
            <version>2.11.3</version>
        </dependency>

 测试的集合：

2.封装实体介绍

 

  • MongoDBCursor——MongoDB条件查询封装实体（支持limit，skip，sort）
  • MongoDBEntity——MongoDB集合封装实体
  • MongoDBUpdate——MongoDB更新封装实体

MongoDBCursor

 

import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * MongoDB条件查询封装实体（支持limit，skip，sort）
 *
 * @author: alex
 * @time: 14-1-21 下午5:00
 * @version: 1.0
 */
public class MongoDBCursor extends MongoDBEntity {

    /**
     * skip属性
     */
    private int skip;

    /**
     * limit属性
     */
    private int limit = 100;

    /**
     * 排序属性
     */
    private Map<String, Object> sort = new LinkedHashMap<String, Object>();

    /**
     * 自定义查询字段属性
     */
    private Map<String, Object> customFieldMap = new HashMap<String, Object>();

    public int getSkip() {
        return skip;
    }

    public void setSkip(int skip) {
        this.skip = skip;
    }

    public int getLimit() {
        return limit;
    }

    public void setLimit(int limit) {
        this.limit = limit;
    }

    public Map<String, Object> getSort() {
        return sort;
    }

    public void setSort(Map<String, Object> sort) {
        this.sort = sort;
    }

    public DBObject getSortObject() {
        if (this.sort == null) {
            return null;
        }
        DBObject dbo = new BasicDBObject();
        for (String k : sort.keySet()) {
            dbo.put(k, Integer.valueOf(sort.get(k).toString()));
        }
        return dbo;
    }

    public Map<String, Object> getCustomFieldMap() {
        return customFieldMap;
    }

    public void setCustomFieldMap(Map<String, Object> customFieldMap) {
        this.customFieldMap = customFieldMap;
    }
}

 MongoDBEntity

 

 

import com.mongodb.DB;

import java.util.Map;

/**
 * MongoDB集合封装实体
 *
 * @author: alex
 * @time: 14-1-20 下午2:57
 * @version: 1.0
 */
public class MongoDBEntity {

    /**
     * mongo数据库
     */
    private DB db;

    /**
     * 集合名字
     */
    private String collectionName;

    /**
     * 字段封装Map
     */
    private Map<String,Object> fieldMap;

    public DB getDb() {
        return db;
    }

    public void setDb(DB db) {
        this.db = db;
    }

    public String getCollectionName() {
        return collectionName;
    }

    public void setCollectionName(String collectionName) {
        this.collectionName = collectionName;
    }

    public Map<String, Object> getFieldMap() {
        return fieldMap;
    }

    public void setFieldMap(Map<String, Object> fieldMap) {
        this.fieldMap = fieldMap;
    }
}

 MongoDBUpdate 

 

 

import java.util.Map;

/**
 * MongoDB更新封装实体
 *
 * @author: alex
 * @time: 14-1-21 下午5:00
 * @version: 1.0
 */
public class MongoDBUpdate extends MongoDBEntity {

    /**
     * where查询Map
     */
    private Map<String, Object> whereMap;

    /**
     * value查询Map
     */
    private Map<String, Object> valueMap;

    public Map<String, Object> getWhereMap() {
        return whereMap;
    }

    public void setWhereMap(Map<String, Object> whereMap) {
        this.whereMap = whereMap;
    }

    public Map<String, Object> getValueMap() {
        return valueMap;
    }

    public void setValueMap(Map<String, Object> valueMap) {
        this.valueMap = valueMap;
    }
}

 

3.MongoDB操作类

  • MongoDBCommonUtil——MongoDB集合操作工作类
  • MongoDBUtil——MongoDBCRUD操作封装工具类

MongoDBCommonUtil

 

import com.mongodb.*;
import org.bson.types.BasicBSONList;
import org.bson.types.ObjectId;

import java.util.*;

/**
 * MongoDBCRUD操作封装工具类
 *
 * @author: alex
 * @time: 14-1-21 下午3:16
 * @version: 1.0
 */
public class MongoDBUtil {

    /**
     * 按主键查询单个实体
     *
     * @param id            主键
     * @param mongoDBCursor 查询实体
     * @return DBObject
     */
    public static DBObject findById(MongoDBCursor mongoDBCursor, String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("_id", new ObjectId(id));
        mongoDBCursor.setFieldMap(map);
        return findOne(mongoDBCursor);
    }

    /**
     * 按条件查询单个
     *
     * @param mongoDBCursor 查询实体
     * @return DBObject
     */
    public static DBObject findOne(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        return MongoDBCommonUtil.getCollection(mongoDBCursor).findOne(dbObject);
    }

    /**
     * 查询全部
     *
     * @param mongoDBCursor 查询实体
     */
    public static List<DBObject> findAll(MongoDBCursor mongoDBCursor) {
        mongoDBCursor.setFieldMap(new HashMap<String, Object>());
        return find(mongoDBCursor);
    }


    /**
     * 按条件查询
     * 支持skip，limit,sort
     *
     * @param mongoDBCursor 查询实体
     */
    public static List<DBObject> find(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        BasicDBObjectBuilder customField = null;
        //自定义查询字段
        if(mongoDBCursor.getCustomFieldMap() != null && mongoDBCursor.getCustomFieldMap().size() > 0) {
            customField = new BasicDBObjectBuilder();
            for(Map.Entry<String, Object> field : mongoDBCursor.getCustomFieldMap().entrySet()) {
                customField.add(field.getKey(),field.getValue());
            }
        }
        return find(mongoDBCursor, dbObject, customField);
    }

    /**
     * 查询（私有方法,检查是否含有skip，limit，sort）
     *
     * @param dbObject      查询条件
     * @param mongoDBCursor 查询实体
     */
    private static List<DBObject> find(final MongoDBCursor mongoDBCursor, DBObject dbObject,BasicDBObjectBuilder customField) {
        MongoDBCursorPreparer cursorPreparer = mongoDBCursor == null ? null : new MongoDBCursorPreparer() {
            public DBCursor prepare(DBCursor dbCursor) {
                if (mongoDBCursor == null) {
                    return dbCursor;
                }
                if (mongoDBCursor.getLimit() <= 0 && mongoDBCursor.getSkip() <= 0 && mongoDBCursor.getSortObject() == null) {
                    return dbCursor;
                }
                DBCursor cursorToUse = dbCursor;
                if (mongoDBCursor.getSkip() > 0) {
                    cursorToUse = cursorToUse.skip(mongoDBCursor.getSkip());
                }
                if (mongoDBCursor.getLimit() > 0) {
                    cursorToUse = cursorToUse.limit(mongoDBCursor.getLimit());
                }
                if (mongoDBCursor.getSortObject() != null) {
                    cursorToUse = cursorToUse.sort(mongoDBCursor.getSortObject());
                }
                return cursorToUse;
            }
        };
        return find(mongoDBCursor, dbObject, cursorPreparer,customField);
    }

    /**
     * 查询（私有方法，真正的查询操作）
     *
     * @param query       查询条件
     * @param mongoDBCursor  查询实体
     * @param cursorPreparer 查询转换接口
     */
    private static List<DBObject> find(MongoDBCursor mongoDBCursor, DBObject query, MongoDBCursorPreparer cursorPreparer,BasicDBObjectBuilder customField) {
        DBCursor dbCursor = null;
        if(customField == null) {
            dbCursor = MongoDBCommonUtil.getCollection(mongoDBCursor).find(query);
        } else {
            dbCursor = MongoDBCommonUtil.getCollection(mongoDBCursor).find(query,customField.get());
        }
        if (cursorPreparer != null) {
            dbCursor = cursorPreparer.prepare(dbCursor);
        }
        return dbCursor.toArray();
    }

    /**
     * Count查询
     *
     * @param mongoDBCursor 查询实体
     * @return 总数
     */
    public static long count(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        return MongoDBCommonUtil.getCollection(mongoDBCursor).count(dbObject);

    }

    /**
     * 把参数Map转换DBObject
     *
     * @param map 查询条件
     * @return DBObject
     */
    private static DBObject getMapped(Map<String, Object> map) {
        DBObject dbObject = new BasicDBObject();
        Iterator<Map.Entry<String, Object>> iterable = map.entrySet().iterator();
        while (iterable.hasNext()) {
            Map.Entry<String, Object> entry = iterable.next();
            Object value = entry.getValue();
            String key = entry.getKey();
            if (key.startsWith("$") && value instanceof Map) {
                BasicBSONList basicBSONList = new BasicBSONList();
                Map<String, Object> conditionsMap = ((Map) value);
//                Set<String> keys = conditionsMap.keySet();
                for (String k : conditionsMap.keySet()) {
                    Object conditionsValue = conditionsMap.get(k);
                    if (conditionsValue instanceof Collection) {
                        conditionsValue = convertArray(conditionsValue);
                    }
                    DBObject dbObject2 = new BasicDBObject(k, conditionsValue);
                    basicBSONList.add(dbObject2);
                }
                value = basicBSONList;
            } else if (value instanceof Collection) {
                value = convertArray(value);
            } else if (!key.startsWith("$") && value instanceof Map) {
                value = getMapped(((Map) value));
            }
            dbObject.put(key, value);
        }
        return dbObject;
    }

    /**
     * 转换成Object[]
     *
     * @param value 待转换实体
     * @return Object[]
     */
    private static Object[] convertArray(Object value) {
        Object[] values = ((Collection) value).toArray();
        return values;
    }

    /**
     * 添加操作
     *
     * @param mongoDBEntity 实体
     */
    public static void add(MongoDBEntity mongoDBEntity) {
        DBObject dbObject = new BasicDBObject(mongoDBEntity.getFieldMap());
        MongoDBCommonUtil.getCollection(mongoDBEntity).insert(dbObject);
    }

    /**
     * 批量处理添加操作
     *
     * @param list          批量字段数据
     * @param mongoDBEntity 实体
     */
    public static void add(MongoDBEntity mongoDBEntity, List<Map<String, Object>> list) {
        for (Map<String, Object> map : list) {
            mongoDBEntity.setFieldMap(map);
            add(mongoDBEntity);
        }
    }

    /**
     * 删除操作
     *
     * @param mongoDBEntity 实体
     */
    public static void delete(MongoDBEntity mongoDBEntity) {
        DBObject dbObject = new BasicDBObject(mongoDBEntity.getFieldMap());
        MongoDBCommonUtil.getCollection(mongoDBEntity).remove(dbObject);
    }

    /**
     * 删除操作,根据主键
     *
     * @param id            主键
     * @param mongoDBEntity 实体
     */
    public static void delete(MongoDBEntity mongoDBEntity, String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("_id", new ObjectId(id));
        mongoDBEntity.setFieldMap(map);
        delete(mongoDBEntity);
    }

    /**
     * 删除全部
     *
     * @param mongoDBEntity 实体
     */
    public static void deleteAll(MongoDBEntity mongoDBEntity) {
        MongoDBCommonUtil.getCollection(mongoDBEntity).drop();
    }

    /**
     * 修改操作
     * 会用一个新文档替换现有文档,文档key结构会发生改变
     * 比如原文档{"_id":"123","name":"zhangsan","age":12}当根据_id修改age
     * value为{"age":12}新建的文档name值会没有,结构发生了改变
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void update(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return valueDBObject;
            }
        });
    }

    /**
     * 修改操作,使用$set修改器
     * 用来指定一个键值,如果键不存在,则自动创建,会更新原来文档, 不会生成新的, 结构不会发生改变
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void updateSet(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return new BasicDBObject("$set", valueDBObject);
            }
        });
    }

    /**
     * 修改操作,使用$inc修改器
     * 修改器键的值必须为数字
     * 如果键存在增加或减少键的值, 如果不存在创建键
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void updateInc(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return new BasicDBObject("$inc", valueDBObject);
            }
        });
    }

    /**
     * 修改(私有方法)
     *
     * @param mongoDBUpdate  更新实体
     * @param updateCallback 更新回调
     */
    private static void executeUpdate(MongoDBUpdate mongoDBUpdate, UpdateCallback updateCallback) {
        DBObject whereDBObject = new BasicDBObject(mongoDBUpdate.getWhereMap());
        DBObject valueDBObject = new BasicDBObject(mongoDBUpdate.getValueMap());
        valueDBObject = updateCallback.doCallback(valueDBObject);
        MongoDBCommonUtil.getCollection(mongoDBUpdate).update(whereDBObject, valueDBObject);
    }


    public static void main(String[] args) {
        try {
            //获取操作DB
            DB db = MongoDBCommonUtil.getDB("192.168.227.170", 20011,"lagd","lagd_rw","lagd_pwd");
            MongoDBCursor mongoDBCursor = new MongoDBCursor();
            mongoDBCursor.setDb(db);     //赋值DB
            mongoDBCursor.setCollectionName("lagd_data_dictionary");   //赋值集合名
            //封装查询条件
            Map<String, Object> fieldMap = new HashMap<String, Object>();
            fieldMap.put("type","dataSource");
            mongoDBCursor.setFieldMap(fieldMap);
            //赋值skip
            mongoDBCursor.setSkip(1);
            //赋值limit
            mongoDBCursor.setLimit(1);
            //封装Sort
            Map<String, Object> sortMap = new LinkedHashMap<String, Object>();
            sortMap.put("key",1);
            mongoDBCursor.setSort(sortMap);
            //查询
            List<DBObject> result = MongoDBUtil.find(mongoDBCursor);
            for(DBObject dbObject : result){
                for(String key : dbObject.keySet()){
                    System.out.println("key=" + key + ";  value=" + dbObject.get(key));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 MongoDBUtil

 

 

import com.mongodb.*;
import org.bson.types.BasicBSONList;
import org.bson.types.ObjectId;

import java.util.*;

/**
 * MongoDBCRUD操作封装工具类
 *
 * @author: alex
 * @time: 14-1-21 下午3:16
 * @version: 1.0
 */
public class MongoDBUtil {

    /**
     * 按主键查询单个实体
     *
     * @param id            主键
     * @param mongoDBCursor 查询实体
     * @return DBObject
     */
    public static DBObject findById(MongoDBCursor mongoDBCursor, String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("_id", new ObjectId(id));
        mongoDBCursor.setFieldMap(map);
        return findOne(mongoDBCursor);
    }

    /**
     * 按条件查询单个
     *
     * @param mongoDBCursor 查询实体
     * @return DBObject
     */
    public static DBObject findOne(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        return MongoDBCommonUtil.getCollection(mongoDBCursor).findOne(dbObject);
    }

    /**
     * 查询全部
     *
     * @param mongoDBCursor 查询实体
     */
    public static List<DBObject> findAll(MongoDBCursor mongoDBCursor) {
        mongoDBCursor.setFieldMap(new HashMap<String, Object>());
        return find(mongoDBCursor);
    }


    /**
     * 按条件查询
     * 支持skip，limit,sort
     *
     * @param mongoDBCursor 查询实体
     */
    public static List<DBObject> find(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        BasicDBObjectBuilder customField = null;
        //自定义查询字段
        if(mongoDBCursor.getCustomFieldMap() != null && mongoDBCursor.getCustomFieldMap().size() > 0) {
            customField = new BasicDBObjectBuilder();
            for(Map.Entry<String, Object> field : mongoDBCursor.getCustomFieldMap().entrySet()) {
                customField.add(field.getKey(),field.getValue());
            }
        }
        return find(mongoDBCursor, dbObject, customField);
    }

    /**
     * 查询（私有方法,检查是否含有skip，limit，sort）
     *
     * @param dbObject      查询条件
     * @param mongoDBCursor 查询实体
     */
    private static List<DBObject> find(final MongoDBCursor mongoDBCursor, DBObject dbObject,BasicDBObjectBuilder customField) {
        MongoDBCursorPreparer cursorPreparer = mongoDBCursor == null ? null : new MongoDBCursorPreparer() {
            public DBCursor prepare(DBCursor dbCursor) {
                if (mongoDBCursor == null) {
                    return dbCursor;
                }
                if (mongoDBCursor.getLimit() <= 0 && mongoDBCursor.getSkip() <= 0 && mongoDBCursor.getSortObject() == null) {
                    return dbCursor;
                }
                DBCursor cursorToUse = dbCursor;
                if (mongoDBCursor.getSkip() > 0) {
                    cursorToUse = cursorToUse.skip(mongoDBCursor.getSkip());
                }
                if (mongoDBCursor.getLimit() > 0) {
                    cursorToUse = cursorToUse.limit(mongoDBCursor.getLimit());
                }
                if (mongoDBCursor.getSortObject() != null) {
                    cursorToUse = cursorToUse.sort(mongoDBCursor.getSortObject());
                }
                return cursorToUse;
            }
        };
        return find(mongoDBCursor, dbObject, cursorPreparer,customField);
    }

    /**
     * 查询（私有方法，真正的查询操作）
     *
     * @param query       查询条件
     * @param mongoDBCursor  查询实体
     * @param cursorPreparer 查询转换接口
     */
    private static List<DBObject> find(MongoDBCursor mongoDBCursor, DBObject query, MongoDBCursorPreparer cursorPreparer,BasicDBObjectBuilder customField) {
        DBCursor dbCursor = null;
        if(customField == null) {
            dbCursor = MongoDBCommonUtil.getCollection(mongoDBCursor).find(query);
        } else {
            dbCursor = MongoDBCommonUtil.getCollection(mongoDBCursor).find(query,customField.get());
        }
        if (cursorPreparer != null) {
            dbCursor = cursorPreparer.prepare(dbCursor);
        }
        return dbCursor.toArray();
    }

    /**
     * Count查询
     *
     * @param mongoDBCursor 查询实体
     * @return 总数
     */
    public static long count(MongoDBCursor mongoDBCursor) {
        DBObject dbObject = getMapped(mongoDBCursor.getFieldMap());
        return MongoDBCommonUtil.getCollection(mongoDBCursor).count(dbObject);

    }

    /**
     * 把参数Map转换DBObject
     *
     * @param map 查询条件
     * @return DBObject
     */
    private static DBObject getMapped(Map<String, Object> map) {
        DBObject dbObject = new BasicDBObject();
        Iterator<Map.Entry<String, Object>> iterable = map.entrySet().iterator();
        while (iterable.hasNext()) {
            Map.Entry<String, Object> entry = iterable.next();
            Object value = entry.getValue();
            String key = entry.getKey();
            if (key.startsWith("$") && value instanceof Map) {
                BasicBSONList basicBSONList = new BasicBSONList();
                Map<String, Object> conditionsMap = ((Map) value);
//                Set<String> keys = conditionsMap.keySet();
                for (String k : conditionsMap.keySet()) {
                    Object conditionsValue = conditionsMap.get(k);
                    if (conditionsValue instanceof Collection) {
                        conditionsValue = convertArray(conditionsValue);
                    }
                    DBObject dbObject2 = new BasicDBObject(k, conditionsValue);
                    basicBSONList.add(dbObject2);
                }
                value = basicBSONList;
            } else if (value instanceof Collection) {
                value = convertArray(value);
            } else if (!key.startsWith("$") && value instanceof Map) {
                value = getMapped(((Map) value));
            }
            dbObject.put(key, value);
        }
        return dbObject;
    }

    /**
     * 转换成Object[]
     *
     * @param value 待转换实体
     * @return Object[]
     */
    private static Object[] convertArray(Object value) {
        Object[] values = ((Collection) value).toArray();
        return values;
    }

    /**
     * 添加操作
     *
     * @param mongoDBEntity 实体
     */
    public static void add(MongoDBEntity mongoDBEntity) {
        DBObject dbObject = new BasicDBObject(mongoDBEntity.getFieldMap());
        MongoDBCommonUtil.getCollection(mongoDBEntity).insert(dbObject);
    }

    /**
     * 批量处理添加操作
     *
     * @param list          批量字段数据
     * @param mongoDBEntity 实体
     */
    public static void add(MongoDBEntity mongoDBEntity, List<Map<String, Object>> list) {
        for (Map<String, Object> map : list) {
            mongoDBEntity.setFieldMap(map);
            add(mongoDBEntity);
        }
    }

    /**
     * 删除操作
     *
     * @param mongoDBEntity 实体
     */
    public static void delete(MongoDBEntity mongoDBEntity) {
        DBObject dbObject = new BasicDBObject(mongoDBEntity.getFieldMap());
        MongoDBCommonUtil.getCollection(mongoDBEntity).remove(dbObject);
    }

    /**
     * 删除操作,根据主键
     *
     * @param id            主键
     * @param mongoDBEntity 实体
     */
    public static void delete(MongoDBEntity mongoDBEntity, String id) {
        Map<String, Object> map = new HashMap<String, Object>();
        map.put("_id", new ObjectId(id));
        mongoDBEntity.setFieldMap(map);
        delete(mongoDBEntity);
    }

    /**
     * 删除全部
     *
     * @param mongoDBEntity 实体
     */
    public static void deleteAll(MongoDBEntity mongoDBEntity) {
        MongoDBCommonUtil.getCollection(mongoDBEntity).drop();
    }

    /**
     * 修改操作
     * 会用一个新文档替换现有文档,文档key结构会发生改变
     * 比如原文档{"_id":"123","name":"zhangsan","age":12}当根据_id修改age
     * value为{"age":12}新建的文档name值会没有,结构发生了改变
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void update(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return valueDBObject;
            }
        });
    }

    /**
     * 修改操作,使用$set修改器
     * 用来指定一个键值,如果键不存在,则自动创建,会更新原来文档, 不会生成新的, 结构不会发生改变
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void updateSet(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return new BasicDBObject("$set", valueDBObject);
            }
        });
    }

    /**
     * 修改操作,使用$inc修改器
     * 修改器键的值必须为数字
     * 如果键存在增加或减少键的值, 如果不存在创建键
     *
     * @param mongoDBUpdate 更新实体
     */
    public static void updateInc(MongoDBUpdate mongoDBUpdate) {
        executeUpdate(mongoDBUpdate, new UpdateCallback() {
            public DBObject doCallback(DBObject valueDBObject) {
                return new BasicDBObject("$inc", valueDBObject);
            }
        });
    }

    /**
     * 修改(私有方法)
     *
     * @param mongoDBUpdate  更新实体
     * @param updateCallback 更新回调
     */
    private static void executeUpdate(MongoDBUpdate mongoDBUpdate, UpdateCallback updateCallback) {
        DBObject whereDBObject = new BasicDBObject(mongoDBUpdate.getWhereMap());
        DBObject valueDBObject = new BasicDBObject(mongoDBUpdate.getValueMap());
        valueDBObject = updateCallback.doCallback(valueDBObject);
        MongoDBCommonUtil.getCollection(mongoDBUpdate).update(whereDBObject, valueDBObject);
    }


    public static void main(String[] args) {
        try {
            //获取操作DB
            DB db = MongoDBCommonUtil.getDB("192.168.227.170", 20011,"lagd","lagd_rw","lagd_pwd");
            MongoDBCursor mongoDBCursor = new MongoDBCursor();
            mongoDBCursor.setDb(db);     //赋值DB
            mongoDBCursor.setCollectionName("lagd_data_dictionary");   //赋值集合名
            //封装查询条件
            Map<String, Object> fieldMap = new HashMap<String, Object>();
            fieldMap.put("type","dataSource");
            mongoDBCursor.setFieldMap(fieldMap);
            //赋值skip
            mongoDBCursor.setSkip(1);
            //赋值limit
            mongoDBCursor.setLimit(1);
            //封装Sort
            Map<String, Object> sortMap = new LinkedHashMap<String, Object>();
            sortMap.put("key",1);
            mongoDBCursor.setSort(sortMap);
            //自定义查询字段
            Map<String, Object> customFieldMap =  new LinkedHashMap<String, Object>();
            customFieldMap.put("type","1");
            customFieldMap.put("key","1");
            customFieldMap.put("value","1");
            mongoDBCursor.setCustomFieldMap(customFieldMap);
            //查询
            List<DBObject> result = MongoDBUtil.find(mongoDBCursor);
            for(DBObject dbObject : result){
                for(String key : dbObject.keySet()){
                    System.out.println("键：" + key + ";  值：" + dbObject.get(key));
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 MongoDBCursorPreparer

import com.mongodb.DBCursor;

/**
 * 查询转换接口定义
 *
 * @author: alex
 * @time: 14-1-21 下午4:55
 * @version: 1.0
 */
public interface MongoDBCursorPreparer {

    DBCursor prepare(DBCursor cursor);
}

 UpdateCallback

import com.mongodb.DBObject;

/**
 * MongoDB更新操作接口定义
 *
 * @author: alex
 * @time: 14-1-21 下午5:25
 * @version: 1.0
 */
interface UpdateCallback {

    DBObject doCallback(DBObject valueDBObject);
}

 

  • 大小: 5.3 KB
分享到：
| Schema学习
评论
1 楼 MrwenQ 2014-07-14  
哥们，你这少个MongoDBCommonUtil类吧 怎么两个MongoDBUtil类呢？
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    java毕设项目之ssm基于SSM的高校共享单车管理系统的设计与实现+vue(完整前后端+说明文档+mysql+lw).zip

    项目包含完整前后端源码和数据库文件 环境说明： 开发语言：Java 框架：ssm，mybatis JDK版本：JDK1.8 数据库：mysql 5.7 数据库工具：Navicat11 开发软件：eclipse/idea Maven包：Maven3.3 服务器：tomcat7

    YOLO算法-贴纸检测数据集-212张图像带标签-部分覆盖-未涵盖-完全覆盖.zip

    YOLO系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中，文件名末尾是部分类别名称; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值； 【注】可以下拉页面，在资源详情处查看标签具体内容；

    zigbee CC2530无线自组网协议栈系统代码实现协调器按键控制终端LED灯和继电器动作.zip

    1、嵌入式物联网单片机项目开发例程，简单、方便、好用，节省开发时间。 2、代码使用IAR软件开发，当前在CC2530上运行，如果是其他型号芯片，请自行移植。 3、软件下载时，请注意接上硬件，并确认烧录器连接正常。 4、有偿指导v：wulianjishu666; 5、如果接入其他传感器，请查看账号发布的其他资料。 6、单片机与模块的接线，在代码当中均有定义，请自行对照。 7、若硬件有差异，请根据自身情况调整代码，程序仅供参考学习。 8、代码有注释说明，请耐心阅读。 9、例程具有一定专业性，非专业人士请谨慎操作。

    手语图像分类数据集【已标注，约2,500张数据】

    手语图像分类数据集【已标注，约2,500张数据】 分类个数【36】：0、1、a、b等【具体查看json文件】 划分了训练集、测试集。存放各自的同一类数据图片。如果想可视化数据集，可以运行资源中的show脚本。 CNN分类网络改进：https://blog.csdn.net/qq_44886601/category_12858320.html 【更多图像分类、图像分割（医学）、目标检测（yolo）的项目以及相应网络的改进，可以参考本人主页：https://blog.csdn.net/qq_44886601/category_12803200.html】

    CNCAP 2024打分表

    CNCAP 2024打分表

    基于小程序的智慧校园管理系统源代码（java+小程序+mysql+LW）.zip

    系统可以提供信息显示和相应服务，其管理智慧校园管理系统信息，查看智慧校园管理系统信息，管理智慧校园管理系统。 项目包含完整前后端源码和数据库文件 环境说明： 开发语言：Java JDK版本：JDK1.8 数据库：mysql 5.7 数据库工具：Navicat11 开发软件：eclipse/idea Maven包：Maven3.3 部署容器：tomcat7 小程序开发工具：hbuildx/微信开发者工具

    【图像去噪】基于matlab PolSAR GWLS滤波器图像去噪【含Matlab源码 9937期】.zip

    Matlab领域上传的视频均有对应的完整代码，皆可运行，亲测可用，适合小白； 1、代码压缩包内容 主函数：main.m； 调用函数：其他m文件；无需运行 运行结果效果图； 2、代码运行版本 Matlab 2019b；若运行有误，根据提示修改；若不会，私信博主； 3、运行操作步骤 步骤一：将所有文件放到Matlab的当前文件夹中； 步骤二：双击打开main.m文件； 步骤三：点击运行，等程序运行完得到结果； 4、仿真咨询 如需其他服务，可私信博主； 4.1 博客或资源的完整代码提供 4.2 期刊或参考文献复现 4.3 Matlab程序定制 4.4 科研合作

    影音互动科普网站-JAVA-基于SpringBoot的哈利波特书影音互动科普网站设计与实现（毕业论文）

    影音互动科普网站功能描述 影音互动科普网站旨在通过多媒体形式（视频、音频、互动内容等）传播科学知识，提高公众的科学素养。该网站结合娱乐与教育，提供易于理解的科普内容，吸引不同年龄层次的用户参与和学习。以下是该网站的主要功能描述： 1. 用户注册与登录 用户注册：用户可以通过电子邮箱、手机号或社交账号（如微信、微博等）注册，提供基本信息并设置密码。 用户登录：支持通过注册的账号登录，保障个人信息的安全性，并提供自动登录功能。 2. 科普视频与音频库 视频内容：网站提供各类科普视频，包括短视频、纪录片、讲座、实验演示等，覆盖物理、化学、生物、地理、天文等多个领域。 音频内容：提供科普音频节目，如科普广播、播客、专题讲座等，便于用户在日常生活中进行学习。 视频分类：按科目、难度、年龄层、时长等维度对视频和音频进行分类，帮助用户更精准地找到感兴趣的内容。 字幕与多语言支持：提供字幕、翻译和多语种版本，帮助不同语言的用户学习。 3. 互动问答与讨论区 专家问答：用户可以向科普专家提问，专家提供详尽的解答，解决用户的科学疑惑。 社区讨论：用户可以在视频下方或专题页面中发表评论、提问或与其他用户

    倪海厦讲义及笔记，易学数据测算

    倪海厦讲义及笔记，易学数据测算

    【组合数学答案】组合数学-苏大李凡长版-课后习题答案

    内容概要：本文档是《组合数学答案-网络流传版.pdf》的内容，主要包含了排列组合的基础知识以及一些经典的组合数学题目。这些题目涵盖了从排列数计算、二项式定理的应用到容斥原理的实际应用等方面。通过对这些题目的解析，帮助读者加深对组合数学概念和技巧的理解。 适用人群：适合初学者和有一定基础的学习者。 使用场景及目标：可以在学习组合数学课程时作为练习题参考，也可以在复习考试或准备竞赛时使用，目的是提高解决组合数学问题的能力。 其他说明：文档中的题目覆盖了组合数学的基本知识点，适合逐步深入学习。每个题目都有详细的解答步骤，有助于读者掌握解题思路和方法。

    管理系统开发指南：功能要求、技术栈及安全控制

    内容概要：本文是一篇完整的管理系统开发指南，详细介绍了功能要求、技术栈选择、数据库设计、用户界面搭建以及安全控制等方面的内容。功能要求包括用户管理、权限控制、数据管理、系统日志、通知与消息、统计分析和扩展模块。使用的技术栈涵盖了后端（Java、Python、C#等）和前端（React、Vue.js、Angular等）技术，以及数据库设计和安全控制措施。 适合人群：具备一定开发经验的软件工程师和技术管理人员。 使用场景及目标：适用于企业级管理系统开发项目，旨在构建一个高效、安全且易于扩展的系统。开发者可以参考本文档进行系统的设计和实现，确保系统满足业务需求。 其他说明：本文档提供了详细的步骤和最佳实践，帮助开发者更好地理解和应用管理系统开发的各种技术。通过结合实际案例和实践经验，本文档能够为开发者提供有价值的指导。

    听器听力损伤程度分级表.docx

    听器听力损伤程度分级表.docx

    MATLAB代码：基于条件风险价值的合作型Stackerlberg博弈微网动态定价与优化调度 关键词：微网优化调度 条件风险价值 合作博弈 纳什谈判 参考文档：A cooperative Stack

    MATLAB代码：基于条件风险价值的合作型Stackerlberg博弈微网动态定价与优化调度 关键词：微网优化调度 条件风险价值 合作博弈 纳什谈判 参考文档：《A cooperative Stackelberg game based energy management considering price discrimination and risk assessment》完美复现 仿真平台：MATLAB yalmip+cplex+mosek 主要内容：代码主要做的是一个基于合作型Stackerlberg博弈的考虑差别定价和风险管理的微网动态定价与调度策略，提出了一个双层能源管理框架，实现多个微网间的P2P能源交易，上层为零商的动态定价模型，目标是社会福利最大化；下层是多个产消者的合作博弈模型，优化各产消者的能量管理策略。 同时，采用纳什谈判法对多个产消者的合作剩余进行公平分配，还考虑了运行风险，采用条件风险价值（CVaR）随机规划方法来描述零商的预期损失。 求解方面，双层模型被基于KKT条件转为单层模型，模型可以高效求解。 这段代码是一个基于合作型Stackelberg博弈的微网

    YOLO算法-监控数据集-873张图像带标签-警方-警车-救护车-消防车-跌倒的人-消防员.zip

    YOLO系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中，文件名末尾是部分类别名称; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值； 【注】可以下拉页面，在资源详情处查看标签具体内容；

    (175526236)【动漫网页设计】源码免费分享，让你的网站更有趣！

    20块钱买的【动漫网页设计】源码，免费分享出来啦,如果要积分那是系统自动涨的啦。 内容概要：本资源是一份动漫网页设计的源码，价格仅为20元，作者将其免费分享给大家。该源码包含了动漫元素的设计，包括背景、图标、按钮等，同时也提供了一些常见的网页布局和交互效果。通过该资源，可以学习到动漫网页设计的基本原理和技巧。 适用人群：本资源适用于对动漫网页设计感兴趣的人群，包括网页设计师、UI设计师、前端开发工程师等。同时，对于想要学习动漫网页设计的初学者也非常适用。 使用场景及目标：该资源可以用于学习和实践动漫网页设计的技巧和原理。通过学习该源码，可以了解到动漫网页设计的基本要素和设计思路，同时也可以借鉴其中的设计元素和交互效果，应用到自己的网页设计中。 其他说明：本资源是作者自己设计的，经过了多次修改和优化，具有一定的参考价值。同时，作者也将其价格设置的非常低，希望更多的人可以学习到动漫网页设计的技巧和方法。如果您对该资源有任何疑问或建议，欢迎在评论区留言，作者会尽快回复。。内容来源于网络分享，如有侵权请联系我删除。另外如果没有积分的同学需要下载，请私信我。

    C++程序设计-参考答案

    自考 本科 C++程序设计-课本 参考答案

    每周质量安全排查报告.docx

    每周质量安全排查报告.docx

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    YOLO算法-杂草检测项目数据集-3970张图像带标签-杂草.zip

    内存搜索工具(易).rar

    内存搜索工具(易).rar

    2024 AGM Meritech Market Section (External).pdf

    AI大模型研究相关报告

Magicbox
Global site tag (gtag.js) - Google Analytics