分布式服务器框架之Servers.Core库中实现 MongoEntityBase 实现阻塞 异步对MongoDB的增删改查

已于 2022-12-29 16:33:00 修改
阅读量286 收藏
点赞数
分类专栏： 轻量服务器框架( .NetCore+MogoDB+Redis 文章标签： mongodb 数据库
于 2022-10-12 22:08:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33531923/article/details/127291751
版权

        YFMongoDBModelBase类是个模板类，对模板参数进行了约束YFMongoEntityBase，必须要继承YFMongoEntityBase

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using MongoDB.Driver;

namespace Servers.Core
{
    // MongoDBModel 基类
    //要继承YFMongoEntityBase
    public abstract class YFMongoDBModelBase<T>
        where T : YFMongoEntityBase, new()
    {
        #region 子类需要实现的属性
        //MongoDB的客户端类(MongoDB是服务器，链接MongoDb的服务器就变成了客户端了)
        protected abstract MongoClient Client
        {
            get;
        }

        //数据库名称
        protected abstract string DatabaseName
        {
            get;
        }

        //集合名称(对应的是Mysql或者是SqlServer中的Table)
        protected abstract string CollectionName
        {
            get;
        }

        //是否记录错误日志（这个一般都要开启的吧？）
        protected virtual bool CanLogError
        {
            get { return false; }
        }
        #endregion


        #region 获取文档集合 GetCollection
        //写了类型之后是会把Mongo中的二进制数据实例化成这个entity类？？
        private IMongoCollection<T> m_Collection = null;

        //获取文档集合(get某个类型的Collection，相当于获取某个类型的Table,不过怎么感觉那么奇怪)
        public IMongoCollection<T> GetCollection()
        {
            try
            {
                if (null == m_Collection)
                {
                    IMongoDatabase database = Client.GetDatabase(DatabaseName);
                    m_Collection = database.GetCollection<T>(CollectionName);
                }
                return m_Collection;
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:log类还没写，后面有了log类之后这里的log打印要补上
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }

        #endregion


        #region GetEntity 根据编号查询实体
        //根据编号查询实体
        public T GetEntity(long YFId)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", YFId);
                return collection.Find(filter).FirstOrDefault();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO：记录错误日志
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }

        //异步根据编号查询实体
        public async Task<T> GetEntityAsync(long YFId)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", YFId);
                return await collection.Find(filter).FirstOrDefaultAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO：记录错误日志
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }

        //根据条件查询实体
        public T GetEntity(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return collection.Find(filter).FirstOrDefault();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }

        
        //异步根据条件查询实体
        public async Task<T> GetEntityAsync(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return await collection.Find(filter).FirstOrDefaultAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return null;
            }
        }

        #endregion

        #region 查询数量

        //查询数量(传进去一个规则策略，寻找符合规则的集合数量)
        public long GetCount(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return collection.CountDocuments(filter);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else 
                {
                    throw e;
                }
                return 0;
            }
        }

        //异步查询数量
        public async Task<long> GetCountAsync(FilterDefinition<T> filter)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                return await collection.CountDocumentsAsync(filter);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
                return 0;
            }
        }

        #endregion

        #region 根据条件查询数据集合
        /// <summary>
        /// 异步根据条件查询数据集合
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <param name="sort">排序</param>
        /// <param name="skip">跳过</param>
        /// <param name="limit">限制数量</param>
        public List<T> GetList(FilterDefinition<T> filter, out long count, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                count = collection.CountDocuments(filter);

                //不指定查询字段???
                if (field == null || field.Length == 0)
                {
                    if (sort == null) 
                        return collection.Find(filter).ToList();
                    
                    //如果有排序规则，进行排序
                    return collection.Find(filter).Sort(sort).ToList();
                }

                //这个的直接翻译叫投影，可以理解成一种投影关系,包含这个名字的（但是不知道include是查找所有的json字符串吗？）
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i=0;i< fieldList.Count;++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(fieldList[i].ToString()));
                }
                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);
                
                //可空类型,不为空就调用Clear
                fieldList?.Clear();

                //没排序规则，就不排序
                if (sort == null)
                    return collection.Find(filter).Project<T>(projection).ToList();
                
                //三重规则??mmp
                return collection.Find(filter).Sort(sort).Project<T>(projection).ToList();
            }
            catch(Exception e) 
            {
                if (CanLogError)
                {
                }
                else 
                {
                    throw e;
                }
                count = 0;
                return null;
            }
        }


        /// <summary>
        /// 异步根据条件查询数据集合
        /// </summary>
        /// <param name="filter">过滤条件</param>
        /// <param name="sort">排序</param>
        /// <param name="skip">跳过</param>
        /// <param name="limit">限制数量</param>
        public async Task<List<T>> GetListAsync(FilterDefinition<T> filter,string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                //count = collection.CountDocuments(filter);

                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return await collection.Find(filter).ToListAsync();
                    
                    //如果有排序规则，进行排序
                    return await collection.Find(filter).Sort(sort).ToListAsync();
                }

                //这个的直接翻译叫投影，可以理解成一种投影关系,包含这个名字的（但是不知道include是查找所有的json字符串吗？）
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < fieldList.Count; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(fieldList[i].ToString()));
                }
                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);

                //可空类型,不为空就调用Clear
                fieldList?.Clear();

                //没排序规则，就不排序
                if (sort == null)
                    return await collection.Find(filter).Project<T>(projection).ToListAsync();

                return await collection.Find(filter).Sort(sort).Project<T>(projection).ToListAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                }
                else
                {
                    throw e;
                }
                //count = 0;
                return null;
            }
        }


        /// <summary>
        /// 查询分页集合
        /// </summary>
        /// <param name="filter">过滤器</param>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">当前页</param>
        /// <param name="count">总数量</param>
        /// <param name="field">字段</param>
        /// <param name="sort">排序</param>
        public List<T> GetListByPage(FilterDefinition<T>filter,int pageSize,int pageIndex,out long count,string[] field=null,SortDefinition<T>sort=null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                count = collection.CountDocuments(filter);

                //不查询指定字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return collection.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                    
                    //如果有排序规则进行排序
                    collection.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }

                //制定查询字段
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));    
                }

                ProjectionDefinition<T> projection  =Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();
                
                //不排序
                if(sort==null)
                    return collection.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                
                //先投影再排序？这样投影出来的不久不会参与排序了嘛？
                return collection.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }

                count = 0;
                return null;
            }
        }

        /// <summary>
        /// 异步查询分页集合
        /// </summary>
        /// <param name="filter">过滤器</param>
        /// <param name="pageSize">每页数量</param>
        /// <param name="pageIndex">当前页</param>
        /// <param name="field">字段</param>
        /// <param name="sort">排序</param>
        public async Task<List<T>> GetListByPageAsync(FilterDefinition<T> filter, int pageSize, int pageIndex, string[] field = null, SortDefinition<T> sort = null)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                //count = collection.CountDocuments(filter);

                //不查询指定字段
                if (field == null || field.Length == 0)
                {
                    if (sort == null)
                        return await collection.Find(filter).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

                    //如果有排序规则进行排序
                    collection.Find(filter).Sort(sort).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToList();
                }

                //制定查询字段
                List<ProjectionDefinition<T>> fieldList = new List<ProjectionDefinition<T>>();
                for (int i = 0; i < field.Length; ++i)
                {
                    fieldList.Add(Builders<T>.Projection.Include(field[i].ToString()));
                }

                ProjectionDefinition<T> projection = Builders<T>.Projection.Combine(fieldList);
                fieldList?.Clear();

                //不排序
                if (sort == null)
                    return await collection.Find(filter).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();

                return await collection.Find(filter).Sort(sort).Project<T>(projection).Skip((pageIndex - 1) * pageSize).Limit(pageSize).ToListAsync();
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }

                //count = 0;
                return null;
            }
        }
        #endregion

        #region Add添加实体
        //添加实体
        public void Add(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                collection.InsertOne(entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {

                }
                else
                {
                    throw e;
                }
            }
        }

        //异步添加实体
        public async Task AddAsync(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                await collection.InsertOneAsync(entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {

                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion

        #region AddMany 添加多个实体
        //添加多个实体
        public void AddMany(List<T> lst)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                collection.InsertMany(lst);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:   
                }
                else
                {
                    throw e;
                }
            }
        }

        //异步添加多个实体
        public async Task AddManyAsync(List<T> lst)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                await collection.InsertManyAsync(lst);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:   
                }
                else
                {
                    throw e;
                }
            }
        }

        #endregion

        #region Update 修改实体
        //修改实体
        public void Update(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", entity.YFId);
                collection.FindOneAndReplace(filter,entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }

        //异步修改实体
        public async Task UpdateAsync(T entity)
        {
            try
            {
                IMongoCollection<T> collection = GetCollection();
                FilterDefinition<T> filter = Builders<T>.Filter.Eq("YFId", entity.YFId);
                await collection.FindOneAndReplaceAsync(filter, entity);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion


        #region 删除实体
        //删除实体
        public void Delete(long YFId)
        {
            try
            {
                T entity = GetEntity(YFId);
                if (null != entity)
                {
                    entity.Status = DataStatus.Delete;
                    Update(entity);
                }
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }

        //异步删除实体
        public async Task DeleteAsync(long YFId)
        {
            try
            {
                T entity = await GetEntityAsync(YFId);
                if (null != entity)
                {
                    entity.Status = DataStatus.Delete;
                    await UpdateAsync(entity);
                }
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO:
                }
                else
                {
                    throw e;
                }
            }
        }
        #endregion

        #region 删除所有文档
        public void DeletaAll()
        {
            try
            {
                //删库跑路了？？drop这个table
                IMongoDatabase database = Client.GetDatabase(DatabaseName);
                database.DropCollection(CollectionName);
                //drop了为啥还要再create一下？为了完全覆盖内存吗？？？
                database.CreateCollection(CollectionName);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO
                }
                else 
                {
                    throw e;
                }
            }
        }
        
        public async Task DeletaAllAsync()
        {
            try
            {
                
                IMongoDatabase database = Client.GetDatabase(DatabaseName);
                await database.DropCollectionAsync(CollectionName);
                await database.CreateCollectionAsync(CollectionName);
            }
            catch (Exception e)
            {
                if (CanLogError)
                {
                    //TODO
                }
                else
                {
                    throw e;
                }
            }
        }

        #endregion

    }
}

天才小熊猫oo
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mongodb C driver的异步查询
Final小屋
04-02 4821
  最近在选用NOSQL数据库的时候最终选择了mongdb, 感觉其各方面都很优秀, 于是为服务器增加了一组mongodb的接口, 以方便LUA逻辑层使用.  驱动方面选用了官方指定的C DRIVER, 大家有兴趣的可以直接去mongodb的官网上查找, 不过查看了其mongo_find接口发现为同步调用, 这在服务器并发应用方面会受到限制, 通常服务器为了提高并发处理效率会使用异步接口. 开始的时候比较偷懒, 在其官网上留言想让其driver开发人员帮忙添加异步调用接口, 这事情也就先放下了... 2天过
mongodb 异步查询(续)
Final小屋
04-08 5742
  承接前一篇, 服务器采用C编写, 逻辑层使用LUA, 搭配开源mongodb c driver开发异步查询接口.  有了上一次的改造, 这次来说说是如何使用改造后的接口实现异步查询.  首先, 再来理清一下思路, 现在的一次完整同步查询被拆分成3个步骤:  1.创建并发送请求  2.接受返回结果消息头  3.接受返回结果数据并做相应的回调处理   为此我们需要2个结构来处理这个过程:   typedef struct { int type; mongo
mongodb 建索引导致数据库阻塞
zhuchunyan_aijia的博客
10-17 5937
在MongoDB上建索引可能会对MongoDB集群对可用性产生负面影响。在生产服务上，如果针对一个大集合触发建立索引，且在前台运行，你可能会发现，在索引建完之前，整个集群都无影响。在一个大集合上，这个过程可能会持续几个小时，甚至几天。 解决的方法很简单，MongoDB 提供了两种建索引的访问，一种是 background 方式，不需要长时间占用写锁，另一种是非 background 方式，需要长...
MongoDB连接失败阻塞过久：MongoDB接口详解
勤学如春起之苗，不见其增，日有所长！ 辍学如磨刀之石，不见其损，日有所亏！
04-09 1046
MongoDB连接失败阻塞过久：MongoDB接口详解 执行启动操作后，mongodb 在输出一些必要信息后不会输出任何信息，之后就等待连接的建立，当连接被建立后，就会开始打印日志信息。 标准 URI 连接语法： mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database][?options]] mongodb:// 这是固定的格式，必须要指定。 username:password
mongoDB 常见三种异常解析 （附配置）
热门推荐
wuhulala的休息室
07-18 2万+
配置 mongoDB配置 &lt;mongo:mongo-client id="mongoClient" host="${mongo.host}" port="${mongo.port}" credentials="${mongo.user}:${mongo.pwd}@${mongo.defaultDbName}"&gt; &lt;mongo:client-options ...
express+mongoose实现对mongodb增删改查操作详解
09-08
主要介绍了express+mongoose实现对mongodb增删改查操作,结合实例形式分析了express+mongoose对mongodb增删改查操作基本实现方法与操作注意事项,需要的朋友可以参考下
Node.js对MongoDB进行增删改查操作的实例代码
10-17
主要介绍了Node.js对MongoDB进行增删改查操作 ,需要的朋友可以参考下
java连接Mongodb实现增删改查
08-24
主要为大家详细介绍了java连接Mongodb实现增删改查，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
mongodb+php实现简单的增删改查
09-10
主要介绍了mongodb+php实现简单的增删改查的相关资料,需要的朋友可以参考下
预约挂号医院管理项目----Model模块—实体类
https://juejin.cn/user/4248168663101239/posts
06-13 589
Model实体类模块一. Model实体类模块①. 枚举类②. model实体类③. Vo实体类 一. Model实体类模块 ①. 枚举类 比如 ：订单状态枚举类 package com.xizi.yygh.enums; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; public enum OrderStatusEnum { UNPAI
直播课堂系统03-model类及实体
z754916067的博客
07-21 337
JsonFormat用来表示json序列化的一种格式或者类型，比如存储在mysql中的数据是date类型的，当读取出来封装在实体类中的时候，就会变成英文时间格式，而不是yyyy-MM-ddHHmmss这样的中文时间，因此需要用到JsonFormat注解来格式化时间。这个原项目放在base里了，可是我寻思它是继承的baseEntity的，于是单独提出来了，没看懂这个实体是做什么的，它指的表也没找到，先放这吧。@ApiModel是作用在接口相关实体类上的注解，用来对该接口相关实体类添加额外的描述信息。...
Mongodb 数据库查询语句 条件查询
weixin_45633407的博客
03-15 1120
ongodb 数据库查询语句 条件查询
mongodb 后台创建索引避免阻塞
weixin_34310369的博客
07-27 1163
2019独角兽企业重金招聘Python工程师标准>>> ...
mongodb调优那些事（四）-遇到的坑
zxmsdyz的专栏
03-20 9059
如果是一个mongo初学者，如果没有仔细看过官方文档在使用mongo的时候会遇到不少问题。这里总结下这段时间使用mongo的心得，列出了几个需要注意的地方。1. 系统参数及mongo参数设置 系统参数就第一章已经讲过，mongo参数主要是storageEngine和directoryperdb，这两个参数一开始不选定后续就无法再更改。directoryperdb主要是将数据库分文件夹存放，方便后
MongoDB 并发机制
xiewen99的专栏
09-21 8561
MongoDB 并发机制
springboot整合mongodb，使用BaseEntityMongo，继承MongoRepository，出现找不到bean
月光秦城
07-01 2340
Description: Field businessLogRecordDao in com.etc.service.impl.BusinessLogRecordServiceImpl required a bean of type 'com.etc.mapper.BusinessLogRecordMapper' that could not be found. The injection p...
mongodb的简单操作以及统计查询详细使用步骤
qq_29751083的博客
12-06 4462
1.首先pom文件引入mongodb的依赖 <!--引入mongodb--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-mongodb</artifactId> </dependency> 2.application.properties配置mon..
mongoTemplate.getCollection方法返回值问题
哈尔的移动城堡
12-22 1万+
今天参考网上MongoDB的例子（https://www.cnblogs.com/wenbronk/p/6385935.html）写了个demo,发现MongoTemplate的getCollection方法返回值和例子上的不一样，就在想是不是版本的问题，然后就去翻了官方的API文档，发现这个方法，在1.9.x的时候还是com.mongodb.DBCollection类型，2.0以后就改成了com
MongoDB复制集虚拟机实现增删改查
最新发布
05-19
实现MongoDB复制集虚拟机的增删改查操作可以分为以下步骤： 1. 在虚拟机中安装MongoDB，并创建一个复制集。可以使用rs.initiate()命令来初始化复制集，例如： ``` rs.initiate( { _id: "myRepSet", members: [ ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值