MongoDB在java中的使用

在一年前就开始在项目中使用Mongodb作为爬虫（crawler）待下载URL、下载成功URL等的存储库，最近对项目进行版本更新，根据Mongodb的最近升级情况，也对项目中的Mongodb进行了相关的调整。

主要的调整在于2.10.0版本中引入了MongoClient类，同时在其API中也说明了Mongo类会在将来的版本中被MongoClient替换（Note: This class has been superseded by MongoClient, and may be deprecated in a future release.）。故在这次调整中，也对原先的Mongodb部分做了相应的修改。

MongoClient被设计成线程安全、可以被多线程共享的。通常访问数据库集群的应用只需要一个实例，所以这次调整我们设计成单例形式。如果出于某些原因，你决定使用多个实例，请注意：所有资源使用限制（最大连接数等等）对每个MongoClient都适用；销毁一个实例时，请确认调用MongoClient.close()方法来清理资源。

下面给出相关的代码：

接口类

1. /**
2. * 项目名：SpiderCrawler
3. * 文件名：MongoDBDao.java
4. * 作者：zhouyh
5. * 时间：2014-8-30 下午03:46:55
6. * 描述：TODO(用一句话描述该文件做什么)
7. */
8. package com.newsTest.dao;
9. import java.util.ArrayList;
10. import com.mongodb.DB;
11. import com.mongodb.DBCollection;
12. import com.mongodb.DBObject;
13. /**
14. * 类名： MongoDBDao
15. * 包名： com.newsTest.dao
16. * 作者： zhouyh
17. * 时间： 2014-8-30 下午03:46:55
18. * 描述： TODO(这里用一句话描述这个类的作用)
19. */
20. public interface MongoDBDao {
21. /**
22. *
23. * 方法名：getDb
24. * 作者：zhouyh
25. * 创建时间：2014-8-30 下午03:53:40
26. * 描述：获取指定的mongodb数据库
27. * @param dbName
28. * @return
29. */
30. public DB getDb(String dbName);
31. /**
32. *
33. * 方法名：getCollection
34. * 作者：zhouyh
35. * 创建时间：2014-8-30 下午03:54:43
36. * 描述：获取指定mongodb数据库的collection集合
37. * @param dbName    数据库名
38. * @param collectionName    数据库集合
39. * @return
40. */
41. public DBCollection getCollection(String dbName, String collectionName);
42. /**
43. *
44. * 方法名：inSert
45. * 作者：zhouyh
46. * 创建时间：2014-8-30 下午04:07:35
47. * 描述：向指定的数据库中添加给定的keys和相应的values
48. * @param dbName
49. * @param collectionName
50. * @param keys
51. * @param values
52. * @return
53. */
54. public boolean inSert(String dbName, String collectionName, String[] keys, Object[] values);
55. /**
56. *
57. * 方法名：delete
58. * 作者：zhouyh
59. * 创建时间：2014-8-30 下午04:09:00
60. * 描述：删除数据库dbName中，指定keys和相应values的值
61. * @param dbName
62. * @param collectionName
63. * @param keys
64. * @param values
65. * @return
66. */
67. public boolean delete(String dbName, String collectionName, String[] keys, Object[] values);
68. /**
69. *
70. * 方法名：find
71. * 作者：zhouyh
72. * 创建时间：2014-8-30 下午04:11:11
73. * 描述：从数据库dbName中查找指定keys和相应values的值
74. * @param dbName
75. * @param collectionName
76. * @param keys
77. * @param values
78. * @param num
79. * @return
80. */
81. public ArrayList<DBObject> find(String dbName, String collectionName, String[] keys, Object[] values, int num);
82. /**
83. *
84. * 方法名：update
85. * 作者：zhouyh
86. * 创建时间：2014-8-30 下午04:17:54
87. * 描述：更新数据库dbName，用指定的newValue更新oldValue
88. * @param dbName
89. * @param collectionName
90. * @param oldValue
91. * @param newValue
92. * @return
93. */
94. public boolean update(String dbName, String collectionName, DBObject oldValue, DBObject newValue);
95. /**
96. *
97. * 方法名：isExit
98. * 作者：zhouyh
99. * 创建时间：2014-8-30 下午04:19:21
100. * 描述：判断给定的keys和相应的values在指定的dbName的collectionName集合中是否存在
101. * @param dbName
102. * @param collectionName
103. * @param keys
104. * @param values
105. * @return
106. */
107. public boolean isExit(String dbName, String collectionName, String key, Object value);
108. }

接口实现类：

1. /**
2. * 项目名：SpiderCrawler
3. * 文件名：MongoDBDaoImpl.java
4. * 作者：zhouyh
5. * 时间：2014-8-30 下午04:21:11
6. * 描述：TODO(用一句话描述该文件做什么)
7. */
8. package com.newsTest.dao.impl;
9. import java.net.UnknownHostException;
10. import java.util.ArrayList;
11. import com.newsTest.dao.MongoDBDao;
12. import com.mongodb.BasicDBObject;
13. import com.mongodb.DB;
14. import com.mongodb.DBCollection;
15. import com.mongodb.DBCursor;
16. import com.mongodb.DBObject;
17. import com.mongodb.MongoClient;
18. import com.mongodb.MongoClientOptions;
19. import com.mongodb.MongoException;
20. import com.mongodb.WriteResult;
21. /**
22. * 类名： MongoDBDaoImpl
23. * 包名： com.newsTest.dao.impl
24. * 作者： zhouyh
25. * 时间： 2014-8-30 下午04:21:11
26. * 描述： TODO(这里用一句话描述这个类的作用)
27. */
28. public class MongoDBDaoImpl implements MongoDBDao{
29. /**
30. * MongoClient的实例代表数据库连接池，是线程安全的，可以被多线程共享，客户端在多线程条件下仅维持一个实例即可
31. * Mongo是非线程安全的，目前mongodb API中已经建议用MongoClient替代Mongo
32. */
33. private MongoClient mongoClient = null;
34. /**
35. *
36. * 私有的构造函数
37. * 作者：zhouyh
38. */
39. private MongoDBDaoImpl(){
40. if(mongoClient == null){
41. MongoClientOptions.Builder build = new MongoClientOptions.Builder();
42. build.connectionsPerHost(50);   //与目标数据库能够建立的最大connection数量为50
43. build.autoConnectRetry(true);   //自动重连数据库启动
44. build.threadsAllowedToBlockForConnectionMultiplier(50); //如果当前所有的connection都在使用中，则每个connection上可以有50个线程排队等待
45. /*
46. * 一个线程访问数据库的时候，在成功获取到一个可用数据库连接之前的最长等待时间为2分钟
47. * 这里比较危险，如果超过maxWaitTime都没有获取到这个连接的话，该线程就会抛出Exception
48. * 故这里设置的maxWaitTime应该足够大，以免由于排队线程过多造成的数据库访问失败
49. */
50. build.maxWaitTime(1000*60*2);
51. build.connectTimeout(1000*60*1);    //与数据库建立连接的timeout设置为1分钟
52. MongoClientOptions myOptions = build.build();
53. try {
54. //数据库连接实例
55. mongoClient = new MongoClient("127.0.0.1", myOptions);
56. } catch (UnknownHostException e) {
57. // TODO 这里写异常处理的代码
58. e.printStackTrace();
59. } catch (MongoException e){
60. e.printStackTrace();
61. }
62. }
63. }
64. /********单例模式声明开始，采用饿汉式方式生成，保证线程安全********************/
65. //类初始化时，自行实例化，饿汉式单例模式
66. private static final MongoDBDaoImpl mongoDBDaoImpl = new MongoDBDaoImpl();
67. /**
68. *
69. * 方法名：getMongoDBDaoImplInstance
70. * 作者：zhouyh
71. * 创建时间：2014-8-30 下午04:29:26
72. * 描述：单例的静态工厂方法
73. * @return
74. */
75. public static MongoDBDaoImpl getMongoDBDaoImplInstance(){
76. return mongoDBDaoImpl;
77. }
78. /************************单例模式声明结束*************************************/
79. @Override
80. public boolean delete(String dbName, String collectionName, String[] keys,
81. Object[] values) {
82. DB db = null;
83. DBCollection dbCollection = null;
84. if(keys!=null && values!=null){
85. if(keys.length != values.length){   //如果keys和values不对等，直接返回false
86. return false;
87. }else{
88. try {
89. db = mongoClient.getDB(dbName); //获取指定的数据库
90. dbCollection = db.getCollection(collectionName);    //获取指定的collectionName集合
91. BasicDBObject doc = new BasicDBObject();    //构建删除条件
92. WriteResult result = null;  //删除返回结果
93. String resultString = null;
94. for(int i=0; i<keys.length; i++){
95. doc.put(keys[i], values[i]);    //添加删除的条件
96. }
97. result = dbCollection.remove(doc);  //执行删除操作
98. resultString = result.getError();
99. if(null != db){
100. try {
101. db.requestDone();   //请求结束后关闭db
102. db = null;
103. } catch (Exception e) {
104. // TODO: handle exception
105. e.printStackTrace();
106. }
107. }
108. return (resultString!=null) ? false : true; //根据删除执行结果进行判断后返回结果
109. } catch (Exception e) {
110. // TODO: handle exception
111. e.printStackTrace();
112. } finally{
113. if(null != db){
114. db.requestDone();   //关闭db
115. db = null;
116. }
117. }
118. }
119. }
120. return false;
121. }
122. @Override
123. public ArrayList<DBObject> find(String dbName, String collectionName,
124. String[] keys, Object[] values, int num) {
125. ArrayList<DBObject> resultList = new ArrayList<DBObject>(); //创建返回的结果集
126. DB db = null;
127. DBCollection dbCollection = null;
128. DBCursor cursor = null;
129. if(keys!=null && values!=null){
130. if(keys.length != values.length){
131. return resultList;  //如果传来的查询参数对不对，直接返回空的结果集
132. }else{
133. try {
134. db = mongoClient.getDB(dbName); //获取数据库实例
135. dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合
136. BasicDBObject queryObj = new BasicDBObject();   //构建查询条件
137. for(int i=0; i<keys.length; i++){    //填充查询条件
138. queryObj.put(keys[i], values[i]);
139. }
140. cursor = dbCollection.find(queryObj);   //查询获取数据
141. int count = 0;
142. if(num != -1){  //判断是否是返回全部数据，num=-1返回查询全部数据，num!=-1则返回指定的num数据
143. while(count<num && cursor.hasNext()){
144. resultList.add(cursor.next());
145. count++;
146. }
147. return resultList;
148. }else{
149. while(cursor.hasNext()){
150. resultList.add(cursor.next());
151. }
152. return resultList;
153. }
154. } catch (Exception e) {
155. // TODO: handle exception
156. } finally{
157. if(null != cursor){
158. cursor.close();
159. }
160. if(null != db){
161. db.requestDone();   //关闭数据库请求
162. }
163. }
164. }
165. }
166. return resultList;
167. }
168. @Override
169. public DBCollection getCollection(String dbName, String collectionName) {
170. // TODO Auto-generated method stub
171. return mongoClient.getDB(dbName).getCollection(collectionName);
172. }
173. @Override
174. public DB getDb(String dbName) {
175. // TODO Auto-generated method stub
176. return mongoClient.getDB(dbName);
177. }
178. @Override
179. public boolean inSert(String dbName, String collectionName, String[] keys,
180. Object[] values) {
181. DB db = null;
182. DBCollection dbCollection = null;
183. WriteResult result = null;
184. String resultString = null;
185. if(keys!=null && values!=null){
186. if(keys.length != values.length){
187. return false;
188. }else{
189. db = mongoClient.getDB(dbName); //获取数据库实例
190. dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合
191. BasicDBObject insertObj = new BasicDBObject();
192. for(int i=0; i<keys.length; i++){    //构建添加条件
193. insertObj.put(keys[i], values[i]);
194. }
195. try {
196. result = dbCollection.insert(insertObj);
197. resultString = result.getError();
198. } catch (Exception e) {
199. // TODO: handle exception
200. e.printStackTrace();
201. }finally{
202. if(null != db){
203. db.requestDone();   //请求结束后关闭db
204. }
205. }
206. return (resultString != null) ? false : true;
207. }
208. }
209. return false;
210. }
211. @Override
212. public boolean isExit(String dbName, String collectionName, String key,
213. Object value) {
214. // TODO Auto-generated method stub
215. DB db = null;
216. DBCollection dbCollection = null;
217. if(key!=null && value!=null){
218. try {
219. db = mongoClient.getDB(dbName); //获取数据库实例
220. dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合
221. BasicDBObject obj = new BasicDBObject();    //构建查询条件
222. obj.put(key, value);
223. if(dbCollection.count(obj) > 0) {
224. return true;
225. }else{
226. return false;
227. }
228. } catch (Exception e) {
229. // TODO: handle exception
230. e.printStackTrace();
231. } finally{
232. if(null != db){
233. db.requestDone();   //关闭db
234. db = null;
235. }
236. }
237. }
238. return false;
239. }
240. @Override
241. public boolean update(String dbName, String collectionName,
242. DBObject oldValue, DBObject newValue) {
243. DB db = null;
244. DBCollection dbCollection = null;
245. WriteResult result = null;
246. String resultString = null;
247. if(oldValue.equals(newValue)){
248. return true;
249. }else{
250. try {
251. db = mongoClient.getDB(dbName); //获取数据库实例
252. dbCollection = db.getCollection(collectionName);    //获取数据库中指定的collection集合
253. result = dbCollection.update(oldValue, newValue);
254. resultString = result.getError();
255. return (resultString!=null) ? false : true;
256. } catch (Exception e) {
257. // TODO: handle exception
258. e.printStackTrace();
259. } finally{
260. if(null != db){
261. db.requestDone();   //关闭db
262. db = null;
263. }
264. }
265. }
266. return false;
267. }
268. /**
269. * 方法名：main
270. * 作者：zhouyh
271. * 创建时间：2014-8-30 下午04:21:11
272. * 描述：TODO(这里用一句话描述这个方法的作用)
273. * @param args
274. */
275. public static void main(String[] args) {
276. // TODO Auto-generated method stub
277. }
278. }

这里使用的mongodb的java驱动版本是2.11.4，相关的驱动版本可以从这里下载mongodb java驱动，也可以查看相关的mongodb的api