MongoDB java方法

[java] view plain copy print ?

1. package model.dao;  
2.   
3. import java.util.ArrayList;  
4. import java.util.HashMap;  
5. import java.util.List;  
6. import java.util.Map;  
7.   
8. import org.apache.log4j.Logger;  
9. import org.bson.types.ObjectId;  
10.   
11. import com.mongodb.BasicDBObject;  
12. import com.mongodb.DB;  
13. import com.mongodb.DBCollection;  
14. import com.mongodb.DBCursor;  
15. import com.mongodb.DBObject;  
16. import com.mongodb.Mongo;  
17. import com.mongodb.MongoException;  
18.   
19. /** 
20. * MongoDB Manager 
21. * @author Ken Chau 
22. * 
23. */  
24. public class MongoDBManager {  
25.      private static Logger log = Logger.getLogger(MongoDBManager.class);  
26.       
27.      private static Mongo mg = null;  
28.      private static DB db = null;  
29.       
30.      private final static MongoDBManager instance = new MongoDBManager();  
31.       
32.      /** 
33.      * 实例化 
34.      * @return 
35.      * @throws Exception 
36.      */  
37.      public static MongoDBManager getInstance() throws Exception {  
38.             return instance;  
39.      }  
40.       
41.      static {  
42.           try {  
43.                mg = new Mongo(HOST, PORT);  
44.               db=mg.getDB(DB);  
45.           } catch (Exception e) {  
46.                log.error("Can't connect MongoDB!");  
47.               e.printStackTrace();  
48.           }  
49.      }  
50.              
51.      /** 
52.      * 获取集合（表） 
53.      * @param collection 
54.      */  
55.      public static DBCollection getCollection(String collection) {  
56.           return db.getCollection(collection);  
57.      }  
58.   
59.      /** 
60.      * ----------------------------------分割线-------------------------------------- 
61.      */  
62.   
63.      /** 
64.      * 插入 
65.      * @param collection 
66.      * @param map 
67.      */  
68.      public void insert(String collection , Map<String, Object> map) {  
69.           try {  
70.                DBObject dbObject = map2Obj(map);  
71.                getCollection(collection).insert(dbObject);  
72.           } catch (MongoException e) {  
73.                log.error("MongoException:" + e.getMessage());  
74.           }  
75.      }  
76.   
77.      /** 
78.      * 批量插入 
79.      * @param collection 
80.      * @param list 
81.      */  
82.      public void insertBatch(String collection ,List<Map<String, Object>> list) {  
83.           if (list == null || list.isEmpty()) {  
84.                return;  
85.           }  
86.           try {  
87.                List<DBObject> listDB = new ArrayList<DBObject>();  
88.                for (int i = 0; i < list.size(); i++) {  
89.                     DBObject dbObject = map2Obj(list.get(i));  
90.                     listDB.add(dbObject);  
91.                }  
92.                getCollection(collection).insert(listDB);  
93.           } catch (MongoException e) {  
94.                log.error("MongoException:" + e.getMessage());  
95.           }  
96.      }  
97.   
98.      /** 
99.      * 删除 
100.      * @param collection 
101.      * @param map 
102.      */  
103.      public void delete(String collection ,Map<String, Object> map) {  
104.           DBObject obj = map2Obj(map);  
105.           getCollection(collection).remove(obj);  
106.      }  
107.   
108.      /** 
109.        * 删除全部 
110.        * @param collection 
111.        * @param map 
112.        */  
113.      public void deleteAll(String collection) {  
114.           List<DBObject> rs = findAll(collection);  
115.           if (rs != null && !rs.isEmpty()) {  
116.                for (int i = 0; i < rs.size(); i++) {  
117.                     getCollection(collection).remove(rs.get(i));  
118.                }  
119.           }  
120.      }  
121.   
122.      /** 
123.      * 批量删除 
124.      * @param collection 
125.      * @param list 
126.      */  
127.      public void deleteBatch(String collection,List<Map<String, Object>> list) {  
128.           if (list == null || list.isEmpty()) {  
129.                return;  
130.           }  
131.           for (int i = 0; i < list.size(); i++) {  
132.                getCollection(collection).remove(map2Obj(list.get(i)));  
133.           }  
134.      }  
135.   
136.      /** 
137.      * 计算满足条件条数 
138.      * @param collection 
139.      * @param map 
140.      */  
141.      public long getCount(String collection,Map<String, Object> map) {  
142.           return getCollection(collection).getCount(map2Obj(map));  
143.      }  
144.       
145.      /** 
146.      * 计算集合总条数 
147.      * @param collection 
148.      * @param map 
149.      */  
150.      public long getCount(String collection) {  
151.           return getCollection(collection).find().count();  
152.      }  
153.   
154.      /** 
155.      * 更新 
156.      * @param collection 
157.      * @param setFields 
158.      * @param whereFields 
159.      */  
160.      public void update(String collection,Map<String, Object> setFields,  
161.                Map<String, Object> whereFields) {  
162.           DBObject obj1 = map2Obj(setFields);  
163.           DBObject obj2 = map2Obj(whereFields);  
164.           getCollection(collection).updateMulti(obj1, obj2);  
165.      }  
166.   
167.      /** 
168.      * 查找对象（根据主键_id） 
169.      * @param collection 
170.      * @param _id 
171.      */  
172.      public DBObject findById(String collection,String _id) {  
173.           DBObject obj = new BasicDBObject();  
174.           obj.put("_id", ObjectId.massageToObjectId(_id));  
175.           return getCollection(collection).findOne(obj);  
176.      }  
177.   
178.      /** 
179.      * 查找集合所有对象 
180.      * @param collection 
181.      */  
182.      public List<DBObject> findAll(String collection) {  
183.           return getCollection(collection).find().toArray();  
184.      }  
185.   
186.      /** 
187.      * 查找（返回一个对象） 
188.      * @param map 
189.      * @param collection 
190.      */  
191.      public DBObject findOne(String collection,Map<String, Object> map) {  
192.           DBCollection coll = getCollection(collection);  
193.           return coll.findOne(map2Obj(map));  
194.      }  
195.   
196.      /** 
197.      * 查找（返回一个List<DBObject>） 
198.      * @param <DBObject> 
199.      * @param map 
200.      * @param collection 
201.      * @throws Exception 
202.      */  
203.      public List<DBObject> find(String collection,Map<String, Object> map) throws Exception {  
204.           DBCollection coll = getCollection(collection);  
205.           DBCursor c = coll.find(map2Obj(map));  
206.           if (c != null)  
207.                return c.toArray();  
208.           else  
209.                return null;  
210.      }  

package model.dao; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import org.apache.log4j.Logger; import org.bson.types.ObjectId; import com.mongodb.BasicDBObject; import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.DBCursor; import com.mongodb.DBObject; import com.mongodb.Mongo; import com.mongodb.MongoException; /** * MongoDB Manager * @author Ken Chau * */ public class MongoDBManager { private static Logger log = Logger.getLogger(MongoDBManager.class); private static Mongo mg = null; private static DB db = null; private final static MongoDBManager instance = new MongoDBManager(); /** * 实例化 * @return * @throws Exception */ public static MongoDBManager getInstance() throws Exception { return instance; } static { try { mg = new Mongo(HOST, PORT); db=mg.getDB(DB); } catch (Exception e) { log.error("Can't connect MongoDB!"); e.printStackTrace(); } } /** * 获取集合（表） * @param collection */ public static DBCollection getCollection(String collection) { return db.getCollection(collection); } /** * ----------------------------------分割线-------------------------------------- */ /** * 插入 * @param collection * @param map */ public void insert(String collection , Map<String, Object> map) { try { DBObject dbObject = map2Obj(map); getCollection(collection).insert(dbObject); } catch (MongoException e) { log.error("MongoException:" + e.getMessage()); } } /** * 批量插入 * @param collection * @param list */ public void insertBatch(String collection ,List<Map<String, Object>> list) { if (list == null || list.isEmpty()) { return; } try { List<DBObject> listDB = new ArrayList<DBObject>(); for (int i = 0; i < list.size(); i++) { DBObject dbObject = map2Obj(list.get(i)); listDB.add(dbObject); } getCollection(collection).insert(listDB); } catch (MongoException e) { log.error("MongoException:" + e.getMessage()); } } /** * 删除 * @param collection * @param map */ public void delete(String collection ,Map<String, Object> map) { DBObject obj = map2Obj(map); getCollection(collection).remove(obj); } /** * 删除全部 * @param collection * @param map */ public void deleteAll(String collection) { List<DBObject> rs = findAll(collection); if (rs != null && !rs.isEmpty()) { for (int i = 0; i < rs.size(); i++) { getCollection(collection).remove(rs.get(i)); } } } /** * 批量删除 * @param collection * @param list */ public void deleteBatch(String collection,List<Map<String, Object>> list) { if (list == null || list.isEmpty()) { return; } for (int i = 0; i < list.size(); i++) { getCollection(collection).remove(map2Obj(list.get(i))); } } /** * 计算满足条件条数 * @param collection * @param map */ public long getCount(String collection,Map<String, Object> map) { return getCollection(collection).getCount(map2Obj(map)); } /** * 计算集合总条数 * @param collection * @param map */ public long getCount(String collection) { return getCollection(collection).find().count(); } /** * 更新 * @param collection * @param setFields * @param whereFields */ public void update(String collection,Map<String, Object> setFields, Map<String, Object> whereFields) { DBObject obj1 = map2Obj(setFields); DBObject obj2 = map2Obj(whereFields); getCollection(collection).updateMulti(obj1, obj2); } /** * 查找对象（根据主键_id） * @param collection * @param _id */ public DBObject findById(String collection,String _id) { DBObject obj = new BasicDBObject(); obj.put("_id", ObjectId.massageToObjectId(_id)); return getCollection(collection).findOne(obj); } /** * 查找集合所有对象 * @param collection */ public List<DBObject> findAll(String collection) { return getCollection(collection).find().toArray(); } /** * 查找（返回一个对象） * @param map * @param collection */ public DBObject findOne(String collection,Map<String, Object> map) { DBCollection coll = getCollection(collection); return coll.findOne(map2Obj(map)); } /** * 查找（返回一个List<DBObject>） * @param <DBObject> * @param map * @param collection * @throws Exception */ public List<DBObject> find(String collection,Map<String, Object> map) throws Exception { DBCollection coll = getCollection(collection); DBCursor c = coll.find(map2Obj(map)); if (c != null) return c.toArray(); else return null; }