【Mongodb教程第十六课】分享NO-SQL开发实战

时间 2019-12-11

标签 mongodb 教程第十六分享 sql 开发实战栏目 MongoDB 繁體版

原文原文链接

最近研究了一下NOSQL，现整理目录以下：程序员

1、关系数据库的瓶颈；web

2、NOSQL概述；sql

3、NOSQL中的热门数据库MongoDB介绍及安装配置；mongodb

4、MongoDB开发模式及实战；数据库

1、关系数据库的瓶颈

从90年代到至今，关系数据库扮演了最重要的角色，它的性能，可扩展性、稳定性、数据的备份和恢复机制等都很是好，关系数据库发展到如今已经很是成熟，它提供给使用者的是一整套体系，包括数据存储、数据备份恢复、数据加解密、应用开发驱动、图形化配置维护工具、安全策略等等。图1中展现了世界上各类数据库的使用比例，从这个图上咱们明显看得出它的霸主地位。windows

图1：各类数据库的使用比例数组

不过随着信息技术的快速发展，Web发展也从Web1.0发展到了Web2.0时代，网站开始快速发展，博客、电子商务、微博、社区等Web应用已经引领了时代潮流，它们的网络流量很是巨大，为了解决这个问题，不少IT公司都采起了一系列优化措施，主要优化措施以下：缓存

一、Cache+SQL;安全

为了提升网站的性能，咱们常常会把一些读取访问频率比较高，更新频率低的数据存储在内存中，一方面能够提升用户的体验，另一方面能够减轻数据库的访问压力；服务器

2 、读写分离；

还有一种好的方式就是读写分离，例如咱们能够把内网应用系统产生的数据对称的发布到互联网的数据库中，这样互联网应用的访问都是从外网数据库中读取，内网数据库大部分都是增、删、改等操做，这样也能大幅度提升应用的性能；

三、分表分库；

随着Web2.0的高速发展，在Cache+SQL、数据库主从复制读写分离的优化的情形下，关系数据库主库的写压力出现瓶颈，数据量的持续猛增，访问的高并发状况之下，关系数据库会出现严重的锁问题，这时开始流行分表分库的方式来缓解写压力和数据增加的扩展问题，很早以前我作的一个应用系统，就出现了这个需求，随着数据量的沉淀，数据库变得很是庞大，数据库和日志文件达到了10几个G，有些表里面有上千万条数据，用户在使用过程当中，进行操做时常常会卡住，有时候一等就是几秒或几十秒，客户很是不满意，后来咱们讨论以后就采起了数据库方面，一年一个库进行分库，某些数据量大的表采用拆分，例如一个月产生一个表，还有把一个表中的字段拆分到多个表中等；

经过以上优化咱们系统的性能会提升很大一块，每秒查询率方面能够达到：几百qps到几千qps不等，数据库大小能够达到1T左右，不过随着访问量和数据量的加大，关系数据库很难继续高效率的担当，采用分表分库能够在必定程度上下降这个瓶颈，不过它下降了应用的可扩展性，带来了巨大的技术和开发成本，例如一个需求的变动，可能就会致使一种新的分库分表方式。

关系数据库中基本上都会存储一些大文本和附件信息，致使数据库很是的大，在作数据库恢复的时候就会很是的慢，例如1000万3KB的大文本就接近30G的大小、100万200K的附件就是200G，若是能把这些大文本和大附件从关系数据库中省去，咱们的关系数据库将会变得很小从而很容易优化。

综上，关系数据库很强大，可是它并不能很好的应付全部的应用场景。关系数据库的扩展性差（须要复杂的技术来实现），大数据下IO压力大，表结构更改困难，正是当前使用关系数据库的开发人员面临的问题。

2、NOSQL概述

一、什么是NOSQL?

随着web2.0的快速发展，非关系型、分布式数据存储获得了快速的发展，它们不保证关系数据的ACID特性。NoSQL概念在2009年被提了出来。NoSQL最多见的解释是“non-relational”，“Not Only SQL”也被不少人接受。（“NoSQL”一词最先于1998年被用于一个轻量级的关系数据库的名字。）

NoSQL被咱们用得最多的当数key-value存储，固然还有其余的文档型的、列存储、图型数据库、xml数据库等，见图2。在NoSQL概念提出以前，这些数据库就被用于各类系统当中，可是却不多用于web互联网应用。

图2：非关系数据库种类

二、NOSQL的发展情况如何？

目前NOSQL至关火爆，微博、电子商务、博客、社区、论坛等大数据量高并发的互联网应用中基本都用到了它，大的IT巨头们都在各自的互联网架构中加入了NOSQL解决方案，甚至拥有本身的NOSQL产品，各类NOSQL产品百花齐放，如图3，在2010年以后NOSQL达到井喷之势，其中mongoDb发展势头最猛也最火热。

图3：NOSQL发展趋势

三、NOSQL和关系数据库的关系？

我以为关系数据库和NOSQL是一种相辅相成紧密结合的关系，咱们须要根据具体的应用场景来选择对应数据库，若是你的应用的数据量很小，那么关系数据库就足够了，并且性能、效率、稳定性、安全都是有保证的；若是你的应用场景中涉及超大的数据量（包含大文本、多附件），例如量级在几百G或T级，那么能够考虑用关系数据库和NOSQL结合的方式来解决，关系数据库存储相应的关系数据，NOSQL数据库存储像大文本、对象、附件等类型数据，这样是一种最优的解决方案；

3、NOSQL中MongoDB介绍及安装配置

一、概念

MongoDB是一个高性能，开源，无模式的文档型数据库，是当前NoSql数据库中比较热门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式。Mongo使用C++开发，理解方面可参考图3：

图3：mongDB内部组成

Mongo的官方网站地址是： http://www.mongodb.org /；

这里给你们推荐一本MongoDB入门的书籍《MongoDB权威指南》，这个有中文版本。

二、特性

面向集合存储，易存储对象类型的数据。

模式自由。

支持动态查询。

支持彻底索引，包含内部对象。

支持查询。

支持复制和故障恢复。

使用高效的二进制数据存储，包括大型对象（如视频等）。

自动处理碎片，以支持云计算层次的扩展性 .

支持Python，PHP，Java，C#，Javascript等语言的驱动程序.

文件存储格式为BSON（一种JSON的扩展）。

可经过网络访问。

三、功能

面向集合的存储：适合存储对象及JSON形式的数据。

动态查询：Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。

完整的索引支持：包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式，并生成一个高效的查询计划。

查询监视：Mongo包含一个监视工具用于分析数据库操做的性能。

复制及自动故障转移：Mongo数据库支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的主要目标是提供冗余及自动故障转移。

高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）

自动分片以支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额外的机器

四、使用场景

网站数据：Mongo很是适合实时的插入，更新与查询，并具有网站实时数据存储所需的复制及高度伸缩性。

缓存：因为性能很高，Mongo也适合做为信息基础设施的缓存层。在系统重启以后，由Mongo搭建的持久化缓存层能够避免下层的数据源过载。

大尺寸，低价值的数据：使用传统的关系型数据库存储一些数据时可能会比较昂贵，在此以前，不少时候程序员每每会选择传统的文件进行存储。

高伸缩性的场景：Mongo很是适合由数十或数百台服务器组成的数据库。Mongo的路线图中已经包含对MapReduce引擎的内置支持。

用于对象及JSON数据的存储：Mongo的BSON数据格式很是适合文档化格式的存储及查询。

五、安装过程

第一步：下载安装包：官方下载地址←单击此处,若是是win系统，注意是64位仍是32位版本的，请选择正确的版本。

第二步：新建目录“D:\MongoDB”，解压下载到的安装包，找到bin目录下面所有.exe文件，拷贝到刚建立的目录下。

第三步：在“D:\MongoDB”目录下新建“data”文件夹，它将会做为数据存放的根文件夹。

　　配置Mongo服务端：

　　打开CMD窗口，按照以下方式输入命令：
　　> d:
　　> cd D:\MongoDB
　　> mongod --dbpath D:\MongoDB\data

　　配置成功后会看到以下图4：

图4：启动成功界面

第四步：安装为windows服务

mongod --install --serviceName MongoDB --serviceDisplayName MongoDB --logpath D:\MongoDB\log\MongoDB.log --dbpath D:\MongoDB\data --directoryperdb，执行成功以后在windows服务中能够看到名称为MongoDB的服务，开启就能够了，这样能避免exe CMD命令框的烦恼；

4、MongoDB开发模式及实战

一、开发模式

对于MongoDB的开发模式，咱们能够采用相似高速服务框架HSF的模式进行架构，见图5，首先在基础构件层中咱们把MongoDB的驱动封装到基类库Inspur.Finix.DAL中，

而后在领域层采用小三层架构模式调用基础构件层的数据服务，展示层在经过AJAX+JSON+Filter方式经过服务的形式调用业务层，展示层就能够很好的利用返回的JSON串实现页面的功能。

图5：开发模式

二、开发实战

C#驱动有不少种比较经常使用的是官方驱动和samus驱动。samus驱动除了支持通常形式的操做以外，还支持linq方式操纵数据

（1）基础构件层封装咱们采用samus驱动进行封装，代码以下：

 public class MongoDBAccess : IDisposable
    {
        /// <summary>
        /// 数据库别名
        /// </summary>
        private string _dataBaseAlias = "Noah.MongoDB";
        /// <summary>
        /// 集合名
        /// </summary>
        public string _collectionName { get; set; }
        // 定义mongo服务
        private Mongo _mongo = null;
        // 获取databaseName对应的数据库，不存在则自动建立
        private IMongoDatabase _mongoDatabase = null;
        public MongoCollection<Document> MongoCollection;
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dataBaseAlias"></param>
        /// <param name="collectionName"></param>
        public MongoDBAccess(string dataBaseAlias, string collectionName)
        {
            _dataBaseAlias = dataBaseAlias;
            _collectionName = collectionName;
            init();
        }
        /// <summary>
        /// 初始化
        /// </summary>
        private void init()
        {
            DatabaseConfigManager dcm = DatabaseConfigManager.Create();
            // 根据别名获得链接串
            string connStr = dcm.GetPrimaryConnection(_dataBaseAlias);
            // 把conn进行拆分
            StringTokenizer st = new StringTokenizer(connStr, ";");
            string conn = st.GetValueByIndex(0);
            // 定义mongo服务
            _mongo = new Mongo(conn);
            _mongo.Connect();
            st = new StringTokenizer(st.GetValueByIndex(1), "=");
            string databaseName = st.GetValueByIndex(1);
            // 获取databaseName对应的数据库，不存在则自动建立
            if (string.IsNullOrEmpty(databaseName) == false)
                _mongoDatabase = _mongo.GetDatabase(databaseName);
            //获取collectionName对应的集合，不存在则自动建立
            MongoCollection = _mongoDatabase.GetCollection<Document>(_collectionName) as MongoCollection<Document>;

        }

        /// <summary>
        /// 切换到指定的数据库
        /// </summary>
        /// <param name="dbName"></param>
        /// <returns></returns>
        public IMongoDatabase UseDb(string dbName)
        {
            if (string.IsNullOrEmpty(dbName))
                throw new ArgumentNullException("dbName");

            _mongoDatabase = _mongo.GetDatabase(dbName);
            return _mongoDatabase;
        }

        /// <summary>
        /// 获取当前链接的数据库
        /// </summary>
        public IMongoDatabase CurrentDb
        {
            get
            {
                if (_mongoDatabase == null)
                    throw new Exception("当前链接没有指定任何数据库。请在构造函数中指定数据库名或者调用UseDb()方法切换数据库。");

                return _mongoDatabase;
            }
        }

        /// <summary>
        /// 获取当前链接数据库的指定集合【依据类型】
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public IMongoCollection<T> GetCollection<T>() where T : class
        {
            return this.CurrentDb.GetCollection<T>();
        }

        /// <summary>
        /// 获取当前链接数据库的指定集合【根据指定名称】
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="name">集合名称</param>
        /// <returns></returns>
        public IMongoCollection<T> GetCollection<T>(string name) where T : class
        {
            return this.CurrentDb.GetCollection<T>(name);
        }
        /// <summary>
        /// 使用GridFS保存附件
        /// </summary>
        /// <param name="byteFile"></param>
        /// <returns></returns>
        public string GridFsSave(byte[] byteFile)
        {
            string filename = Guid.NewGuid().ToString();
            //这里GridFile构造函数有个重载，bucket参数就是用来替换那个建立集合名中默认的"fs"的。    
            GridFile gridFile = new GridFile(_mongoDatabase);
            using (GridFileStream gridFileStream = gridFile.Create(filename))
            {
                gridFileStream.Write(byteFile, 0, byteFile.Length);
            }
            return filename;
        }
        /// <summary>
        /// 读取GridFs附件
        /// </summary>
        /// <param name="filename"></param>
        /// <returns></returns>
        public byte[] GridFsRead(string filename)
        {
            GridFile gridFile = new GridFile(_mongoDatabase);
            byte[] bytes;
            using (GridFileStream gridFileStream = gridFile.OpenRead(filename))
            {
                bytes = new byte[gridFileStream.Length];
                gridFileStream.Read(bytes, 0, bytes.Length);
            }
            return bytes;
        }
        public void GridFsDelete(string filename)
        {
            GridFile gridFile = new GridFile(_mongoDatabase);
            gridFile.Delete(new Document("filename", filename));
        }
        /// <summary>
        /// 资源释放
        /// </summary>
        public void Dispose()
        {
            if (_mongo != null)
            {
                _mongo.Dispose();
                _mongo = null;
            }

        }
    }

（2）领域层部分代码

public class KNOWLEDGE_SOCKDAL
    {
        public KNOWLEDGE_SOCKDAL()
        {
        }
        /// <summary>
        /// 保存一个对象
        /// </summary>
        /// <param name="model"></param>
        public void Add(KNOWLEDGE_SOCK model)
        {
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    mm.GetCollection<KNOWLEDGE_SOCK>().Insert(model);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
        }
        /// <summary>
        /// 保存附件
        /// </summary>
        /// <param name="file"></param>
        /// <returns></returns>
        public string  SaveAttach(byte[] file)
        {
            string fileName = string.Empty;
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    fileName = mm.GridFsSave(file);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return fileName;
        }
        /// <summary>
        /// 读取附件
        /// </summary>
        /// <param name="fileName"></param>
        /// <returns></returns>
        public byte[] ReadAttach(string fileName)
        {
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    mm.GetCollection<KNOWLEDGE_SOCK>();
                    return  mm.GridFsRead(fileName);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return null;
        }
        /// <summary>
        /// 删除附件
        /// </summary>
        /// <param name="fileName"></param>
        public void DeleteAttach(string fileName)
        {
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    mm.GetCollection<KNOWLEDGE_SOCK>();
                    mm.GridFsDelete(fileName);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
        }
        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="model"></param>
        public void Update(KNOWLEDGE_SOCK model)
        {
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    var query = new Document("Know_Code", model.Know_Code);
                    mm.GetCollection<KNOWLEDGE_SOCK>().Update(model, query);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        public void Delete(string id)
        {
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    var query = new Document("Know_Code", id);
                    mm.GetCollection<KNOWLEDGE_SOCK>().Remove(query);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
        }
        /// <summary>
        /// 查询特定一条
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public KNOWLEDGE_SOCK FindOne(string id)
        {
            KNOWLEDGE_SOCK catalog = new KNOWLEDGE_SOCK();
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    var query = new Document("Know_Code", id);
                    catalog = mm.GetCollection<KNOWLEDGE_SOCK>().FindOne(query);
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return catalog;
        }
        /// <summary>
        /// 根据条件查询
        /// </summary>
        /// <param name="js"></param>
        /// <returns></returns>
        public List<KNOWLEDGE_SOCK> Find(string js)
        {
            List<KNOWLEDGE_SOCK> catalogs = new List<KNOWLEDGE_SOCK>();
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    string jsStr = @" 
                    function(){ 
                        return " + js + ";}";
                    catalogs = mm.GetCollection<KNOWLEDGE_SOCK>().Find(Op.Where(jsStr)).Documents.ToList();
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return catalogs;
        }
        /// <summary>
        /// 查询所有
        /// </summary>
        /// <returns></returns>
        public List<KNOWLEDGE_SOCK> FindAll()
        {
            List<KNOWLEDGE_SOCK> catalogs = new List<KNOWLEDGE_SOCK>();
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    catalogs = mm.GetCollection<KNOWLEDGE_SOCK>().FindAll().Documents.ToList();
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return catalogs;
        }
        /// <summary>
        /// 返回数量
        /// </summary>
        /// <param name="js"></param>
        /// <returns></returns>
        public int GetCount(string js)
        {
            int count = 0;
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    string jsStr = @" 
                    function(){ 
                        return " + js + ";}";
                    count = mm.GetCollection<KNOWLEDGE_SOCK>().Find(Op.Where(jsStr)).Documents.Count();
                }

            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return count;
        }
        public List<KNOWLEDGE_SOCK> Find(string js, int pageSize, int pageIndex)
        {
            List<KNOWLEDGE_SOCK> list = new List<KNOWLEDGE_SOCK>();
            try
            {
                using (MongoDBAccess mm = new MongoDBAccess(cConfig.Noah_MongoDB, ""))
                {
                    string jsStr = @" 
                    function(){ 
                        return " + js + ";}";
                    list = mm.GetCollection<KNOWLEDGE_SOCK>().Find(Op.Where(jsStr)).Documents.OrderBy(x=>x.Know_CreateTime).Skip(pageSize * (pageIndex-1)).Take(pageSize).ToList();
                }
            }
            catch (Exception ex)
            {
                ExceptionManager.Handle(ex);
            }
            return list;
        }
    }

【Mongodb教程 第十六课 】 分享NO-SQL开发实战

1、关系数据库的瓶颈

2、NOSQL概述

3、NOSQL中MongoDB介绍及安装配置

4、MongoDB开发模式及实战

【Mongodb教程第十六课】分享NO-SQL开发实战