怎么样使用mongoDB实现主从读写分离功能？

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=

<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>
  </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>

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

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;
 }
}

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;
 }



}