Mongo读写分离

   转发自http://blog.chinaunix.net/uid-15795819-id-3075952.html 


Mongo的主从和复制集结构提供良好的读写分离环境,Mongo的java-driver也实现了读写分离的参数,这给程序开发减少了很多工作。现在我们看一下Mongo-Java-Driver读写分离的一些机制。

    MongoJavaDriver的读是通过设置ReadReference参数,顾名思义,读参照,或者读偏好。与之对应的是WriteConcern,字面意思写涉及,就是规定了写的一些参数,比如是否是一致写,对应Mongo中的w,j,fync等参数,我们暂不讨论。在MongoDB 2.0/Java Driver 2.7版本之前,是通过MongoOption的slaveOk参数控制从库的读,在之后的版本已经废弃。
ReadPreference 使用方法:
  1. m.setReadPreference(new ReadPreference().SECONDARY);
    ReadReference是一个类,定义了三种读的参数:Primary、Secondery、Taged,Taged是一个内部类,使用DbObject赋值。这个方便程序自定义读参数,暂不讨论。

我们还是使用复制集连接代码,见 此篇博客

读测试代码:
  1. public static void main(String args[]){
  2.         DB db = m.getDB("test");
  3.         db.authenticate("test", "123".toCharArray());
  4.         while(true){
  5.             DBCollection dbcol = db.getCollection("things");
  6.             System.out.println(dbcol.findOne());
  7.             try {
  8.                 Thread.sleep(500);
  9.             } catch (InterruptedException e) {
  10.                 // TODO Auto-generated catch block
  11.                 e.printStackTrace();
  12.             }
  13.         }
  14.         
  15.     }
每隔0.5秒查询一次数据库,观察mongostat状态。当我们不设置读参数的时候,Mongo只在主库上读,这跟Mongo文档中写的有出入,我们的观察结果页印证了这点,两个从库上都是是没有任何读的。

当我们设置了
  1. m.setReadPreference(new ReadPreference().SECONDARY);
之后,再观察两个从库

已经有读了,也可以看出两个从库是交替读的(并不严格,后面会说),而主库没有任何读。
这是为什么呢,我们来看他的实现机制。
首先从findOne()函数开始,这个函数重载了很多方法,最终都是调用:
  1. public DBObject findOne( DBObject o, DBObject fields, ReadPreference readPref ) {
  2.         Iterator<DBObject> i = __find( o , fields , 0 , -, 0, getOptions(), readPref, getDecoder() );
  3.         DBObject obj = (== null ? null : i.next());
  4.         if ( obj != null && ( fields != null && fields.keySet().size() > 0 ) ){
  5.             obj.markAsPartialObject();
  6.         }
  7.         return obj;
  8.     }
这是最上层返回数据的函数,我们看到_find()方法中已经存在readPref参数了,这个函数是个抽象函数,DBApiLayer类实现了此方法,继续往下走:
  1. Response res = _connector.call( _db , this , query , null , 2, readPref, decoder );
函数中调用了 _connector.call(),这估计就是执行命令的函数了,continue:
  1. if (readPref == null)
  2.             readPref = ReadPreference.PRIMARY;

  3.         if (readPref == ReadPreference.PRIMARY && m.hasOption( Bytes.QUERYOPTION_SLAVEOK ))
  4.            readPref = ReadPreference.SECONDARY;
  5. ...
  6. final DBPort port = mp.get( false , readPref, hostNeeded );
  7. ...
  8. res = port.call( m , coll, readPref, decoder );
  9. ...
我们看到了我们开头讲的参数设置的判断,如果不设置 readPref,那么默认 PRIMARY,由于Bytes . QUERYOPTION_SLAVEOK这个参数已经废弃,而且默认是false,所以其他的情况下就是 SECONDARY了。
程序是通过DBPort这个类去执行Mongo命令的,我们看得到port的 mp.get() 函数:
  1. if ( !(readPref == ReadPreference.PRIMARY) && _rsStatus != null ){
  2.                 // if not a primary read set, try to use a secondary
  3.                 // Do they want a Secondary, or a specific tag set?
  4.                 if (readPref == ReadPreference.SECONDARY) {
  5.                     ServerAddress slave = _rsStatus.getASecondary();
  6.                     if ( slave != null ){
  7.                         return _portHolder.get( slave ).get();
  8.                     }
  9.                 } else if (readPref instanceof ReadPreference.TaggedReadPreference) {
  10.                     // Tag based read
  11.                     ServerAddress secondary = _rsStatus.getASecondary( ( (TaggedReadPreference) readPref ).getTags() );
  12.                     if (secondary != null)
  13.                         return _portHolder.get( secondary ).get();
  14.                     else
  15.                         throw new MongoException( "Could not find any valid secondaries with the supplied tags ('" +
  16.                                                   ( (TaggedReadPreference) readPref ).getTags() + "'");
  17.                 }
  18.             }
  19. ....
  20.             // use master
                DBPort p = _masterPortPool.get();
                if ( keep && _inRequest ) {
                    // if within request, remember port to stick to same server
                    _requestPort = p;
                }
  21. ....
这就比较明了了,通过上一篇文章提到的ReplicaSetStatus类的 getASecondary ( ) 去得到slave
  1. int start = pRandom.nextInt( pNodes.size() );
  2. Node n = pNodes.get( ( start + i ) % nodeCount );
  3. if ( ! n.secondary() ){
            mybad++;
            continue;
    } else if (pTagKey != null && !n.checkTag( pTagKey, pTagValue )){
            mybad++;
            continue;
    }
通过一个random的nextInt选择从库,所以说是随即的,不是Round-Robin,交替读也不是这么严格的,但是基本可以这么认为,不是问题。
至于主库的选择,那个实现的比较复杂,他会去判断是不是读的时候主库已经切换,等等严格的检查。

结语:通过简单的设置ReadPreference就可以实现Mongo的读写分离,这对程序再简单不过了。但是由于Mongo跟Mysql都是通过读日志实现的数据同步,短暂的延迟是必然的,而且Mongo现在的版本是全局锁,主从同步也是个问题,特别是设置了严格同步写入的时候。当然这不是Mongo擅长做的事情,你可以用在商品评论,SNS等不在意数据延迟的应用中,真的很奏效。
相关文章
相关标签/搜索