加入收藏 | 设为首页 | 会员中心 | 我要投稿 银川站长网 (https://www.0951zz.com/)- 云通信、基础存储、云上网络、机器学习、视觉智能!
当前位置: 首页 > 服务器 > 系统 > 正文

MongoDB主从读写分离如何达成 过程是怎样

发布时间:2023-09-13 13:40:48 所属栏目:系统 来源:
导读:今天就跟大家聊聊有关“MongoDB主从读写分离如何实现,过程是怎样”的内容,可能很多人都不太了解,为了让大家认识和更进一步的了解,小编给大家总结了以下内容,希望这篇“MongoDB主从读写分离如何实

今天就跟大家聊聊有关“MongoDB主从读写分离如何实现,过程是怎样”的内容,可能很多人都不太了解,为了让大家认识和更进一步的了解,小编给大家总结了以下内容,希望这篇“MongoDB主从读写分离如何实现,过程是怎样”文章能对大家有帮助。

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主从读写分离如何实现,过程是怎样内容,欢迎关注群英网络技术资讯频道,小编将为大家输出更多高质量的实用文章!

(编辑:银川站长网)

【声明】本站内容均来自网络,其相关言论仅代表作者个人观点,不代表本站立场。若无意侵犯到您的权利,请及时与联系站长删除相关内容!

    推荐文章