当前位置：移动技术网 > IT编程>数据库>MongoDB > mongoDB 实现主从读写分离实现的实例代码

mongoDB 实现主从读写分离实现的实例代码

2017年12月08日 | 移动技术网IT编程 | 我要评论

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=

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

web.xml

<context-param>
  <param-name>contextconfiglocation</param-name>
  <param-value>
    /web-inf/classes/mongo_config.xml
  </param-value>
</context-param>

实体层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;
  }
}

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



}

感谢阅读，希望能帮助到大家，谢谢大家对本站的支持！

您可能感兴趣的文章:

如对本文有疑问，点击进行留言回复！！

MongoDB常用数据库命令大全

一、mongodb 数据库常用操作命令1、help查看命令提示helpdb.help();db.yourcoll.help();2、切换/创建数据库use ra... [阅读全文]
28个MongoDB经典面试题详解

mongodb是目前最好的面向文档的免费开源nosql数据库。如果你正准备参加mongodb nosql数据库的技术面试，你最好看看下面的mongodb nos... [阅读全文]
MongoDB 数据库的命名、设计规范详解

mongodb 数据库的命名和设计也有一套规范。只不过，由于用的人不多，目前在业界还没有形成权威的共识，今天根据我个人平时的一些经验，总结了一些规范第一部分，我... [阅读全文]
MongoDB中数据的替换方法实现类Replace()函数功能详解

近日接到一个开发需求，因业务调整，需要dba协助，将mongodb数据库中某集合的进行替换。例如我们需要将集合a中b字段中，有关《美好》的字符替换为《非常美好... [阅读全文]
解决MongoDB占用内存过大频繁死机的方法详解

从mongodb 3.4开始，默认的wiredtiger内部缓存大小是以下两者中的较大者：50％（ram-1 gb），或 256 mb例如，在总共有4gb ra... [阅读全文]
在 Fedora 上安装 MongoDB 服务器的方法教程

mongo（来自 “humongous” —— 巨大的）是一个高性能、开源、无模式的、面向文档的数据库，它是最受欢迎的 nosql 数据库之一。它使用 json... [阅读全文]
mongodb driver使用代码详解

mongodb 是一个基于分布式文件存储的数据库。由 c++ 语言编写。旨在为 web 应用提供可扩展的高性能数据存储解决方案。mongodb 是一个介于关系数... [阅读全文]
MongoDB操作符中的$elemMatch问题

问题如果mongodb 数据库集合中仅存在一条记录{ "_id" : objectid("5e6b4ef546b5f44e5c5b276d"), "name... [阅读全文]
Redis 字符串 SDS

SDS 简单动态字符串。 SDS的结构： struct sdshdr{ int len;//记录BUF数组中已使用字节的数量，等于SDS所八寸字符串的... [阅读全文]
理解Redis持久化，RDB持久化和AOF持久化的不同处理方式

理解和掌握Redis的持久机制，对于Redis的日常开发和运维都有很大帮助，也是在大厂面试经常被问到的知识点。 ... [阅读全文]

网友评论


验证码：

mongoDB 实现主从读写分离实现的实例代码

2017年12月08日 | 移动技术网IT编程 | 我要评论

您可能感兴趣的文章:

相关文章:

网友评论