mongodb 读写分离

主从模式mongoDB官方已经不建议使用了，替代方案是采用副本集的模式， 点击查看。如果您的环境不符合副本集模式可参考本文，来实现主从读写分离。 

resources.properties

mongodb_read.host=10.0.0.45
mongodb_read.port=27017
mongodb_read.apname=ecsp
mongodb_read.username=
mongodb_read.password=

mongodb_write.host=10.0.0.46
mongodb_write.port=27017
mongodb_write.apname=ecsp
mongodb_write.username=
mongodb_write.password=

1
2
3
4
5
6
7
8
9
10
11

mongo_config.xml

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xsi:schemaLocation="http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.0.xsd http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd"> 
<!-- 连接数据库信息 -->
<bean id="propertyConfigurer"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<property name="locations">
<list>
<value>classpath:resources.properties</value>
</list>
</
4000
property>
</bean>
<!-- 读start -->
<bean id="mongoServerReadAddress" class="com.mongodb.ServerAddress">
<constructor-arg value="${mongodb_read.host}"></constructor-arg>
<constructor-arg value="${mongodb_read.port}"></constructor-arg>
</bean>
<bean id="chexunMongoReadOptions" class="com.ecsp.chexun.mongo.ChexunMongoOptions">
<property name="username" value="${mongodb_read.username}" />
<property name="password" value="${mongodb_read.password}" />
<property name="dbname" value="${mongodb_read.apname}" />
<property name="connectionsPerHost" value="100" />
<property name="threadsAllowedToBlockForConnectionMultiplier"
value="5" />
<property name="slaveOk" value="true" />
</bean>
<bean id="mongo_read" class="com.mongodb.Mongo">
<constructor-arg ref="mongoServerReadAddress"></constructor-arg>
<constructor-arg ref="chexunMongoReadOptions"></constructor-arg>
</bean>
<!-- 读end -->

<!-- 写start -->
<bean id="mongoServerWriteAddress" class="com.mongodb.ServerAddress">
<constructor-arg value="${mongodb_write.host}"></constructor-arg>
<constructor-arg value="${mongodb_write.port}"></constructor-arg>
</bean>
<bean id="chexunMongoWriteOptions" class="com.ecsp.chexun.mongo.ChexunMongoOptions">
<property name="username" value="${mongodb_write.username}" />
<property name="password" value="${mongodb_write.password}" />
<property name="dbname" value="${mongodb_write.apname}" />
<property name="connectionsPerHost" value="100" />
<property name="threadsAllowedToBlockForConnectionMultiplier"
value="5" />
</bean>
<bean id="mongo_write" class="com.mongodb.Mongo">
<constructor-arg ref="mongoServerWriteAddress"></constructor-arg>
<constructor-arg ref="chexunMongoWriteOptions"></constructor-arg>
</bean>
<!-- 写end -->

<!-- 链接对象注入start -->
<bean id="mongoHelper" class="com.ecsp.chexun.mongo.MongoHelper">
<constructor-arg ref="mongo_read"></constructor-arg>
<constructor-arg ref="mongo_write"></constructor-arg>
</bean>

<!-- 链接对象注入end -->
</beans>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

web.xml

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/classes/mongo_config.xml
</param-value>
</context-param>

1
2
3
4
5
6

实体层ChexunMongoOptions.java

package com.ecsp.chexun.mongo;

import javax.net.SocketFactory;

import com.mongodb.DBDecoderFactory;
import com.mongodb.MongoOptions;

/**
* Mongo配置类
*
* @author vincent.he
* @version 1.0, Created on 2012-3-12
*
*/
public class ChexunMongoOptions extends MongoOptions{
private String username;
private String password;
private String dbname;

public ChexunMongoOptions(){
super();
}

public void setDescription(String description) {
this.description = description;
}

public void setConnectionsPerHost(int connectionsPerHost) {
this.connectionsPerHost = connectionsPerHost;
}

public void setThreadsAllowedToBlockForConnectionMultiplier(
int threadsAllowedToBlockForConnectionMultiplier) {
this.threadsAllowedToBlockForConnectionMultiplier = threadsAllowedToBlockForConnectionMultiplier;
}

public void setMaxWaitTime(int maxWaitTime) {
this.maxWaitTime = maxWaitTime;
}

public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}

public void setSocketTimeout(int socketTimeout) {
this.socketTimeout = socketTimeout;
}

public void setSocketKeepAlive(boolean socketKeepAlive) {
this.socketKeepAlive = socketKeepAlive;
}

public void setAutoConnectRetry(boolean autoConnectRetry) {
this.autoConnectRetry = autoConnectRetry;
}

public void setMaxAutoConnectRetryTime(long maxAutoConnectRetryTime) {
this.maxAutoConnectRetryTime = maxAutoConnectRetryTime;
}

public void setSlaveOk(boolean slaveOk) {
this.slaveOk = slaveOk;
}

public void setDbDecoderFactory(DBDecoderFactory dbDecoderFactory) {
this.dbDecoderFactory = dbDecoderFactory;
}

public void setSafe(boolean safe) {
this.safe = safe;
}

public void setW(int w) {
this.w = w;
}

public void setWtimeout(int wtimeout) {
this.wtimeout = wtimeout;
}

public void setFsync(boolean fsync) {
this.fsync = fsync;
}

public void setJ(boolean j) {
this.j = j;
}

public void setSocketFactory(SocketFactory socketFactory) {
this.socketFactory = socketFactory;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username = username;
}

public String getPassword() {
return password;
}

public void setPassword(String password) {
this.password = password;
}

public String getDbname() {
return dbname;
}

public void setDbname(String dbname) {
this.dbname = dbname;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

java dao层

package com.ecsp.chexun.mongo;
import java.util.List;

import com.mongodb.BasicDBObject;
import com.mongodb.CommandResult;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBObject;
import com.mongodb.Mongo;

/**
* mongo 操做方法
* @author zhanglibing
*
*/
public class MongoHelper {

private  Mongo mongo;
private  Mongo mongo_read;
private  Mongo mongo_write;
private String dataBaseName = "cxec";
public MongoHelper(){}
public MongoHelper(Mongo mongo,Mongo mongo_read,Mongo mongo_write){
this.mongo = mongo;
this.mongo_read = mongo_read;
this.mongo_write = mongo_write;
}
//  public MongoHelper(String dbName){
//      dataBaseName = dbName;
//  }
public int add(String collectionName,BasicDBObject dbObject){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_write.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.save(dbObject).getN();
}
//批量添加
public int addAll( String collectionName,List<DBObject> list){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_write.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.insert(list).getN();
}

public int isExists(String collectionName,BasicDBObject query){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return  dbc.find(query).size();
}

public List<DBObject>  get(String collectionName,BasicDBObject query){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return  dbc.find(query).toArray();
}

public int  getCount(String collectionName,BasicDBObject query){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return  dbc.find(query).count();
}

public List<DBObject>  get(String collectionName,BasicDBObject query,BasicDBObject keys){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.find(query, keys).toArray();
}

/***
* 获取mongo 中 collection 的值
* @param collectionName
* @param query  查询条件
* @param keys   查询字段
* @param batchSize 返回个数
* @return
*/
public List<DBObject>  get(String collectionName,BasicDBObject query,BasicDBObject keys,BasicDBObject orderBy,int batchSize){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
if(orderBy != null){
return dbc.find(query, keys).sort(orderBy).limit(batchSize).toArray();
}
return dbc.find(query, keys).limit(batchSize).toArray();
}

public List<DBObject>  get(String collectionName,BasicDBObject query,BasicDBObject keys,BasicDBObject orderBy,int batchSize,int n){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
if(orderBy != null){
return dbc.find(query, keys).sort(orderBy).limit(batchSize).skip(n).toArray();
}
return dbc.find(query, keys).limit(batchSize).toArray();
}

public List<DBObject> get(String collectionName,DBObject query,int batchSize){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.find(query).limit(batchSize).toArray();
}
public List<DBObject> get(String collectionName,int number){
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
List<DBObject> dboList = dbc.find().skip(0).limit(number).toArray();
return dboList;
}
public List<DBObject> get(String collectionName,BasicDBObject query,BasicDBObject orderBy,int n,int pageSize ){
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
List<DBObject> dboList = dbc.find(query).sort(orderBy).skip(n).limit(pageSize).toArray();
return dboList;
}
public List<DBObject> get(String collectionName,BasicDBObject query,int top ){
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
List<DBObject> dboList =  dbc.find(query).skip(0).limit(top).toArray();

return dboList;
}
public List<DBObject> get(String collectionName,DBObject query,DBObject orderBy,int batchSize){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_read.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.find(query).sort(orderBy).limit(batchSize).toArray();
}

public int reomve(String collectionName,BasicDBObject  o){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_write.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.remove(o).getN();
}

public int edit(String collectionName,BasicDBObject query,BasicDBObject update){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo_write.getDB(dataBaseName);
DBCollection dbc = db.getCollection(collectionName);
return dbc.update(query, update).getN();
//return dbc.updateMulti(query, update).getN();
}

public int edit(String cmd){
//      DB db = MongoManager.getDB(dataBaseName);
DB db = mongo.getDB(dataBaseName);
CommandResult cmdResult = db.command(cmd);
if(cmdResult.ok())
{
return 1;
}
return 0;
}

//  public DBCollection get(String collectionName){
////        DB db = MongoManager.getDB(dataBaseName);
//      DB db = mongo.getDB(dataBaseName);
//      return db.getCollection(collectionName);
//  }
public void setMongo(Mongo mongo) {
this.mongo = mongo;
}
public void setMongo_read(Mongo mongo_read) {
this.mongo_read = mongo_read;
}
public void setMongo_write(Mongo mongo_write) {
this.mongo_write = mongo_write;
}

}