Java单例模式下的MongoDB数据库操作工具类

本文实例讲述了Java 单例模式下的MongoDB数据库操作工具类。分享给大家供大家参考，具体如下：

我经常对MongoDB进行一些基础操作，将这些常用操作合并到一个工具类中，方便自己开发使用。

没用Spring Data、Morphia等框架是为了减少学习、维护成本，另外自己直接JDBC方式的话可以更灵活，为自己以后的积累留一个脚印。

JAVA驱动版本：

<dependency>

<groupId>org.mongodb</groupId>

<artifactId>mongo-java-driver</artifactId>

<version>3.0.2</version>

</dependency>

工具类代码如下：

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

package utils;

import java.util.ArrayList;

import java.util.List;

import org.apache.commons.configuration.CompositeConfiguration;

import org.apache.commons.configuration.ConfigurationException;

import org.apache.commons.configuration.PropertiesConfiguration;

import org.bson.Document;

import org.bson.conversions.Bson;

import org.bson.types.ObjectId;

import com.mongodb.BasicDBObject;

import com.mongodb.MongoClient;

import com.mongodb.MongoClientOptions;

import com.mongodb.MongoClientOptions.Builder;

import com.mongodb.WriteConcern;

import com.mongodb.client.MongoCollection;

import com.mongodb.client.MongoCursor;

import com.mongodb.client.MongoDatabase;

import com.mongodb.client.MongoIterable;

import com.mongodb.client.model.Filters;

import com.mongodb.client.result.DeleteResult;

/**

* MongoDB工具类 Mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个Mongo实例对我们来说已经足够了<br>

* 注意Mongo已经实现了连接池，并且是线程安全的。 <br>

* 设计为单例模式， 因 MongoDB的Java驱动是线程安全的，对于一般的应用，只要一个Mongo实例即可，<br>

* Mongo有个内置的连接池（默认为10个） 对于有大量写和读的环境中，为了确保在一个Session中使用同一个DB时，<br>

* DB和DBCollection是绝对线程安全的<br>

*

* @author zhoulingfei

* @date 2015-5-29 上午11:49:49

* @version 0.0.0

*/

public enum MongoDBUtil {

/**

* 定义一个枚举的元素，它代表此类的一个实例

*/

instance;

private MongoClient mongoClient;

static {

System.out.println("===============MongoDBUtil初始化========================");

CompositeConfiguration config = new CompositeConfiguration();

try {

config.addConfiguration(new PropertiesConfiguration("mongodb.properties"));

} catch (ConfigurationException e) {

e.printStackTrace();

}

// 从配置文件中获取属性值

String ip = config.getString("host");

int port = config.getInt("port");

instance.mongoClient = new MongoClient(ip, port);

// or, to connect to a replica set, with auto-discovery of the primary, supply a seed list of members

// List<ServerAddress> listHost = Arrays.asList(new ServerAddress("localhost", 27017),new ServerAddress("localhost", 27018));

// instance.mongoClient = new MongoClient(listHost);

// 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：

// boolean auth = db.authenticate(myUserName, myPassword);

Builder options = new MongoClientOptions.Builder();

// options.autoConnectRetry(true);// 自动重连true

// options.maxAutoConnectRetryTime(10); // the maximum auto connect retry time

options.connectionsPerHost(300);// 连接池设置为300个连接,默认为100

options.connectTimeout(15000);// 连接超时，推荐>3000毫秒

options.maxWaitTime(5000); //

options.socketTimeout(0);// 套接字超时时间，0无限制

options.threadsAllowedToBlockForConnectionMultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。

options.writeConcern(WriteConcern.SAFE);//

options.build();

}

// ------------------------------------共用方法---------------------------------------------------

/**

* 获取DB实例 - 指定DB

*

* @param dbName

* @return

*/

public MongoDatabase getDB(String dbName) {

if (dbName != null && !"".equals(dbName)) {

MongoDatabase database = mongoClient.getDatabase(dbName);

return database;

}

return null;

}

/**

* 获取collection对象 - 指定Collection

*

* @param collName

* @return

*/

public MongoCollection<Document> getCollection(String dbName, String collName) {

if (null == collName || "".equals(collName)) {

return null;

}

if (null == dbName || "".equals(dbName)) {

return null;

}

MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collName);

return collection;

}

/**

* 查询DB下的所有表名

*/

public List<String> getAllCollections(String dbName) {

MongoIterable<String> colls = getDB(dbName).listCollectionNames();

List<String> _list = new ArrayList<String>();

for (String s : colls) {

_list.add(s);

}

return _list;

}

/**

* 获取所有数据库名称列表

*

* @return

*/

public MongoIterable<String> getAllDBNames() {

MongoIterable<String> s = mongoClient.listDatabaseNames();

return s;

}

/**

* 删除一个数据库

*/

public void dropDB(String dbName) {

getDB(dbName).drop();

}

/**

* 查找对象 - 根据主键_id

*

* @param collection

* @param id

* @return

*/

public Document findById(MongoCollection<Document> coll, String id) {

ObjectId _idobj = null;

try {

_idobj = new ObjectId(id);

} catch (Exception e) {

return null;

}

Document myDoc = coll.find(Filters.eq("_id", _idobj)).first();

return myDoc;

}

/** 统计数 */

public int getCount(MongoCollection<Document> coll) {

int count = (int) coll.count();

return count;

}

/** 条件查询 */

public MongoCursor<Document> find(MongoCollection<Document> coll, Bson filter) {

return coll.find(filter).iterator();

}

/** 分页查询 */

public MongoCursor<Document> findByPage(MongoCollection<Document> coll, Bson filter, int pageNo, int pageSize) {

Bson orderBy = new BasicDBObject("_id", 1);

return coll.find(filter).sort(orderBy).skip((pageNo - 1) * pageSize).limit(pageSize).iterator();

}

/**

* 通过ID删除

*

* @param coll

* @param id

* @return

*/

public int deleteById(MongoCollection<Document> coll, String id) {

int count = 0;

ObjectId _id = null;

try {

_id = new ObjectId(id);

} catch (Exception e) {

return 0;

}

Bson filter = Filters.eq("_id", _id);

DeleteResult deleteResult = coll.deleteOne(filter);

count = (int) deleteResult.getDeletedCount();

return count;

}

/**

* FIXME

*

* @param coll

* @param id

* @param newdoc

* @return

*/

public Document updateById(MongoCollection<Document> coll, String id, Document newdoc) {

ObjectId _idobj = null;

try {

_idobj = new ObjectId(id);

} catch (Exception e) {

return null;

}

Bson filter = Filters.eq("_id", _idobj);

// coll.replaceOne(filter, newdoc); // 完全替代

coll.updateOne(filter, new Document("$set", newdoc));

return newdoc;

}

public void dropCollection(String dbName, String collName) {

getDB(dbName).getCollection(collName).drop();

}

/**

* 关闭Mongodb

*/

public void close() {

if (mongoClient != null) {

mongoClient.close();

mongoClient = null;

}

/**

* 测试入口

*

* @param args

*/

public static void main(String[] args) {

String dbName = "GC_MAP_DISPLAY_DB";

String collName = "COMMUNITY_BJ";

MongoCollection<Document> coll = MongoDBUtil.instance.getCollection(dbName, collName);

// 插入多条

// for (int i = 1; i <= 4; i++) {

// Document doc = new Document();

// doc.put("name", "zhoulf");

// doc.put("school", "NEFU" + i);

// Document interests = new Document();

// interests.put("game", "game" + i);

// interests.put("ball", "ball" + i);

// doc.put("interests", interests);

// coll.insertOne(doc);

// }

// // 根据ID查询

// String id = "556925f34711371df0ddfd4b";

// Document doc = MongoDBUtil2.instance.findById(coll, id);

// System.out.println(doc);

// 查询多个

// MongoCursor<Document> cursor1 = coll.find(Filters.eq("name", "zhoulf")).iterator();

// while (cursor1.hasNext()) {

// org.bson.Document _doc = (Document) cursor1.next();

// System.out.println(_doc.toString());

// }

// cursor1.close();

// 查询多个

// MongoCursor<Person> cursor2 = coll.find(Person.class).iterator();

// 删除数据库

// MongoDBUtil2.instance.dropDB("testdb");

// 删除表

// MongoDBUtil2.instance.dropCollection(dbName, collName);

// 修改数据

// String id = "556949504711371c60601b5a";

// Document newdoc = new Document();

// newdoc.put("name", "时候");

// MongoDBUtil.instance.updateById(coll, id, newdoc);

// 统计表

// System.out.println(MongoDBUtil.instance.getCount(coll));

// 查询所有

Bson filter = Filters.eq("count", 0);

MongoDBUtil.instance.find(coll, filter);

}

希望本文所述对大家java程序设计有所帮助。

原文链接：https://www.cnblogs.com/zhoulf/p/4571647.html

Java单例模式下的MongoDB数据库操作工具类

相关文章

快网idc优惠网

相关文章

微信

快网idc优惠网

QQ交流群