ITKeyword,专注技术干货聚合推荐

注册 | 登录

Java操作MongoDB增删改查工具Demo

zhangliangzi 分享于 2016-06-21

推荐:基于Java对象的数据库增删改查操作

目标:     让完全不懂数据库,不懂SQL的程序员,能轻松地进行数据库记录的增删改查操作。减少重复的DAO操作编码,提高开发效率。 分析: 一、表记录类型:    

——因为实习工作需要,在学MongoDB,参考了公司的一个MongDB服务类,写了一个整合的Demo,涉及到的大部分的增删改查操作,而且还算规范,给大家参考!源代码:(完整项目文件下载链接:点击打开链接)http://download.csdn.net/detail/zhangliangzi/9555872

使用说明:

一、MongoDB数据库参数配置

1、推荐使用mongodb.cfg.properties配置,则在构造MongoDBService对象的时候只需调用无参构造方法即可自动完成配置。


2、如果没有通过mongodb.cfg.properties,会采用程序指定的默认配置

// 定义默认配置,1、IP地址 2、端口号 3、用户名 4、密码 5、配置文件位置名 6、数据库名
	private static final String MONGODB_ADDRESS = "127.0.0.1";
	private static final int MONGODB_PORT = 27017;
	private static final String MONGODB_USERNAME = "root";
	private static final String MONGODB_PASSWORD = "";
	private static final String MONGODB_RESOURCE_FILE = "mongodb.cfg.properties";
	private static final String MONGODB_DBNAME = "test";
	private static final String MONGODB_COLLECTIONNAME = "test";

3、通过有参构造方法构造MongoDBService对象或通过get/set方法,指定数据库及集合,优先级最高

//有参构造方法,指定数据库名与集合名
	public MongoDBServiceImpl(String dbName, String collName) {
		this.dbName = dbName;
		this.collName = collName;
		try {
			db = getDb();
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
	//无参构造方法,返回配置文件配置的数据库对象引用,如果配置文件中没有设置则返回默认数据库对象引用
	public MongoDBServiceImpl() {
		getDb();
	}
	/*
	 * 获取数据库对象,3种情况(优先级从高到低):
<span style="white-space:pre">	</span>*1、构造方法指定2、配置文件指定3、默认数据库
<span style="white-space:pre">	</span>*(情况2、3在MongoDButil中设置)
	 */
	public DB getDb() {
		if (this.db == null) {
			if (this.dbName == null) {
				this.db = MongoDBUtil.getDB();
			} else {
				this.db = MongoDBUtil.getDBByName(this.dbName);
			}
		}
		return this.db;
	}
	
	/*
	 * 获取集合对象,3种情况(优先级从高到低):
         *1、构造方法指定2、配置文件指定3、默认数据库
	 *(情况2、3在MongoDButil中设置)
	 */
	public DBCollection getCollection() {
		if(this.collName != null){
			return db.getCollection(this.collName);
		}
		else {
			return MongoDBUtil.getDBCollection();
		}
	}

二、方法简介(具体实现参看MongoDBServiceImpl接口实现类)

1、获取基本信息或对象:

(1)、获取数据库名: getDbName()
(2)、设置数据库名(指定数据库): setDbName(String dbName)
(3)、获取集合名: getCollName()
(4)、设置集合名(指定集合): setCollName(String collName)
(5)、获取数据库对象: getDb()

2、数据插入方式:
(1)、插入单条数据: insert(DBObject obj)
(2)、插入多条数据: insertBatch(List<DBObject> list)void

3、数据删除方式:
(1)、删除单条数据: delete(DBObject obj)
(2)、删除多条数据: deleteBatch(List<DBObject> list)

4、数量统计方式:
(1)、获取集合中数据数量: getCollectionCount()
(2)、获取符合条件的数据数量: getCount(DBObject obj)

5、查找数据:
(1)、查找所有数据: findAll()
(2)、查找符合条件的数据: find(DBObject obj)
(3)、查找符合条件的数据并排序: find(DBObject query, DBObject sort)
(4)、查找符合条件的指定数量的数据并排序:find(DBObject query, DBObject sort, int start, int limit)
(5)、由ID查找数据: getById(String id)

6、更新数据update(DBObject setFields, DBObject whereFields) void

7、打印List<DBObject>:  printListDBObj(List<DBObject> list)

推荐:常用代码备忘录(封装 Apache Commons 的 DbUtils 实现的数据库操作工具类)-DBUtil.java

public class DBUtil { private static final QueryRunner runner = new QueryRunner(); // 打开数据库连接(type: MySQL, Oracle,SQLServer) p

测试代码:(@Test)

public class testMongoService {
	//使用mongodb.cfg.properties中配置的数据库与集合,如未指定,使用MongoDBUtil中默认的数据库与集合
	MongoDBService mongoDBService1 = new MongoDBServiceImpl();
	
	//测试插入数据
	@Test
	public void testInsert(){
		//数据一,包括用户名、密码,地址信息(省份、城市),爱好[…]
		BasicDBList dbList1 = new BasicDBList();
		dbList1.add("basketball");
		dbList1.add("music");
		dbList1.add("web");
		DBObject dbObject1 = new BasicDBObject("username","insert1")
			.append("age", 18)
			.append("address", new BasicDBObject("province","广东").append("city", "广州"))
			.append("favourite", dbList1);
		//数据二
		BasicDBList dbList2 = new BasicDBList();
		dbList2.add("football");
		dbList2.add("music");
		DBObject dbObject2 = new BasicDBObject("username","insert2")
			.append("age", 18)
			.append("address", new BasicDBObject("province","陕西").append("city", "西安"))
			.append("favourite", dbList2);
		//数据三
		BasicDBList dbList3 = new BasicDBList();
		dbList3.add("Linux");
		DBObject dbObject3 = new BasicDBObject("username","insert3")
			.append("age", 18)
			.append("address", new BasicDBObject("province","河北").append("city", "保定"))
			.append("favourite", dbList3);
		//数据四
		BasicDBList dbList4 = new BasicDBList();
		dbList4.add("swim");
		dbList4.add("android");
		DBObject dbObject4 = new BasicDBObject("username","insert4")
			.append("age", 18)
			.append("address", new BasicDBObject("province","四川").append("city", "成都"))
			.append("favourite", dbList4);
		//数据五
		DBObject dbObject5 = new BasicDBObject("username", "insert5")
			.append("age", 28)
			.append("address", new BasicDBObject("city", "杭州"));
		mongoDBService1.printListDBObj(mongoDBService1.findAll());
		System.out.println("——————————————————insert collection——————————————————");
		List<DBObject> list = new ArrayList<DBObject>();
		list.add(dbObject1);
		list.add(dbObject2);
		list.add(dbObject3);
		list.add(dbObject5);
		mongoDBService1.insertBatch(list);
		System.out.println("——————————————————insert one——————————————————");
		mongoDBService1.insert(dbObject4);
		mongoDBService1.printListDBObj(mongoDBService1.findAll());
	}
	
	//测试查询数据
	@Test
	public void testFind(){
		DBObject dbObject = new BasicDBObject("username","insert1");
		System.out.println("数量:" + mongoDBService1.getCollectionCount());
		System.out.println("username=java的数据数量:" + mongoDBService1.getCount(dbObject));
		System.out.println("——————————————————find all——————————————————");
		mongoDBService1.printListDBObj(mongoDBService1.findAll());
		System.out.println("——————————————————find obj——————————————————");
		mongoDBService1.printListDBObj(mongoDBService1.find(dbObject));
		System.out.println("——————————————————find sort——————————————————");
		mongoDBService1.printListDBObj(mongoDBService1.find(new BasicDBObject(), new BasicDBObject("age", 1)));
		System.out.println("——————————————————find sort limit——————————————————");
		mongoDBService1.printListDBObj(mongoDBService1.find(new BasicDBObject(), new BasicDBObject("age", 1), 1, 2));
	}

	//测试数据更新
	@Test
	public void testUpdate(){
		BasicDBObject newDocument = new BasicDBObject("$set",new BasicDBObject("age",11));
				
		BasicDBObject searchQuery = new BasicDBObject().append("username", "insert2");
	
		mongoDBService1.printListDBObj(mongoDBService1.find(searchQuery));
		System.out.println("——————————————————update——————————————————");
		mongoDBService1.update(newDocument, searchQuery);
		mongoDBService1.printListDBObj(mongoDBService1.find(searchQuery));
	}
	
	//测试数据删除
	@Test
	public void testDelete(){
		DBObject dbObject1 = new BasicDBObject("username", "insert1");
		DBObject dbObject2 = new BasicDBObject("username", "insert2");
		DBObject dbObject3 = new BasicDBObject("username", "insert3");
		DBObject dbObject4 = new BasicDBObject("username", "insert4");
		DBObject dbObject5 = new BasicDBObject("username", "insert5");
		List<DBObject> list = new ArrayList<DBObject>();
		list.add(dbObject1);
		list.add(dbObject2);
		list.add(dbObject3);
		list.add(dbObject4);
		mongoDBService1.printListDBObj(mongoDBService1.findAll());
		System.out.println("——————————————————delete list——————————————————");
		mongoDBService1.deleteBatch(list);
		System.out.println("——————————————————delete one——————————————————");
		mongoDBService1.delete(dbObject5);
		//System.out.println("——————————————————delete all——————————————————");
		//mongoDBService1.delete(new BasicDBObject());
		mongoDBService1.printListDBObj(mongoDBService1.findAll());
	}
}
测试结果:





源代码:(完整项目文件下载链接:点击打开链接

MongoDBServiceImpl.java

public class MongoDBServiceImpl implements MongoDBService {
	private String dbName;
	private String collName;
	private DB db;
	
	//有参构造方法,指定数据库名与集合名
	public MongoDBServiceImpl(String dbName, String collName) {
		this.dbName = dbName;
		this.collName = collName;
		try {
			db = getDb();
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}
	//无参构造方法,返回配置文件配置的数据库对象引用,如果配置文件中没有设置则返回默认数据库对象引用
	public MongoDBServiceImpl() {
		getDb();
	}
	/*
	 * 获取数据库对象,3种情况(优先级从高到低):
     *1、构造方法指定2、配置文件指定3、默认数据库
	 *(情况2、3在MongoDButil中设置)
	 */
	public DB getDb() {
		if (this.db == null) {
			if (this.dbName == null) {
				this.db = MongoDBUtil.getDB();
			} else {
				this.db = MongoDBUtil.getDBByName(this.dbName);
			}
		}
		return this.db;
	}
	
	/*
	 * 获取集合对象,3种情况(优先级从高到低):
     *1、构造方法指定2、配置文件指定3、默认数据库
	 *(情况2、3在MongoDButil中设置)
	 */
	public DBCollection getCollection() {
		if(this.collName != null){
			return db.getCollection(this.collName);
		}
		else {
			return MongoDBUtil.getDBCollection();
		}
	}

	public DBObject map2Obj(Map<String, Object> map) {
		DBObject obj = new BasicDBObject();
		if (map.containsKey("class") && map.get("class") instanceof Class)
			map.remove("class");
		obj.putAll(map);
		return obj;
	}
	//插入数据
	public void insert(DBObject obj) {
		getCollection().insert(obj);
	}
	//插入多条数据
	public void insertBatch(List<DBObject> list) {
		if (list == null || list.isEmpty()) {
			return;
		}
		List<DBObject> listDB = new ArrayList<DBObject>();
		for (int i = 0; i < list.size(); i++) {
			listDB.add(list.get(i));
		}
		getCollection().insert(listDB);
	}
	//删除数据
	public void delete(DBObject obj) {
		getCollection().remove(obj);
	}
	//删除多条数据
	public void deleteBatch(List<DBObject> list) {
		if (list == null || list.isEmpty()) {
			return;
		}
		for (int i = 0; i < list.size(); i++) {
			getCollection().remove(list.get(i));
		}
	}
	//获取集合中的数据数量
	public long getCollectionCount() {
		return getCollection().getCount();
	}
	//查找符合条件的数据数量
	public long getCount(DBObject obj) {
		if (obj != null)
			return getCollection().getCount(obj);
		return getCollectionCount();
	}
	//查找符合条件的数据
	public List<DBObject> find(DBObject obj) {
		DBCursor cur = getCollection().find(obj);
		return DBCursor2list(cur);
	}
	
	//查找符合条件的数据并排序
	@Override
	public List<DBObject> find(DBObject query, DBObject sort) {
		DBCursor cur;
		if (query != null) {
			cur = getCollection().find(query);
		} else {
			cur = getCollection().find();
		}
		if (sort != null) {
			cur.sort(sort);
		}
		return DBCursor2list(cur);
	}

	//查找符合条件的数据并排序,规定数据个数
	@Override
	public List<DBObject> find(DBObject query, DBObject sort, int start,
			int limit) {
		DBCursor cur;
		if (query != null) {
			cur = getCollection().find(query);
		} else {
			cur = getCollection().find();
		}
		if (sort != null) {
			cur.sort(sort);
		}
		if (start == 0) {
			cur.batchSize(limit);
		} else {
			cur.skip(start).limit(limit);
		}
		return DBCursor2list(cur);
	}
	
	//将DBCursor转化为list<DBObject>
	private List<DBObject> DBCursor2list(DBCursor cur) {
		List<DBObject> list = new ArrayList<DBObject>();
		if (cur != null) {
			list = cur.toArray();
		}
		return list;
	}

	//更新数据
	public void update(DBObject setFields, DBObject whereFields) {
		getCollection().updateMulti(whereFields, setFields);
	}
	//查询集合中所有数据
	public List<DBObject> findAll() {
		DBCursor cur = getCollection().find();
		List<DBObject> list = new ArrayList<DBObject>();
		if (cur != null) {
			list = cur.toArray();
		}
		return list;
	}

	//由ID获取数据
	public DBObject getById(String id) {
		DBObject obj = new BasicDBObject();
		obj.put("_id", new ObjectId(id));
		DBObject result = getCollection().findOne(obj);
		return result;
	}

	public String getDbName() {
		return dbName;
	}

	public void setDbName(String dbName) {
		this.dbName = dbName;
		this.db = MongoDBUtil.getDBByName(this.dbName);
	}

	public String getCollName() {
		return collName;
	}

	public void setCollName(String collName) {
		this.collName = collName;
	}
	@Override
	public void printListDBObj(List<DBObject> list) {
		// TODO Auto-generated method stub
		for(DBObject dbObject: list){
			System.out.println(dbObject);
		}
	}

	

}
MongoDBUtil.java

public class MongoDBUtil {
	// 定义默认配置,1、IP地址 2、端口号 3、用户名 4、密码 5、配置文件位置名 6、数据库名
	private static final String MONGODB_ADDRESS = "127.0.0.1";
	private static final int MONGODB_PORT = 27017;
	private static final String MONGODB_USERNAME = "root";
	private static final String MONGODB_PASSWORD = "";
	private static final String MONGODB_RESOURCE_FILE = "mongodb.cfg.properties";
	private static final String MONGODB_DBNAME = "test";
	private static final String MONGODB_COLLECTIONNAME = "test";
	// 定义静态变量,1、Mongo对象(代表数据库连接)2、DB对象(代表数据库)3、集合名4、数据库相关配置映射集合5、已获取的数据库连接
	private static Mongo mongo;
	private static DB db;
	private static DBCollection collection;
	private static Map<String, String> cfgMap = new HashMap<String, String>();
	private static Hashtable<String, DB> mongoDBs = new Hashtable<String, DB>();

	/**
	 * 初始化Mongo的数据库
	 */
	static {
		init();
	}

	/**
	 * 获取配置文件中配置的DB对象
	 */
	public static DB getDB() {
		return db;
	}

	/**
	 * 获取配置文件中配置的DBCollection对象
	 */
	public static DBCollection getDBCollection() {
		return collection;
	}

	/**
	 * 根据数据库名称,得到数据库 如果不存在,则创建一个该名称的数据库,并设置用户名和密码为配置文件中的参数值
	 * 
	 * @param dbName
	 * @return DB
	 */
	@SuppressWarnings("deprecation")
	public static DB getDBByName(String dbName) {
		DB db = mongo.getDB(dbName);
		if (!mongoDBs.contains(db)) {
			System.out.println("add");
			db.addUser(cfgMap.get("mongo.db.username"),
					cfgMap.get("mongo.db.password").toCharArray());
			mongoDBs.put(dbName, db);
		}
		return db;
	}

	// ————————————————————————————————————初始化过程————————————————————————————————————
	/**
	 * 获取配置文件mongedb.cfg.properties的文件对象
	 */
	public static File getConfigFile() {
		String path = MongoDBUtil.class.getResource("/").getPath();
		String fileName = path + MONGODB_RESOURCE_FILE;
		System.out.println(fileName);
		File file = new File(fileName);
		if (file.exists()) {
			return file;
		}
		return null;
	}

	/**
	 * 通过mongedb.cfg.properties配置文件初始化配置映射集合,如果没有编写配置文件,则加载程序指定的默认配置
	 */
	@SuppressWarnings("unchecked")
	private static void initCfgMap() {
		File file = getConfigFile();
		if (file != null) {
			Properties p = new Properties();
			try {
				p.load(new FileInputStream(file));
				for (Enumeration enu = p.propertyNames(); enu.hasMoreElements();) {
					String key = (String) enu.nextElement();
					String value = (String) p.getProperty(key);
					cfgMap.put(key, value);
				}
			} catch (IOException e) {
				System.out.println("加载Mongo配置文件失败!");
				e.printStackTrace();
			}
		} else { // 如果没有编写配置文件,则加载默认配置
			cfgMap.put("mongo.db.address", MONGODB_ADDRESS);
			cfgMap.put("mongo.db.port", String.valueOf(MONGODB_PORT));
			cfgMap.put("mongo.db.username", MONGODB_USERNAME);
			cfgMap.put("mongo.db.password", MONGODB_PASSWORD);
			cfgMap.put("mongo.db.dbname", MONGODB_DBNAME);
			cfgMap.put("mongo.db.collectionname", MONGODB_COLLECTIONNAME);
		}
	}

	/**
	 * 初始化Mongo的数据库(将db指向相应对象引用,将collection指向相应对象引用,通过mongoDBs记录现有数据库对象)
	 */
	@SuppressWarnings("deprecation")
	private static void init() {
		initCfgMap();
		try {
			String address = cfgMap.get("mongo.db.address");
			int port = Integer.parseInt(cfgMap.get("mongo.db.port").toString());
			String dbName = cfgMap.get("mongo.db.dbname");
			String username = cfgMap.get("mongo.db.username");
			String password = cfgMap.get("mongo.db.password");
			String collectionName = cfgMap.get("mongo.db.collectionname");
			mongo = new Mongo(address, port);
			if (dbName != null && !"".equals(dbName)) {
				db = mongo.getDB(dbName);
				if (username != null && !"".equals(username)) {
					db.addUser(username, password.toCharArray());
					if (collectionName != null && !"".equals(collectionName)) {
						collection = db.getCollection(collectionName);
					}
				}
				mongoDBs.put(dbName, db);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}


推荐:java代码中如何对MongoDB数据库进行类似{“age”:{"$all":[6,8]}}的查询

// 连接数据库 Mongo mongoClient = new Mongo("localhost",27017); // 获取名为“test”的数据库 DB db = mongoClient.getDB("test"); // 获取名为“things”的

——因为实习工作需要,在学MongoDB,参考了公司的一个MongDB服务类,写了一个整合的Demo,涉及到的大部分的增删改查操作,而且还算规范,给大家参考!源代码:(完整项目文件下载链接:点击打

相关阅读排行


用户评论

游客

相关内容推荐

最新文章

×

×

请激活账号

为了能正常使用评论、编辑功能及以后陆续为用户提供的其他产品,请激活账号。

您的注册邮箱: 修改

重新发送激活邮件 进入我的邮箱

如果您没有收到激活邮件,请注意检查垃圾箱。