的使用及仓库储存设计

作者: 数据库信息  发布:2019-11-14

2.Repository继承继口IMongoRepository

 

namespace UnitoonIot.Mongo
{
   public interface IMongoRepository<TEntity> where TEntity : class
    {
    }
}

3.启动mongo-server

简单易行的介绍一下,笔者利用MongoDB的场所。

二、仓库储存设计

3.MongoRepository

using MongoDB.Driver;
using MongoDB.Bson;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Bson.Serialization.Attributes;
using MongoDB.Driver.Linq;
using System.Configuration;
using System.IO;
using UnitoonIot.AppSetting;

namespace UnitoonIot.Mongo
{

    public class MongoDb
    {
        private static  string ConnectionStringHost ;
        private static  string UserName ;
        private static  string Password;
        private static IMongoDatabase _db = null;
        private static readonly object LockHelper = new object();
        /// <summary>
        /// mongodb初始化
        /// </summary>
        public static void Init()
        {
            ConnectionStringHost = "10.1.5.24:27016,10.1.5.24:27016,10.1.5.26:27017";
            //AppSettings.GetConfigValue("MongoHost");//"10.1.5.24:27016";
            UserName = AppSettings.GetConfigValue("MongoUserName");
            Password = AppSettings.GetConfigValue("MongoPwd");
        }
        static MongoDb()
        {

        }
       public static IMongoDatabase GetDb(string dbName,string options=null)
        {

            if (_db != null) return _db;
            lock (LockHelper)
            {

                if (_db != null) return _db;
                var database = dbName;
                var userName = UserName;
                var password = Password;
                var authentication = string.Empty;
                var host = string.Empty;
                if (!string.IsNullOrWhiteSpace(userName))
                {
                    authentication = string.Concat(userName, ':', password, '@');
                }
                if (!string.IsNullOrEmpty(options) && !options.StartsWith("?"))
                {
                    options = string.Concat('?', options);
                }



                host = string.IsNullOrEmpty(ConnectionStringHost) ? "localhost" : ConnectionStringHost;
                database = database ?? "testdb";
                //mongodb://[username:password@]host1[:port1][,host2[:port2],…[,hostN[:portN]]][/[database][?options]]

                var conString = options!=null? $"mongodb://{authentication}{host}/{database}{options}"
                    : $"mongodb://{authentication}{host}/{database}";

                var url = new MongoUrl(conString);
                var mcs = MongoClientSettings.FromUrl(url);
                mcs.MaxConnectionLifeTime = TimeSpan.FromMilliseconds(1000);
                var client = new MongoClient(mcs);

                _db = client.GetDatabase(url.DatabaseName);
            }
            return _db;
        }
    }
    /// <summary>
    /// MongoDb 数据库操作类
    /// </summary>
    public class MongoRepository<T>: IMongoRepository<T> where T :  BaseEntity
    {
        #region readonly field
        /// <summary>
        /// 表名
        /// </summary>
        private readonly IMongoCollection<T> _collection = null;
        /// <summary>
        /// 数据库对象
        /// </summary>
        private readonly IMongoDatabase _database;
        #endregion

        /// <summary>
        /// 构造函数
        /// </summary>
        public MongoRepository()
        {
            this._database = MongoDb.GetDb(Activator.CreateInstance<T>().DbName, "readPreference =secondaryPreferred ");//primaryPreferred/secondaryPreferred/nearest
            _collection = _database.GetCollection<T>(typeof(T).Name);
        }


        #region 增加
        /// <summary>
        /// 插入对象
        /// </summary>
        /// <param name="t">插入的对象</param>
        public virtual T Insert(T t)
        {
           // var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);    
            //t.Time = DateTime.Now;

            _collection.InsertOne(t);
            return t;
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的对象集合</param>
        public virtual IEnumerable<T> InsertBatch(IEnumerable<T> ts)
        {
            _collection.InsertMany(ts);
            return ts;
        }

        /// <summary>
        /// 插入对象
        /// </summary>
        /// <param name="t">插入的对象</param>
        public virtual  void InsertAsync(T t)
        {
            //var flag = ObjectId.GenerateNewId();
           // t.GetType().GetProperty("Id").SetValue(t, flag);
           // t.Time = DateTime.Now;
             _collection.InsertOneAsync(t);
        }
        /// <summary>
        /// 批量插入
        /// </summary>
        /// <param name="ts">要插入的对象集合</param>
        public virtual void InsertBatchAsync(IEnumerable<T> ts)
        {
             _collection.InsertManyAsync(ts);
        }
        #endregion

        #region 删除
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public virtual long Delete(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;          
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <returns></returns>
        public virtual  void DeleteAsync(T t)
        {
            var filter = Builders<T>.Filter.Eq("Id", t.Id);
            _collection.DeleteOneAsync(filter);
        }

        /// <summary>
        /// 按条件表达式删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual long Delete(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteOne(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按条件表达式删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(Expression<Func<T, bool>> predicate)
        {
           _collection.DeleteOneAsync(predicate);
        }


        /// <summary>
        /// 按条件表达式批量删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual long DeleteBatch(Expression<Func<T, bool>> predicate)
        {
            var result = _collection.DeleteMany(predicate);
            return result.DeletedCount;
        }
        /// <summary>
        /// 按条件表达式批量删除
        /// </summary>
        /// <param name="predicate">条件表达式</param>
        /// <returns></returns>
        public virtual  void DeleteBatchAsync(Expression<Func<T, bool>> predicate)
        {
             _collection.DeleteManyAsync(predicate);
        }

        /// <summary>
        /// 按检索条件删除
        /// 建议用Builders<T>构建复杂的查询条件
        /// </summary>
        /// <param name="filter">条件</param>
        /// <returns></returns>
        public virtual long Delete(FilterDefinition<T> filter)
        {
            var result = _collection.DeleteOne(filter);
            return result.DeletedCount;
        }

        /// <summary>
        /// 按检索条件删除
        /// 建议用Builders<T>构建复杂的查询条件
        /// </summary>
        /// <param name="filter">条件</param>
        /// <returns></returns>
        public virtual  void DeleteAsync(FilterDefinition<T> filter)
        {
             _collection.DeleteOneAsync(filter);
        }
        #endregion

        #region 修改
        /// <summary>
        /// 修改(Id不变)
        /// </summary>    
        /// <returns></returns>
        public virtual long Update(T t)
        {         
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id",t.Id);
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 修改(Id不变)
        /// </summary>    
        /// <returns></returns>
        public virtual  void UpdateAsync(T t)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", t.Id);
             _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }


        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(Expression<Func<T, bool>> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }


        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(FilterDefinition<T> filter, T t)
        {
            var update = _collection.ReplaceOne(filter, t, new UpdateOptions() { IsUpsert = true });
            return update.ModifiedCount;
        }
        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(Expression<Func<T, bool>> filter, T t)
        {
            _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }
        /// <summary>
        /// 用新对象替换新文档
        /// </summary>
        /// <param name="filter">查询条件</param>
        /// <param name="t">对象</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(FilterDefinition<T> filter, T t)
        {
              _collection.ReplaceOneAsync(filter, t, new UpdateOptions() { IsUpsert = true });

        }
        /// <summary>
        /// 根据Id和条件文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">对象Id</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return  result.ModifiedCount;
        }
        /// <summary>
        /// 根据Id和条件文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="id">对象Id</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(string id, UpdateDefinition<T> update)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });       
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void Update(UpdateDefinition<T> update,Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long Update(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateOne(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        /// <summary>
        /// 根据条件修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void  UpdateAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
             _collection.UpdateOneAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual long UpdateBatch(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            var result = _collection.UpdateMany(filter, update, new UpdateOptions() { IsUpsert = true });
            return result.ModifiedCount;
        }
        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, Expression<Func<T, bool>> filter)
        {
             _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }

        /// <summary>
        /// 根据条件批量修改文档
        /// </summary>
        /// <param name="update">修改条件-形如:Builders/<T/>.Update.Set(filed, value)</param>
        /// <param name="filter">查询条件Builders/<T/>.Filter.Eq(filed, value)</param>
        /// <returns>修改影响文档数</returns>
        public virtual void UpdateBatchAsync(UpdateDefinition<T> update, FilterDefinition<T> filter)
        {
            _collection.UpdateManyAsync(filter, update, new UpdateOptions() { IsUpsert = true });
        }
        #endregion

        #region 查询 

        #region GetCollection

        /// <summary>
        /// 获取操作对象的IMongoCollection集合,强类型对象集合
        /// </summary>
        /// <returns></returns>
        public virtual IMongoCollection<T> GetCollection()
        {
            return _database.GetCollection<T>(typeof(T).Name);
        }

        #endregion

        #region GetSingle
        /// <summary>
        /// 查询数据库,检查是否存在指定ID的对象
        /// </summary>
        /// <param name="id">对象的ID值</param>
        /// <returns>存在则返回指定的对象,否则返回Null</returns>
        public virtual T GetById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = _collection.Find(filter).FirstOrDefault();
            return data;
        }
        /// <summary>
        /// 查询数据库,检查是否存在指定ID的对象
        /// </summary>
        /// <param name="id">对象的ID值</param>
        /// <returns>存在则返回指定的对象,否则返回Null</returns>
        public virtual async Task<T> GetAsyncById(string id)
        {
            var filterBuilder = Builders<T>.Filter;
            var filter = filterBuilder.Eq("Id", new ObjectId(id));
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual T Get(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual T Get(Expression<Func<T,bool>> filter)
        {
            return _collection.Find(filter).FirstOrDefault();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }
        /// <summary>
        /// 查询数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual async Task<T> GetAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.SingleOrDefaultAsync();
        }


        #endregion

        #region GetMany
        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(FilterDefinition<T> filter)
        {
            return _collection.Find(filter).ToEnumerable();
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">条件表达式</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetMany(Expression<Func<T,bool>> filter)
        {
            //return _collection.AsQueryable().Where(filter).ToList();
            //return _collection.AsQueryable().Where(filter);
            return _collection.Find(filter).ToEnumerable(); //.ToEnumerable(); 
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(FilterDefinition<T> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查询部分数据
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <returns></returns>
        public virtual async Task<IEnumerable<T>> GetManyAsync(Expression<Func<T, bool>> filter)
        {
            var data = await _collection.FindAsync(filter);
            return await data.ToListAsync();
        }

        #endregion

        #region GetAll

        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual IEnumerable<T> GetAll()
        {
            var data = _collection.AsQueryable();
            return data.ToEnumerable();
        }
        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual async Task<IEnumerable<T>> GetAllAsync()
        {
            var data =  _collection.AsQueryable();
            return await data.ToListAsync();
        }

        /// <summary>
        /// 查询所有记录,复杂查询直接用Linq处理(避免全表扫描)
        /// </summary>
        /// <returns>要查询的对象</returns>
        public virtual IQueryable<T> GetAllQueryable()
        {
            return _collection.AsQueryable();
        }

        #endregion

        #region MapReduce
        /// <summary>  
        ///  MapReduce
        /// </summary>     
       /// <returns>返回一个List列表数据</returns>  
        public IEnumerable<T> GetMap(BsonJavaScript map,BsonJavaScript reduce)
        {
            return  _collection.MapReduce<T>(map,reduce).ToList();
        }


        #endregion

        #endregion
    }

}

好了,就介绍到此处。

 

7.品质对照

读写速度:Redis>Mongo>Mssqlserver

可容纳数据量:Mssqlserver~Mongo>Redis

存储数据类型:Mongo>Mssqlserver>Redis

 

Note:内部存储器持续上涨,内部未有内部存款和储蓄器回笼机制,若约束内存,则也许现身查询速度变慢,数据遗失等难题,建议优化查询作用,创建目录

Db.test.ensureIndex({"username":1, "age":-1})

强制释放内部存款和储蓄器命令:db.runCommand({closeAllDatabases:1})

 

1.基类BaseEntity

namespace UnitoonIot.Mongo
{
    /// <summary>
    /// 实体基类,方便生成ObjId
    /// </summary>
    [Serializable]
    [ProtoContract(ImplicitFields = ImplicitFields.AllPublic)]
   //[ProtoInclude(10, typeof(NormalHistory))]
    public class BaseEntity
    {
        //[BsonRepresentation(BsonType.ObjectId)]
        public ObjectId Id { get; set; }

        /// <summary>
        /// 数据库名称
        /// </summary>
        public string DbName { get; set; }

        /// <summary>
        /// 给对象初值
        /// </summary>
        public BaseEntity()
        {
           // this.ObjId = ObjectId.GenerateNewId().ToString();
            //this.Id = ObjectId.NewObjectId().ToString();
        }
    }
}

那边要求小心时间格式,MongoDB私下认可时间格式为国际时间,所以在写入数据时和读取数据时,时间格式要后生可畏律,此例中从不对时间张开特别规管理,由传入的日子格式鲜明。

少年老成、安装配备和配备意况

2.配置Config文件

dbpath=C:/Program Files/MongoDB/Server/3.4/bin/data/db 

logpath=C:/Program Files/MongoDB/Server/3.4/bin/data/log/master.log 

pidfilepath=C:/Program Files/MongoDB/Server/3.4/bin/master.pid 

directoryperdb=true 

logappend=true 

replSet=testrs 

澳门金莎娱乐网站 ,bind_ip=10.1.5.25

port=27016 

oplogSize=10000

noauth = true

 

storageEngine = wiredTiger

wiredTigerCacheSizeGB = 2

syncdelay = 30

wiredTigerCollectionBlockCompressor = snappy

 

以上是亲力亲为的配置参数,其南路线部分依照需求退换, 这里安装的oplogsize大小为10G,依据业务场景进行调治,其它auth权限为null,因为安装权限会大增服务开拓,影响作用,最下边几行是内部存款和储蓄器引擎,能够操纵别本集同步及内部存款和储蓄器限定,制止内部存款和储蓄器败露。

4.加多别本集配置

conf=

{

    "_id" : "testrs",

    "members" : [

        { "_id" : 0,  "host" : "10.1.5.25:27016"  },

        { "_id" : 1,  "host" : "10.1.5.26:27016"  },

        { "_id" : 2,  "host" : "10.1.5.27:27016"  }

    ]

}

 

rs.initiate(conf)

那儿别本集集群配置已经做到,然后在命令行中输入:rs.status(),查看别本集状态,必要查阅同步情形,能够输入指令:db.serverStatus().

6..NET操作mongo

连续几日来装置,请参谋个人封装Unitoon.Mongo代码所示。

笔者们今后的物联网遇到下,有意气风发对数据,采集样本频率为2002条记下/分钟,那样下去一天24*60*贰零零肆=2880000约等于300万条数据,今后一定还有只怕会扩充。在此之前数据库使用的是mssql,对于数据库的下压力比较大,同时又供给确定保证历史查询的响应速度,这种情形下,在单表中数据量大,同时设有读写操作。不得已选用MongoDB来积存数据。如若运用MongoDB,则起码要求三台机械,两台达成读写抽离,后生可畏台作为决策(当然条件不允许也得以不用卡塔 尔(英语:State of Qatar),每台机械的内存暂且配置在16G,公司小,无法,据说,使用那些MongoDB供给机械内部存款和储蓄器最少92G,小编没有申明过,然则吃内部存款和储蓄器是公众以为的,所以内部存款和储蓄器应当要保证,就算有限扶助了,也不必然完全就未有意外发生。大家地点的那些独特的数量是允许一点点的遗失的,那么些只是做深入分析利用的,几个月了,最近尚未现身数量遗失的动静,可能最新版本现已修复了啊,生手使用建议多看下官英特网的注明。上面间接奔入核心:

5.安装别本集可读写

Rs.slaveOk()

1.安装配置mongo-server(V3.4卡塔尔

参考

本条时候不要运转,接着陈设config文件

本文由金沙澳门官网发布于数据库信息,转载请注明出处:的使用及仓库储存设计

关键词: 金沙澳门官网

上一篇:window安装配置,window10轻巧安装MongoDB
下一篇:没有了