`

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操作mongodb的工具类

    java操作mongodb的工具类,增删查改方法

    java 连接 MongoDB 工具类示例

    Java连接MongoDB工具类示例主要展示了如何在Java应用程序中与MongoDB数据库进行交互，MongoDB是一个NoSQL数据库，以其非关系型、分布式、高性能和灵活性而受到开发者的青睐。在Java中，我们通常使用MongoDB Java驱动...

    java 操作mongodb

    【Java 操作 MongoDB 知识点详解】 MongoDB 是一个流行的开源、分布式文档数据库系统，以其灵活性、高性能和高可用性而受到欢迎。在 Java 开发环境中，可以通过 MongoDB 的 Java 驱动程序来实现对 MongoDB 数据库的...

    mongodb java Driver

    MongoDB Java驱动程序是Java开发者用来与MongoDB数据库进行交互的一种关键工具。它提供了一组丰富的API，使得在Java应用程序中执行CRUD（创建、读取、更新、删除）操作变得简单而高效。MongoDB是一个分布式文档存储...

    java中mongodb使用环境详细配置

    Java 中 MongoDB 使用环境详细配置 Java 中 MongoDB 使用环境详细配置是指在 Windows 平台（WinXP）上安装、运行、安装 Windows 服务的笔记，以作备忘。下面是一些重要的知识点： 1. MongoDB 的下载和安装 ...

    JAVA单例MongoDB工具类

    经常对MongoDB进行一些常用操作，为了方便起见将这些常用操作合并到一个工具类中，方便自己开发使用。 　没用Spring Data、Morphia等框架是为了减少学习、维护成本，另外自己直接JDBC方式的话可以更方便的控制操作...

    java连接mongodb的jar包

    这些JAR文件包含了所有必要的类和方法，使得Java开发者能够编写代码来连接到MongoDB服务器并执行查询或更新操作。 要开始使用MongoDB Java驱动，首先需要将对应的JAR文件添加到项目的类路径中。这可以通过在构建...

    Java访问MongoDB实用工具类

    为了方便Java程序员与MongoDB交互，通常会创建一些实用工具类，将常见的数据库操作封装起来，降低代码复杂性。本篇文章将详细介绍如何利用提供的"Java访问MongoDB实用工具类"进行高效开发。 首先，`mongodb....

    通过java向mongodb中插入数据

    【标题】: "Java操作MongoDB插入数据指南" 【描述】: 本指南将详细介绍如何在Linux环境下安装MongoDB，并通过Java进行数据插入操作。我们将涵盖MongoDB的Linux安装、MongoVUE客户端的使用以及Java API与MongoDB的...

    mongodb连接工具类

    本文将详细讲解如何使用Kotlin语言编写MongoDB连接工具类，以便在不依赖配置文件的情况下实现数据库的连接和操作。 首先，我们来看`MongoDBUtil.kt`这个文件，它很可能是用来封装MongoDB连接逻辑的工具类。在Kotlin...

    连接mongodb工具类及配置文件

    在Kotlin中，创建一个MongoDB连接工具类可能包括以下步骤： 1. 引入MongoDB Java驱动程序或KMongo库。 2. 初始化MongoClient实例，指定服务器地址和端口。 3. 选择要操作的数据库。 4. 提供用于操作集合的方法，如...

    java连接mongodb3.4.2所需jar

    总的来说，Java连接MongoDB 3.4.2涉及到的关键知识点包括MongoDB Java驱动的安装和配置、BSON的理解、MongoClient的使用、数据库和集合的创建与操作，以及文档的CRUD操作。通过这些API，你可以灵活地构建与MongoDB...

    Java连接mongoDB需要的jar包(3.9.1)

    总的来说，这组JAR文件是Java开发者连接MongoDB不可或缺的工具，它们提供了与MongoDB服务器通信所需的所有功能，使得Java应用能够充分利用MongoDB的非结构化数据处理能力。虽然现在MongoDB已经发布了更高版本的驱动...

    Java操作MongoDB

    在实际项目中，通常会将这些操作封装在DAO（数据访问对象）类中，如`MongoDBDao.java`所示。一个简单的`MongoDBDao`可能会包含连接数据库、插入、查询、更新和删除等基本方法。 ```java public class MongoDBDao { ...

    基于java的mongodb开发环境搭建

    本节将详细介绍如何使用Java语言对MongoDB进行基本的操作，包括连接数据库、插入数据、查询数据等。 ##### 2.1 创建连接 在Java代码中，可以通过以下方式创建MongoDB连接： ```java import com.mongodb.Mongo; ...

    java操作mongodb增删改查

    这里假设已经定义了一个名为`MongoConnection`的工具类来管理连接。 ```java Mongo mongo = MongoConnection.getMongo(); // 获取MongoDB连接 DB db = mongo.getDB("user"); // "user"是数据库名称 ``` #### 四、...

    Java操作MongoDB数据库方法详解

    在 Java 中，你可以使用 `Mongo` 类的构造函数来连接到 MongoDB 服务器。默认情况下，它连接到本地主机的 27017 端口： ```java Mongo mg = new Mongo(); ``` 如果需要指定 IP 和端口，可以这样： ```java ...

    java+mongodb+分页

    `CRMQueryHelper.java`可能是实现此功能的一个工具类，它可能封装了上述逻辑，提供更友好的API供其他部分代码调用。此类可能包含如`queryByPage(int pageNum, int pageSize)`这样的方法，内部处理分页细节。 源码...

    mongoDB 操作 java源代码

    4. **查询与过滤**：在执行查询时，可以使用 ` Filters` 工具类构造过滤条件，例如 `Filters.eq("fieldName", value)` 用于等值匹配。`Projections` 可以用来控制返回文档的字段。`Sorts` 则用于排序结果。 5. **...

    java代码操作MongoDB

    本主题将深入探讨如何利用Java API与MongoDB进行交互，包括基本操作以及通过工具类进行封装的方法。 首先，我们需要在Java项目中引入MongoDB的驱动jar包，即`mongo.jar`。这可以通过Maven或Gradle等构建工具添加...

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