mongodb数据库实体关系 mongodb数据库表

转载

mob64ca1418736f 2024-08-13 16:55:42

文章标签 mongodb数据库实体关系数据库 mongodb 服务器 文章分类 MongoDB 数据库

第七讲
主从复制1.主从复制是一个简单的数据库同步备份的集群技术.
1.1在数据库集群中要明确的知道谁是主服务器,主服务器只有一台.
1.2从服务器要知道自己的数据源也就是对于的主服务是谁.
1.3--master用来确定主服务器,--slave 和 –source 来控制从服务器
1.主从复制集群案例
主8888
       dbpath = D:\sortware\mongod\01\8888 主数据库地址
       port = 8888 主数据库端口号
       bind_ip = 127.0.0.1 主数据库所在服务器
       master = true 确定我是主服务器
从7777
      dbpath = D:\sortware\mongod\01\7777   从数据库地址
      port = 7777 从数据库端口号
      bind_ip = 127.0.0.1 从数据库所在服务器
      source = 127.0.0.1:8888 确定我数据库端口
      slave = true 确定自己是从服务器
2.主从复制的其他设置项
    --only 从节点指定复制某个数据库,默认是复制全部数据库
    --slavedelay 从节点设置主数据库同步数据的延迟(单位是秒)
    --fastsync 从节点以主数据库的节点快照为节点启动从数据库
    --autoresync 从节点如果不同步则重新同步数据库
    --oplogSize 主节点设置oplog的大小(主节点操作记录存储到local的oplog中)
3.利用shell动态添加和删除从节点
    不难看出从节点中关于主节点的信息全部存到local的sources的集合中
    我们只要对集合进行操作就可以动态操作主从关系
    挂接主节点:操作之前只留下从数据库服务
    db.sources.insert({"host":"127.0.0.1:8888"})
    删除已经挂接的主节点:操作之前只留下从数据库服务
    db.sources.remove({"host":"127.0.0.1:8888"})

副本集1.副本集概念
1.1第一张图表明A是活跃的B和C是用于备份的
1.2第二张图当A出现了故障,这时候集群根据权重算法推选出B为活跃的数据库
1.3第三张图当A恢复后他自动又会变为备份数据库
1.副本集概念
A
     dbpath = D:\sortware\mongod\02\A
     port = 1111 #端口
     bind_ip = 127.0.0.1 #服务地址
     replSet = child/127.0.0.1:2222 #设定同伴
B
     dbpath = D:\sortware\mongod\02\B
     port = 2222
     bind_ip = 127.0.0.1
     replSet = child/127.0.0.1:3333
C
     dbpath = D:\sortware\mongod\02\C
     port = 3333
     bind_ip = 127.0.0.1
     replSet = child/127.0.0.1:1111

2.初始化副本集
   use admin
   db.runCommand({"replSetInitiate":
     {
         "_id":'child',
         "members":[{
                "_id":1,
  "host":"127.0.0.1:1111"
       },{
  "_id":2,
  "host":"127.0.0.1:2222"
     },{
  "_id":3,
  "host":"127.0.0.1:3333"
         }]
       }
})
2.查看副本集状态
   rs.status()
2.Shell展示
2.关掉127.0.0.1:2222再查看状态
3.节点和初始化高级参数
    standard 常规节点:参与投票有可能成为活跃节点
    passive 副本节点:参与投票,但是不能成为活跃节点
    arbiter 仲裁节点:只是参与投票不复制节点也不能成为活跃节点
4.高级参数
      Priority 0到1000之间 ,0代表是副本节点 ,1到1000是常规节点
      arbiterOnly : true 仲裁节点
      用法
          members":[{
             "_id":1,
             "host":"127.0.0.1:1111",
             arbiterOnly : true
             }]"
5.优先级相同时候仲裁组建的规则
6.读写分离操作--扩展读
6.1一般情况下作为副本的节点是不能进行数据库读操作的
          但是在读取密集型的系统中读写分离是十分必要的
    6.2设置读写分离
         slaveOkay : true
          很遗憾他在shell中无法演示,这个特性是被写到mongoDB的驱动程序中的,在java和node等其他语言中可以完成
7.Oplog
     他是被存储在本地数据库local中的,他的每一个文档保证这一个节点操作
     如果想故障恢复可以更彻底oplog可已经尽量设置大一些用来保存更多的操作
     信息改变oplog大小
     主库 --master --oplogSize size

第八讲
分片1.插入负载技术分片架构图
2.片键的概念和用处
3.什么时候用到分片呢?
        3.1机器的磁盘空间不足
        3.2单个的mongoDB服务器已经不能满足大量的插入操作
        3.3想通过把大数据放到内存中来提高性能
4.分片步骤
        4.1创建一个配置服务器
        4.2创建路由服务器,并且连接配置服务器
           路由器是调用mongos命令
        4.3添加2个分片数据库8081和8082
        4.5利用路由为集群添加分片(允许本地访问)
   db.runCommand({addshard:"127.0.0.1:8081",allowLocal:true})
   db.runCommand({addshard:"127.0.0.1:8082",allowLocal:true})
                 切记之前不能使用任何数据库语句
        4.6打开数据分片功能,为数据库foobar打开分片功能
                 db.runCommand({"enablesharding":"foobar"})
        4.7对集合进行分片
                 db.runCommand({"shardcollection":"foobar.bar","key":{"_id":1}})
        4.8利用大数据量进行测试 (800000条)
5.查看配置库对于分片服务器的配置存储
                 db.printShardingStatus()
6.查看集群对bar的自动分片机制配置信息
                 mongos> db.shards.find()
                        { "_id" : "shard0000", "host" : "127.0.0.1:8081" }
                        { "_id" : "shard0001", "host" : "127.0.0.1:8082" }
7.保险起见的配置服务器集群
8.分片与副本集一起使用

第九讲

DataBase.java

package com.mongodb.text;

import java.net.UnknownHostException;

import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.util.JSON;

public class DataBase {
	public static void main(String[] args) 
		throws UnknownHostException, MongoException {
		//1.建立一个Mongo的数据库连接对象
		Mongo mg = new Mongo("127.0.0.1:27017");
        //查询所有的Database
        for (String name : mg.getDatabaseNames()) {
            System.out.println("dbName: " + name);
        }
        //2.创建相关数据库的连接
        DB db = mg.getDB("foobar");
        //查询数据库所有的集合
        for (String name : db.getCollectionNames()) {
            System.out.println("collectionName: " + name);
        }
        
        DBCollection users = db.getCollection("persons");
        //查询所有的数据
        DBCursor cur = users.find();
        while (cur.hasNext()) {
        	DBObject object = cur.next();
        	System.out.println(object.get("name"));
        }
        System.out.println(cur.count());
        System.out.println(cur.getCursorId());
        System.out.println(JSON.serialize(cur));
    }
}

MongoDb.java

package com.mongodb.text;

import java.net.UnknownHostException;
import java.util.List;

import org.bson.types.ObjectId;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

public class MongoDb {
	//1.建立一个Mongo的数据库连接对象
	static Mongo connection = null;
	//2.创建相关数据库的连接
	static DB db = null;
	public MongoDb(String dbName) throws UnknownHostException, MongoException{
		connection = new Mongo("127.0.0.1:27017");
		db = connection.getDB(dbName);
	}
	public static void main(String[] args) throws UnknownHostException, MongoException {
		//实例化
		MongoDb mongoDb = new MongoDb("foobar");
	    /**
	     * 1.创建一个名字叫javadb的数据库
	     */
//		mongoDb.createCollection("javadb");
		/**
		 * 2.为集合javadb添加一条数据
		 */
//		DBObject dbs = new BasicDBObject();
//		dbs.put("name", "uspcat.com");
//		dbs.put("age", 2);
//		List<String>  books = new ArrayList<String>();
//		books.add("EXTJS");
//		books.add("MONGODB");
//		dbs.put("books", books);
//		mongoDb.insert(dbs, "javadb");
		/**
		 * 3.批量插入数据
		 */
//		List<DBObject> dbObjects = new ArrayList<DBObject>();
//		DBObject jim = new BasicDBObject("name","jim");
//		DBObject lisi = new BasicDBObject("name","lisi");
//		dbObjects.add(jim);
//		dbObjects.add(lisi);
//		mongoDb.insertBatch(dbObjects, "javadb");
		/**
		 * 4.根据ID删除数据
		 */
//		mongoDb.deleteById("502870dab9c368bf5b151a04", "javadb");
		/**
		 * 5.根据条件删除数据
		 */
//		DBObject lisi = new BasicDBObject();
//		lisi.put("name", "lisi");
//		int count = mongoDb.deleteByDbs(lisi, "javadb");
//		System.out.println("删除数据的条数是: "+count);
		/**
		 * 6.更新操作,为集合增加email属性
		 */
//		DBObject update = new BasicDBObject();
//		update.put("$set", 
//				new BasicDBObject("eamil","uspcat@126.com"));
//		mongoDb.update(new BasicDBObject(),
//				update,false,true,"javadb");
		/**
		 * 7.查询出persons集合中的name和age
		 */
//		DBObject keys = new BasicDBObject();
//		keys.put("_id", false);
//		keys.put("name", true);
//		keys.put("age", true);
//		DBCursor cursor = mongoDb.find(null, keys, "persons");
//	    while (cursor.hasNext()) {
//		    DBObject object = cursor.next();
//		    System.out.println(object.get("name"));
//	    }
	    /**
	     * 7.查询出年龄大于26岁并且英语成绩小于80分
	     */
//		DBObject ref = new BasicDBObject();
//		ref.put("age", new BasicDBObject("$gte",26));
//		ref.put("e", new BasicDBObject("$lte",80));
//		DBCursor cursor = mongoDb.find(ref, null, "persons");
//	    while (cursor.hasNext()) {
//		    DBObject object = cursor.next();
//		    System.out.print(object.get("name")+"-->");
//		    System.out.print(object.get("age")+"-->");
//		    System.out.println(object.get("e"));
//	    }
		/**
		 * 8.分页例子
		 */
		DBCursor cursor = mongoDb.find(null, null, 0, 3, "persons");
	    while (cursor.hasNext()) {
		    DBObject object = cursor.next();
		    System.out.print(object.get("name")+"-->");
		    System.out.print(object.get("age")+"-->");
		    System.out.println(object.get("e"));
	    }		
		//关闭连接对象
		connection.close();
	}
	/**
	 * 创建一个数据库集合
	 * @param collName 集合名称
	 * @param db  数据库实例
	 */
	public void createCollection(String collName){
		DBObject dbs = new BasicDBObject();
		db.createCollection("javadb", dbs);
	}
	/**
	 * 为相应的集合添加数据
	 * @param dbs
	 * @param collName
	 */
	public void insert(DBObject dbs,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		//2.插入操作
		coll.insert(dbs);
	}
	/**
	 * 为集合批量插入数据
	 * @param dbses
	 * @param collName
	 */
	public void insertBatch(List<DBObject> dbses,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		//2.插入操作
		coll.insert(dbses);
	}
	/**
	 * 根据id删除数据
	 * @param id
	 * @param collName
	 * @return 返回影响的数据条数
	 */
	public int deleteById(String id,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		DBObject dbs = new BasicDBObject("_id", new ObjectId(id));
		int count = coll.remove(dbs).getN();
		return count;
	}
	/**
	 * 根据条件删除数据
	 * @param id
	 * @param collName
	 * @return 返回影响的数据条数
	 */	
	public int deleteByDbs(DBObject dbs,String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		int count = coll.remove(dbs).getN();
		return count;
	}
	/**
	 * 更新数据
	 * @param find 查询器
	 * @param update 更新器
	 * @param upsert 更新或插入
	 * @param multi 是否批量更新
	 * @param collName 集合名称
	 * @return 返回影响的数据条数
	 */
	public int update(DBObject find,
						DBObject update,
						boolean upsert,
						boolean multi,
						String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		int count = coll.update(find, update, upsert, multi).getN();
		return count;
	}
	/**
	 * 查询器(分页)
	 * @param ref
	 * @param keys
	 * @param start
	 * @param limit
	 * @return
	 */
	public DBCursor find(DBObject ref, 
			DBObject keys,
			int start,
			int limit,
			String collName){
		DBCursor cur = find(ref, keys, collName);
		return cur.limit(limit).skip(start);
	}
	/**
	 * 查询器(不分页)
	 * @param ref
	 * @param keys
	 * @param start
	 * @param limit
	 * @param collName
	 * @return
	 */
	public DBCursor find(DBObject ref,
			DBObject keys,
			String collName){
		//1.得到集合
		DBCollection coll = db.getCollection(collName);
		DBCursor cur = coll.find(ref, keys);
		return cur;
	}	
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。