用过 mongodb 吧, 这三个大坑踩过吗?_慕课手记

mikel阅读(722)

来源: 用过 mongodb 吧, 这三个大坑踩过吗?_慕课手记

一:背景

1. 讲故事

前段时间有位朋友在微信群问,在向 mongodb 中插入的时间为啥取出来的时候少了 8 个小时,8 在时间处理上是一个非常敏感的数字,又吉利又是一个普适的话题,后来我想想初次使用 mongodb 的朋友一定还会遇到各种新坑,比如说: 插入的数据取不出来,看不爽的 ObjectID,时区不对等等,这篇就和大家一起聊一聊。

二: 1号坑 插进去的数据取不出来

1. 案例展示

这个问题是使用强类型操作 mongodb 你一定会遇到的问题,案例代码如下:


    class Program
    {
        static void Main(string[] args)
        {
            var client = new MongoClient("mongodb://192.168.1.128:27017");
            var database = client.GetDatabase("school");
            var table = database.GetCollection<Student>("student");

            table.InsertOne(new Student() { StudentName = "hxc", Created = DateTime.Now });

            var query = table.AsQueryable().ToList();

        }
    }

    public class Student
    {
        public string StudentName { get; set; }

        public DateTime Created { get; set; }
    }

我去,这么简单的一个操作还报错,要初学到放弃吗? 挺急的,在线等!

2. 堆栈中深挖源码

作为一个码农还得有钻研代码的能力,从错误信息中看说有一个 _id 不匹配 student 中的任何一个字段,然后把全部堆栈找出来。


System.FormatException
  HResult=0x80131537
  Message=Element '_id' does not match any field or property of class Newtonsoft.Test.Student.
  Source=MongoDB.Driver
  StackTrace:
   at MongoDB.Driver.Linq.MongoQueryProviderImpl`1.Execute(Expression expression)
   at MongoDB.Driver.Linq.MongoQueryableImpl`2.GetEnumerator()
   at System.Collections.Generic.List`1..ctor(IEnumerable`1 collection)
   at System.Linq.Enumerable.ToList[TSource](IEnumerable`1 source)
   at Newtonsoft.Test.Program.Main(String[] args) in E:\crm\JsonNet\Newtonsoft.Test\Program.cs:line 32

接下来就用 dnspy 去定位一下 MongoQueryProviderImpl.Execute 到底干的啥,截图如下:

我去,这代码硬核哈,用了 LambdaExpression 表达式树,我们知道表达式树用于将一个领域的查询结构转换为另一个领域的查询结构,但要寻找如何构建这个方法体就比较耗时间了,接下来还是用 dnspy 去调试看看有没有更深层次的堆栈。

这个堆栈信息就非常清楚了,原来是在 MongoDB.Bson.Serialization.BsonClassMapSerializer.DeserializeClass 方法中出了问题,接下来找到问题代码,简化如下:


public TClass DeserializeClass(BsonDeserializationContext context)
{
	while (reader.ReadBsonType() != BsonType.EndOfDocument)
	{
		TrieNameDecoder<int> trieNameDecoder = new TrieNameDecoder<int>(elementTrie);
		string text = reader.ReadName(trieNameDecoder);
		if (trieNameDecoder.Found)
		{
			int value = trieNameDecoder.Value;
			BsonMemberMap bsonMemberMap = allMemberMaps[value];
		}
		else
		{
			if (!this._classMap.IgnoreExtraElements)
			{
				throw new FormatException(string.Format("Element '{0}' does not match any field or property of class {1}.", text, this._classMap.ClassType.FullName));
			}
			reader.SkipValue();
		}
	}
}

上面的代码逻辑非常清楚,要么 student 中存在 _id 字段,也就是 trieNameDecoder.Found, 要么使用 忽略未知的元素,也就是 this._classMap.IgnoreExtraElements,添加字段容易,接下来看看怎么让 IgnoreExtraElements = true,找了一圈源码,发现这里是关键:

也就是: foreach (IBsonClassMapAttribute bsonClassMapAttribute in classMap.ClassType.GetTypeInfo().GetCustomAttributes(false).OfType<IBsonClassMapAttribute>())这句话,这里的 classMap 就是 student,只有让 foreach 得以执行才能有望 classMap.IgnoreExtraElements 赋值为 true ,接下来找找看在类上有没有类似 IgnoreExtraElements 的 Attribute,嘿嘿,还真有一个类似的: BsonIgnoreExtraElements ,如下代码:


    [BsonIgnoreExtraElements]
    public class Student
    {
        public string StudentName { get; set; }

        public DateTime Created { get; set; }
    }

接下来执行一下代码,可以看到问题搞定:

如果你想验证的话,可以继续用 dnspy 去验证一下源码哈,如下代码所示:

接下来还有一种办法就是增加 _id 字段,如果你不知道用什么类型接,那就用object就好啦,后续再改成真正的类型。

三: 2号坑 DateTime 时区不对

如果你细心的话,你会发现刚才案例中的 Created 时间是 2020/8/16 4:24:57, 大家请放心,我不会傻到凌晨4点还在写代码,好了哈,看看到底问题在哪吧, 可以先看看 mongodb 中的记录数据,如下:


{
    "_id" : ObjectId("5f38b83e0351908eedac60c9"),
    "StudentName" : "hxc",
    "Created" : ISODate("2020-08-16T04:38:22.587Z")
}

从 ISODate 可以看出,这是格林威治时间,按照0时区存储,所以这个问题转成了如何在获取数据的时候,自动将 ISO 时间转成 Local 时间就可以了,如果你看过底层源码,你会发现在 mongodb 中每个实体的每个类型都有一个专门的 XXXSerializer,如下图:

接下来就好好研读一下里面的 Deserialize 方法即可,代码精简后如下:


public override DateTime Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args)
{
	IBsonReader bsonReader = context.Reader;
	BsonType currentBsonType = bsonReader.GetCurrentBsonType();
	DateTime value;
	
	switch (this._kind)
	{
		case DateTimeKind.Unspecified:
		case DateTimeKind.Local:
			value = DateTime.SpecifyKind(BsonUtils.ToLocalTime(value), this._kind);
			break;
		case DateTimeKind.Utc:
			value = BsonUtils.ToUniversalTime(value);
			break;
	}
	return value;
}

可以看出,如果当前的 this._kind= DateTimeKind.Local 的话,就将 UTC 时间转成 Local 时间,如果你有上一个坑的经验,你大概就知道应该也是用特性注入的,


    [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
    public DateTime Created { get; set; }

不信的话,我调试给你看看哈。

接下来再看看 this._kind 是怎么被赋的。

四: 3号坑 自定义ObjectID

在第一个坑中,不知道大家看没看到类似这样的语句: ObjectId("5f38b83e0351908eedac60c9") ,乍一看像是一个 GUID,当然肯定不是,这是mongodb自己组建了一个 number 组合的十六进制表示,姑且不说性能如何,反正看着不是很舒服,毕竟大家都习惯使用 int/long 类型展示的主键ID。

那接下来的问题是:如何改成我自定义的 number ID 呢? 当然可以,只要实现 IIdGenerator 接口即可,那主键ID的生成,我准备用 雪花算法,完整代码如下:


    class Program
    {
        static void Main(string[] args)
        {
            var client = new MongoClient("mongodb://192.168.1.128:27017");
            var database = client.GetDatabase("school");
            var table = database.GetCollection<Student>("student");

            table.InsertOne(new Student() { Created = DateTime.Now });
            table.InsertOne(new Student() { Created = DateTime.Now });
        }
    }

    class Student
    {
        [BsonId(IdGenerator = typeof(MyGenerator))]
        public long ID { get; set; }

        [BsonDateTimeOptions(Kind = DateTimeKind.Local)]
        public DateTime Created { get; set; }
    }

    public class MyGenerator : IIdGenerator
    {
        private static readonly IdWorker worker = new IdWorker(1, 1);

        public object GenerateId(object container, object document)
        {
            return worker.NextId();
        }

        public bool IsEmpty(object id)
        {
            return id == null || Convert.ToInt64(id) == 0;
        }
    }

然后去看一下 mongodb 生成的 json:

四: 总结

好了,这三个坑,我想很多刚接触 mongodb 的朋友是一定会遇到的困惑,总结一下方便后人乘凉,结果不重要,重要的还是探索问题的思路和不择手段😄😄😄

作者:一线码农上海
链接:https://www.imooc.com/article/309515?block_id=tuijian_wz
来源:慕课网

MongoDB查询转对象是出错Element '_id' does not match any field or property of class - 94cool - 博客园

mikel阅读(917)

来源: MongoDB查询转对象是出错Element ‘_id’ does not match any field or property of class – 94cool – 博客园

MongoDB查询转对象是出错Element ‘_id’ does not match any field or property of class

 

解决方法:

1、在实体类加:[BsonIgnoreExtraElements]

2、或者定义public ObjectId _id { get; set; }

例子:

[BsonIgnoreExtraElements]

public class BaseData
{
//public ObjectId _id { get; set; }

public string cNo { get; set; }

public string customer { get; set; }

public long batchNo { get; set; }

public DateTime mDate { get; set; }

public string mUser { get; set; }
}

Jmete压力测试、并发测试的简单方法 - BF! - 博客园

mikel阅读(1056)

来源: Jmete压力测试、并发测试的简单方法 – BF! – 博客园

我们的需求场景如下:

服务器硬件:(只有一台)

系统:CentOS 7

WebServer:Tomcat 7.0

Jdk:1.8

CPU:8核 2.9GHz两个

内存:16g

报名应用系统:只需要向外提供一个报名和找回报名号的接口。

我们需要:测试服务器能同时承受多少条HTTP请求。

通过各种百度后发现LoadRunner是好,但是使用起来短时间内比较难上手,然后就找到了Jmeter。

一、运行Jmeter:

首先在网上下载一个jmeter,我下载的是2.3版本,其他版本同理

二、创建一个线程组

三、设置线程组参数

四、创建HTTP请求

五、配置HTTP请求

 

 

六、添加运行结果分析监听器

 

 

七、聚合报告

 

 

八、图形结果

 

 

九、总结

我们按照如上步骤设置好参数后,对应用进行了并发测试(测试时,测试机器和服务器同一个内网网段),第一次模拟100个用户并发请求(请求需要通过查询

具有1000条数据的数据表)持续执行10分钟,偏移保持在100以下,第二次模拟200个用户,偏移还是保持在100以下,第三次模拟350个用户时,偏移则保持在100左右。

而且服务器CPU状态良好,使用率一直保持在20%左右,最高不超过25%。为什么服务器CPU的使用率没有达到很高的情况下,而偏移会越来越高呢,我猜测可能跟Tomcat

没进行优化有关。最后我们认为该应用的并发量大概是在400左右。

jmeter(一)基础介绍 - 老_张 - 博客园

mikel阅读(881)

来源: jmeter(一)基础介绍 – 老_张 – 博客园

参考书籍:段念《软件性能测试与案例剖析》——第二版

推荐一本书《零成本实现web性能测试——基于Apache—jmeter》,主要内容是一些关于jmeter的实战使用,想学习的可以去看看。。。

 

jmeter是一款优秀的开源性能测试工具,目前最新版本3.0版本,官网文档地址:http://jmeter.apache.org/usermanual/index.html

一、优点

1、开源工具,可扩展性非常好

2、高可扩展性,用户可自定义调试相关模块代码

3、精心简单的GUI设计,小巧灵活

4、完全的可移植性和100%纯java

5、完全swing和轻量组件支持(预编译的HAR使用javax.swing.*)包

6、完全多线程框架,允许通过多个线程并发取样以及单独的线程对不同的功能同时取样

7、支持脚本取样器

 

二、安装及下载

这里附一个最新的jmeter官网下载地址:

http://jmeter.apache.org/download_jmeter.cgi

该链接是3.0版本的jmeter安装包

jmeter本身不需要安装,只需要配置好JDK环境,然后在在jmeter文件中的bin文件中打开jmeter.bat文件即可

最新版本,建议配置的JDK最好用1.7及以上版本

 

三、基础构成

1、组成部分

1)负载发生器:产生负载,多进程或多线程模拟用户行为

2)用户运行器:脚本运行引擎,用户运行器附加在进程或线程上,根据脚本模拟指定的用户行为

3)资源生成器:生成测试过程中服务器、负载机的资源数据

4)报表生成器:根据测试中获得的数据生成报表,提供可视化的数据显示方式·

2、主要概念

2.1测试计划(test plan)

描述一个性能测试,包含本次测试所有相关功能

2.2.threads(users)线程

Setup thread group:

一种特殊类型的线程,可用于执行预测试操作。即执行测试前进行定期线程组的执行

Teardown thread group:

一种特殊类型的线程,可用于执行测试后动作。即执行测试结束后执行定期的线程组

以上两个线程组,举个例子:loadrunner的脚本除了action里是真正的脚本核心内容,还有初始化“环境”的初始化脚本和测试完毕后对应的清除信息的脚本块,与其对应

Thread group:

通常添加使用的线程,一般一个线程组可看做一个虚拟用户组,其中每个线程为一个虚拟用户

2.3测试片段(test fragment)

2.5版本之后新增的一个选项,是一种特殊的线程组,在测试树上与线程组一个层级,但是它不被执行,除非它是一个模块控制器或者被控制器所引用时才会被执行

 

2.4控制器

Jmeter有2种控制器:取样器(sampler)和逻辑控制器(Logic Controller)

作用:用这些原件驱动处理一个测试

1)取样器(Sampler)

是性能测试中向服务器发送请求,记录响应信息,记录响应时间的最小单元,JMeter 原生支持多种不同的sampler

如 HTTP Request Sampler 、 FTP  Request Sampler 、TCP  Request Sampler 、JDBC Request Sampler 等

每一种不同类型的 sampler 可以根据设置的参数向服务器发出不同类型的请求。

Java Request Sampler 和 Beanshell Request Sampler 是两种特殊的可定制的 Sampler (暂不讨论)

2)逻辑控制器(Logic Controller)

包含两类原件:

一类是控制Test Plan中Sampler节点发送请求的逻辑顺序控制器,常用的有:If Controller、Swith Controller、Loop Controller、Random Controller等

另一类是用来组织和控制Sampler节点的,如Transaction Controller、Throughput Controller等

2.5监听器(Listener)

对测试结果进行处理和可视化展示的一系列组件,常用的有图形结果、查看结果树、聚合报告等

以上的五类原件就可以构成一个简单的性能测试脚本

下面再介绍几种jmeter提供的其他组件:

2.6配置原件(Config Element)

用于提供对静态数据配置的支持。CSV Date Set Config可以将本地数据文件形成数据池(Date Pool),而对应于HTTP Request Configuration

和TCP Request Sample等类型的Configuration元件则可以修改这些Sample的默认数据等

2.7定时器(Time)

用于操作之间设置等待时间,等待时间使性能测试中常用的控制客户端QPS的手段,jmeter定义了Constant Times、

Constant Throughput Times、Guass Ramdon Times等不同类型的Times

2.8断言(Assertions)

用于检查测试中得到的响应数据等是否符合预期,Assertions一般用来设置检查点,用以保证性能测试过程中的数据交互与预期一致

2.9前处理器(Pre Processors)

用于在实际请求发出之前对即将发出的请求进行特殊处理。

例如:Count处理器可以实现自增操作,自增后生成的的数据可以被将要发出的请求使用,而HTTP URL Re—Writing Modifier处理器则可以实现URL重写,

当URL中有sessionID一类的session信息时,可以通过该处理器填充发出请求实际的sessionID。

2.10后处理器(Post Processors)

 

用于对Sampler发出请求后得到的服务器响应进行处理。一般用来提取响应中的特定数据(类似loadrunner中的关联)。

例如:Regular Expression Extractor用于提取响应数据中匹配某正则表达式的数据段,并将其填充在参数中,Xpath Extractor则可以用于提取响应数据中通过给定Xpath值获得的数据。。。

 

转载请注明出处,商用请征得作者本人同意,谢谢!!!

《jmeter:菜鸟入门到进阶》系列 - 老_张 - 博客园

mikel阅读(782)

来源: 《jmeter:菜鸟入门到进阶》系列 – 老_张 – 博客园

jmeter是我从事软件测试工作以来接触的第一个性能测试工具,也是耗费时间精力最多的一个工具,当然,学习jmeter过程中,由于知识储备不够,也顺带学习了很多其他相关的一些知识。

一直有个想法,就是把jmeter写成一个完整的系列,包括元件构成、用法、不同组合能实现什么功能,以及利用jmeter来实现接口自动化、性能自动化测试等功能。

当然,工具只是辅助测试提高效率的手段,博采众长,选择合适的解决问题的方案才是我们学习的目的,工具只是手段,仅此而已。

这篇博客,将关于jmeter的一些使用技巧,遇到的错误整理成一个目录索引吧,方便自己查阅的同时也方便其他同行参考。

目前是持续更新状态,如果哪天断更了会提前说的,就这样吧。。。

 

1、基础介绍

简单介绍jmeter的元件组成,作用等基础知识;

2、录制脚本

简述了jmeter录制脚本的2种方式;

3、元件的作用域及执行顺序

jmeter各元件的作用域及执行的顺序;

4、Sampler之SOAP/XML-RPC Request

取样器中关于SOAP/XML-RPC Request的用法;

5、Sampler之HTTP请求

取样器中关于HTTP请求的用法;

6、http请求之content-type

取样器中关于HTTP请求的补充说明;

7、Sample之JDBC Request

取样器中关于JDBC请求的用法;

8、JDBC Request之Query Type

取样器中关于JDBC请求的补充说明;

9、目录结构

jmeter目录结构等简单介绍;

10、参数化

jmeter参数化的4种方式;

11、关联之正则表达式提取器

jmeter关联之正则表达式提取器的用法;

12、关联之XPath Extractor

jmeter关联之XPath Extractor的用法;

13、配置元件之计数器

jmeter配置元件中关于计数器的用法;

14、配置元件之HTTP属性管理器

jmeter配置元件中关于http属性管理器的用法;

15、函数助手

jmeter内置函数助手的简单介绍;

16、定时器

jmeter八大元件之定时器的介绍;

17、断言

jemter八大元件之断言的介绍;

18、逻辑控制器

jmeter八大元件之逻辑控制器的介绍;

19、常见问题及解决方法

jmeter使用过程中常见问题及解决方案的说明;

20、阶梯式加压测试

jmeter扩展插件Stepping Thread Group的简单介绍;

21、jmeter常用插件介绍

jmeter插件Transactions per Second、Response Times Over Time、PerfMon Metrics Collector的下载安装及使用;

22、内存溢出原因及解决方法

关于jmeter做压力负载测试时候遇到内存溢出的原因和解决方法;

23、jmeter分布式测试

关于高并发情况下分布式测试的一些技术点和注意事项;

24、dubbo接口测试

利用jmeter的dubbo插件进行dubbo接口测试和性能测试;

25、linux环境运行jmeter并生成报告

linux环境,非GUI模式运行jmeter脚本进行性能测试,并生成测试报告的介绍;

26、jmeter生成HTML格式性能测试报告

jmeter生成HTML格式的性能测试报告的2种方式,以及可视化图表解析内容;

27、jmeter分布式压测注意事项

利用jmeter进行分布式压测,需要注意的一些细节;

28、利用beanshell进行多重断言

利用beanshell来处理多重返回的方法;

 

转载请注明出处,商用请征得作者本人同意,谢谢!!!

Excel数据批量导入到SqlServer的方法 - xiashengwang - 博客园

mikel阅读(1102)

来源: Excel数据批量导入到SqlServer的方法 – xiashengwang – 博客园

1,以Excel为数据源建立连接导入。

关键点在于Excel的数据要有表头,表头要和数据库表的列名一样。连接字符串中HDR=YES不能省略,也就是第一行是表头的意思。IMEX=1;是把数据都当作字符串读取。

复制代码
Sub test()
     
    Dim cn As ADODB.Connection
    Dim strSQL As String
    Dim lngRecsAff As Long
    Dim Headers As Boolean
    Dim strConn As String
    Dim path As String
    
    On Error GoTo test_Error
    
    Headers = True
    path = "c:\20131212.xls"
    strConn = "Provider=Microsoft.Jet.OLEDB.4.0;" & _
              "Data Source=" & path & ";" & _
              "Extended Properties=""Excel 8.0; IMEX=1;HDR=YES"""
                  
    Debug.Print strConn
    Set cn = New ADODB.Connection
    cn.Open strConn
     
     'Import by using Jet Provider.
    strSQL = "Insert INTO [odbc;Driver={SQL Server};" & _
             "Server=192.168.6.111;Database=answer;" & _
             "UID=sa;PWD=password].test1 " & _
             "Select * FROM [Sheet1$]"
    Debug.Print strSQL
    cn.Execute strSQL, lngRecsAff
    Debug.Print "Records affected: " & lngRecsAff
     
    cn.Close
    Set cn = Nothing
     
    On Error GoTo 0
    Exit Sub
     
test_Error:
     
    MsgBox "Error " & Err.Number & " (" & Err.Description & ") in procedure test of VBA Document ThisWorkbook"
     
End Sub
复制代码

2,还有一种方案,是以SQLServer为数据源,写法大致如下

“INSERT INTO [档案1] SELECT * FROM [Excel 8.0;Database=” & ThisWorkbook.FullName & “;HDR=YES].[sheet1$” & addr & “];”

使用c#对MongoDB进行查询(1) - 莫问今朝· - 博客园

mikel阅读(911)

来源: 使用c#对MongoDB进行查询(1) – 莫问今朝· – 博客园

1.BsonDocument对象

在MongoDB.Bson命名空间下存在一个BsonDocument类,它是MongoDB的文档对象,代表着MongoDB中不规则数据一条条实体模型。可以使用BsonDocument对不规则数据进行操作,这个类型继承了IEnumberable<>类,也就是说又将每一个实体模型看做一个集合,我们可以使用下标方式获取实体模型中的值

复制代码
     //
        // 摘要:
        //     Gets or sets a value by position.
        //
        // 参数:
        //   index:
        //     The position.
        //
        // 返回结果:
        //     The value.
        public override BsonValue this[int index] { get; set; }
        //
        // 摘要:
        //     Gets or sets a value by name.
        //
        // 参数:
        //   name:
        //     The name.
        //
        // 返回结果:
        //     The value.
        public override BsonValue this[string name] { get; set; }
        //
        // 摘要:
        //     Gets the value of an element or a default value if the element is not found.
        //
        // 参数:
        //   name:
        //     The name of the element.
        //
        //   defaultValue:
        //     The default value to return if the element is not found.
        //
        // 返回结果:
        //     Teh value of the element or a default value if the element is not found.
        [Obsolete("Use GetValue(string name, BsonValue defaultValue) instead.")]
        public virtual BsonValue this[string name, BsonValue defaultValue] { get; }
复制代码

  2.连接配置

复制代码
 //连接地址
        private static string conn = "mongodb://192.168.11.51:40000";
        //数据库名称
        private static string dbName = "yan";
        //集合名称
        private static string colName = "Demo";
        //连接服务端
       static  MongoClient client = new MongoClient(conn);
        //获取指定数据库
       static IMongoDatabase db = client.GetDatabase(dbName);
        //获取指定集合   BsonDocument数据库文档对象
       static  IMongoCollection<BsonDocument> coll = db.GetCollection<BsonDocument>(colName);
复制代码

3.插入数据

复制代码
  var doc = new[]
            {
                new BsonDocument{
                    { "DepartmentName","开发部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "狗娃" },{"Age",20 } },
                             new BsonDocument{ { "Name", "狗剩" },{"Age",22 } },
                              new BsonDocument{ { "Name", "铁蛋" },{"Age",24 } }
                        }
                    },
                    {"Sum",18 },
                      { "dim_cm", new BsonArray { 14, 21 } }


                },
                 new BsonDocument{
                    { "DepartmentName","测试部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "张三" },{"Age",11 } },
                             new BsonDocument{ { "Name", "李四" },{"Age",34 } },
                              new BsonDocument{ { "Name", "王五" },{"Age",33 } }
                        }
                    }
                     ,
                     { "Sum",4 }
                     ,
                       { "dim_cm", new BsonArray { 14, 21 } }

                },
                  new BsonDocument{
                    { "DepartmentName","运维部"},
                    { "People",new  BsonArray
                        {
                            new BsonDocument{ { "Name", "闫" },{"Age",20 } },
                             new BsonDocument{ { "Name", "王" },{"Age",22 } },
                              new BsonDocument{ { "Name", "赵" },{"Age",24 } }
                        }
                    },
                     { "Sum",2 },
                       { "dim_cm", new BsonArray { 22.85, 30 } }

                }
            };

            coll.InsertMany(doc);
复制代码

4.查询

4.1 查询部门是开发部的信息

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.Eq("DepartmentName", "开发部");
            //获取数据
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

 4.2 获取Sum大于4的数据

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFIlter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.Gt("Sum", 4);
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

   4.3 And约束  

复制代码
 //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //约束条件
            FilterDefinition<BsonDocument> filter = builder.And(builder.Gt("Sum", "2"), builder.Eq("DepartmentName", "运维"));
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.4查询指定值

复制代码
  //创建约束生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            ProjectionDefinitionBuilder<BsonDocument> builderProjection = Builders<BsonDocument>.Projection;
            //Include 包含某元素    Exclude  不包含某元素
            ProjectionDefinition<BsonDocument> projection = builderProjection.Include("DepartmentName").Exclude("_id");
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Project(projection).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

4.5 排序

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //排序生成器
            SortDefinitionBuilder<BsonDocument> builderSort = Builders<BsonDocument>.Sort;
            //排序约束   Ascending 正序    Descending 倒序
            SortDefinition<BsonDocument> sort = builderSort.Ascending("Sum");
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Sort(sort).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.6 In查询

复制代码
  //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            FilterDefinition<BsonDocument> filter = builderFilter.In("DepartmentName", new[] { "测试部", "开发部" });
            var result = coll.Find<BsonDocument>(filter).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

   4.7  分页查询

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //分页   Skip 跳过  Limit查询多少
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Skip(1).Limit(1).ToList();
            foreach (var item in result)
            {
                //取出整条值
                Console.WriteLine(item.AsBsonValue);
            }
复制代码

  4.8查询总条目数

 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //总条目数
            var result = coll.Find<BsonDocument>(builderFilter.Empty).Count();

 4.9Linq查询

复制代码
 //创建生成器//linq
            var result = from y in coll.AsQueryable() select new { DepartmentName = y["DepartmentName"], id = y["_id"] };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName:" + item.DepartmentName + "====Id:"+item.id);
            }
复制代码

   4.10分组查询

复制代码
 //创建生成器
            FilterDefinitionBuilder<BsonDocument> builderFilter = Builders<BsonDocument>.Filter;
            //分组
            var result = from y in coll.AsQueryable()  group y by  y["DepartmentName"] into s select new { DepartmentName = s.Key, Count = s.Count() };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName:" + item.DepartmentName + "====Count:"+item.Count);
            }
复制代码

  4.11连表查询

复制代码
 //linq
            //连表查询   在这里是自己连自己
            var result = from u in coll.AsQueryable() join o in coll.AsQueryable() on u["_id"] equals o["_id"] select new { DepartmentName1 = u["DepartmentName"], DepartmentName2 = u["DepartmentName"] };
            foreach (var item in result)
            {

                Console.WriteLine("DepartmentName1:" + item.DepartmentName1 + "====DepartmentName2:" + item.DepartmentName2);
            }
复制代码

 

c#驱动操作mongodb辅助类MongoDBHelper - AndyQ - 博客园

mikel阅读(1135)

FilterDefinition

来源: c#驱动操作mongodb辅助类MongoDBHelper – AndyQ – 博客园

C#驱动操作mongodb辅助类MongoDBHelper

复制代码
using MongoDB.Bson;
using MongoDB.Driver;
using System;
using System.Collections.Generic;
 
/*
https://docs.mongodb.com/manual/tutorial/update-documents/
https://docs.mongodb.com/manual/tutorial/perform-two-phase-commits/
https://docs.mongodb.com/manual/reference/command/dropDatabase/index.html
https://docs.mongodb.com/manual/reference/command/listCommands/
*/
 
namespace MongoDbHelper
{
    public class MongoDBHelper
    {
        private string databaseName = string.Empty;
        private IMongoClient client = null;
        private IMongoDatabase database = null;
 
        public MongoDBHelper(string connectionString)
        {
            client = new MongoClient(connectionString);
        }
 
        public MongoDBHelper(string connectionString, string databaseName)
        {
            client = new MongoClient(connectionString);
            database = client.GetDatabase(databaseName);
        }
 
        public string DatabaseName
        {
            get { return databaseName; }
            set
            {
                databaseName = value;
                database = client.GetDatabase(databaseName);
            }
        }
 
        /// <summary>
        /// 执行命令,命令请参考MongoCommand,命令太多,不一一展示,传入的就是里面的字符串,有些命令执行需要连接到admin表
        /// </summary>
        /// <param name="cmdText"></param>
        /// <returns></returns>
        public BsonDocument RunCommand(string cmdText)
        {
            return database.RunCommand<BsonDocument>(cmdText);
        }
 
        public IList<BsonDocument> GetDatabase()
        {
            return client.ListDatabases().ToList();
        }
 
        #region SELECT
        /// <summary>
        /// 判断文档存在状态
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filterexist"></param>
        /// <returns></returns>
        public bool IsExistDocument<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Count(filter) > 0;
        }
 
        /// <summary>
        /// 通过条件得到查询的结果个数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public long GetCount<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Count(filter);
        }
 
        /// <summary>
        /// 通过系统id(ObjectId)获取一个对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public T GetDocumentById<T>(string documentname, string id)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            var result = database.GetCollection<T>(documentname).Find(filter);
            return result.FirstOrDefault();
        }
 
        /// <summary>
        /// 通过系统id(ObjectId)获取一个对象同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <param name="fields"></param>
        /// <returns></returns>
        public T GetDocumentById<T>(string documentname, string id, ProjectionDefinition<T> fields)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).FirstOrDefault();
        }
 
        /// <summary>
        /// 通过指定的条件获取一个对象,如果有多条,只取第一条,同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="fields"></param>
        /// <returns></returns>
        public T GetDocumentByUserFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields)
        {
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).FirstOrDefault();
        }
 
        /// <summary>
        /// 获取全部文档
        /// </summary>
        /// <typeparam name="T"></typeparam>       
        /// <param name="documentname"></param>
        /// <returns></returns>
        public IList<T> GetAllDocuments<T>(string documentname)
        {
            var filter = Builders<T>.Filter.Empty;
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 获取全部文档同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetAllDocuments<T>(string documentname, ProjectionDefinition<T> fields)
        {
            var filter = Builders<T>.Filter.Empty;
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过一个条件获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="property">字段名</param>
        /// <param name="value">字段值</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter)
        {
            return database.GetCollection<T>(documentname).Find(filter).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象,同时过滤字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="property">字段名</param>
        /// <param name="value">字段值</param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, string property, string value, ProjectionDefinition<T> fields)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过条件获取对象,同时过滤数据和字段
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter">过滤器</param>
        /// <param name="fields">要获取的字段</param>
        /// <returns></returns>
        public IList<T> GetDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields)
        {
            return database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).ToList();
        }
 
        /// <summary>
        /// 通过条件获取分页的文档并排序
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, ProjectionDefinition<T> fields, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Project<T>(fields).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 通过条件获取分页的文档并排序
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="sort"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 通过条件获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, FilterDefinition<T> filter, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, SortDefinition<T> sort, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            var filter = Builders<T>.Filter.Empty;
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).Sort(sort).ToList();
            }
            return result;
        }
 
        /// <summary>
        /// 获取分页的文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="pageIndex"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public IList<T> GetPagedDocumentsByFilter<T>(string documentname, int pageIndex, int pageSize)
        {
            IList<T> result = new List<T>();
            var filter = Builders<T>.Filter.Empty;
            if (pageIndex != 0 && pageSize != 0)
            {
                result = database.GetCollection<T>(documentname).Find(filter).Skip(pageSize * (pageIndex - 1)).Limit(pageSize).ToList();
            }
            else
            {
                result = database.GetCollection<T>(documentname).Find(filter).ToList();
            }
            return result;
        }
        #endregion
 
        #region INSERT
 
        /// <summary>
        /// 新增
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="document"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public void Insert<T>(string documentName, T document)
        {
            try
            {
                database.GetCollection<T>(documentName).InsertOne(document);
            }
            catch (MongoWriteException me)
            {
                MongoBulkWriteException mbe = me.InnerException as MongoBulkWriteException;
                if (mbe != null && mbe.HResult == -2146233088)
                    throw new Exception("插入重复的键!");
                throw new Exception(mbe.Message);
            }
            catch (Exception ep)
            {
                throw ep;
            }
        }
 
        /// <summary>
        /// 新增多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="documents"></param>
        /// <returns></returns>
        public void InsertMany<T>(string documentname, IList<T> documents)
        {
            try
            {
                database.GetCollection<T>(documentname).InsertMany(documents);
            }
            catch (MongoWriteException me)
            {
                MongoBulkWriteException mbe = me.InnerException as MongoBulkWriteException;
                if (mbe != null && mbe.HResult == -2146233088)
                    throw new Exception("插入重复的键!");
                throw new Exception(mbe.Message);
            }
            catch (Exception ep)
            {
                throw ep;
            }
        }
        #endregion
 
        #region UPDATE
        /// <summary>
        /// 修改
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filterexist"></param>
        /// <param name="id"></param>
        /// <param name="oldinfo"></param>
        /// <returns></returns>
        public void UpdateReplaceOne<T>(string documentname, string id, T oldinfo)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            database.GetCollection<T>(documentname).ReplaceOne(filter, oldinfo);
        }
 
        /// <summary>
        /// 只能替换一条,如果有多条的话
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <param name="oldinfo"></param>
        public void UpdateReplaceOne<T>(string documentname, FilterDefinition<T> filter, T oldinfo)
        {
            database.GetCollection<T>(documentname).ReplaceOne(filter, oldinfo);
        }
 
        /// <summary>
        /// 更新指定属性值,按ID就只有一条,替换一条
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <param name="setvalue"></param>
        /// <returns></returns>
        public void Update<T>(string documentname, string id, string property, string value)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filter = Builders<T>.Filter.Eq("_id", oid);
            var update = Builders<T>.Update.Set(property, value);
            database.GetCollection<T>(documentname).UpdateOne(filter, update);
        }
 
        public void Update<T>(string documentname, FilterDefinition<T> filter, UpdateDefinition<T> update)
        {
            database.GetCollection<T>(documentname).UpdateOne(filter, update);
        }
 
        public void UpdateMany<T>(string documentname, FilterDefinition<T> filter, UpdateDefinition<T> update)
        {
            database.GetCollection<T>(documentname).UpdateMany(filter, update);
        }
 
        #endregion
 
        #region DELETE
        /// <summary>
        /// 删除一个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public void Delete<T>(string documentname, string id)
        {
            ObjectId oid = ObjectId.Parse(id);
            var filterid = Builders<T>.Filter.Eq("_id", oid);
            database.GetCollection<T>(documentname).DeleteOne(filterid);
        }
 
        public void Delete<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            database.GetCollection<T>(documentname).DeleteOne(filter);
        }
 
        /// <summary>
        /// 通过一个属性名和属性值删除多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="id"></param>
        /// <returns></returns>
        public void DeleteMany<T>(string documentname, string property, string value)
        {
            FilterDefinition<T> filter = Builders<T>.Filter.Eq(property, value);
            database.GetCollection<T>(documentname).DeleteMany(filter);
        }
 
        /// <summary>
        /// 通过一个属性名和属性值删除多个文档
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="documentname"></param>
        /// <param name="filter"></param>
        /// <returns></returns>
        public void DeleteMany<T>(string documentname, FilterDefinition<T> filter)
        {
            database.GetCollection<T>(documentname).DeleteMany(filter);
        }
        #endregion
 
        /// <summary>
        /// 有些命令要求你连到系统库上才能执行
        /// You need to link to the admin table if you want to run system command;eg:listDatabases ,the following url show you the details
        /// https://docs.mongodb.com/manual/reference/command/listCommands/
        /// </summary>
        public sealed class MongoCommand
        {
            public const string ListDatabases = "{listDatabases:1}";
            public const string ListCommands = "{ listCommands: 1 }";
        }
    }
}
复制代码

 

MongoDB 工具助手类(.NET) - jiangys - 博客园

mikel阅读(726)

来源: MongoDB 工具助手类(.NET) – jiangys – 博客园

在开发过程中,需要用到MongoDB,本身MongoDB自己对类的封装就特别好了。为了更加符合我们平时的开发使用,我现在进行了一个简单的封装操作。

连接数据库类:MongoDBContext

复制代码
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Configuration;

using MongoDB.Bson;
using MongoDB.Driver;
using MongoDB.Driver.Builders;
using MongoDB.Driver.Linq;

namespace XXXXX.MongoDB
{
    public class MongoDBContext
    {
        // 数据库链接
        private readonly MongoDatabase database;

        public MongoDBContext()
            : this(ConfigurationManager.AppSettings["DefaultMongoDBConnection"], ConfigurationManager.AppSettings["DefaultMonoDbDatabase"])
        {
        }

        /// <summary>
        /// 构造函数。根据指定连接字符串和数据库名
        /// </summary>
        /// <param name="connectionString">连接字符串</param>
        /// <param name="dbName">数据库名</param>
        public MongoDBContext(string connectionString, string dbName)
        {
            if (string.IsNullOrEmpty(connectionString))
            {
                throw new ArgumentNullException("connectionString is null");
            }

            if (string.IsNullOrEmpty(dbName))
            {
                throw new ArgumentNullException("dbName is null");
            }

            var client = new MongoClient(connectionString);
            var server = client.GetServer();
            this.database = server.GetDatabase(dbName);
        }

        /// <summary>
        /// 获取当前连接数据库的指定集合【依据类型】
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public MongoCollection<T> Collection<T>()
        {
            return database.GetCollection<T>(typeof(T).Name);
        }
    }
}
复制代码

服务操作类:MongoDBService

复制代码
using MongoDB.Driver.Builders;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace XXXXX.MongoDB
{

    public class MongoDBService<T> : IMongoDBService<T> where T : class,new()
    {
        MongoDBContext mc = new MongoDBContext();

        /// <summary>
        /// 查询符合条件的集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList()
        {
            var query = Query<T>.Where(o => true);
            return mc.Collection<T>().Find(query);
        }

        /// <summary>
        /// 查询符合条件的集合
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public IEnumerable<T> GetList(Expression<Func<T, bool>> whereLambda)
        {
            var query = Query<T>.Where(whereLambda);
            return mc.Collection<T>().Find(query);
        }

        /// <summary>
        /// 查询一条记录
        /// </summary>
        /// <param name="whereLambda"></param>
        /// <returns></returns>
        public T GetOne(Expression<Func<T, bool>> whereLambda)
        {
            var query = GetList(whereLambda).FirstOrDefault();
            return query;
        }

        /// <summary>
        /// 增加
        /// </summary>
        /// <param name="entity"></param>
        public void Insert(T entity)
        {
            mc.Collection<T>().Insert(entity);
        }

        /// <summary>
        /// 批量增加
        /// </summary>
        /// <param name="entitys"></param>
        public void InsertAll(IEnumerable<T> entitys)
        {
            mc.Collection<T>().InsertBatch(entitys);
        }

        /// <summary>
        /// 更新一个实体
        /// </summary>
        /// <param name="entity"></param>
        public void Update(T entity)
        {
            mc.Collection<T>().Save(entity);
        }

        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="whereLambda"></param>
        public void Remove(Expression<Func<T, bool>> whereLambda)
        {
            var query = Query<T>.Where(whereLambda);
            mc.Collection<T>().Remove(query);
        }
    }
}
复制代码

上面方法封装完后,我们就可以直接使用了。使用很简单,比如,我有一个ActivityModel实体,使用时,如下:

复制代码
        public void activityTest()
        {
            var activityDb = new MongoDBService<ActivityModel>();
            var activityList = activityDb.GetList().ToList();
            var activity = activityDb.GetOne(o => o.Id==ObjectId.Parse("54d9aecd89f0bd14d81a63a7"));
            var xxx = activity.To();
        }
复制代码

 

双十一来了,别让你的mongodb宕机了 - 一线码农 - 博客园

mikel阅读(834)

来源: 双十一来了,别让你的mongodb宕机了 – 一线码农 – 博客园

 

好久没过来吹牛了,前段时间一直赶项目,没有时间来更新博客,项目也终于赶完了,接下来就要面临双十一这场惊心动魄的处女秀考验,

我们项目中会有一个wcf集群,而集群地址则放在mongodb中,所以mongodb的核心地位可想而知,如果mongodb挂掉,整个项目也就陷入

瘫痪,想让mongodb不宕机,最简单的方法就是要做双机热备,跟传统的关系型数据库的双机热备模式一样,一个主服务器,一个备份服务器,

一个仲裁服务器。如果热备集群中的主服务器宕掉,会有仲裁服务器参与投票来选出一台作为主服务器,我想这个大家都比较清楚,下面我们来

实战一下,最后会奉献源代码。

 

一:搭建mongodb热备集群

1. 准备工作

为了做到最简化搭建,我就做一个主,一个备,一个仲裁就好了,然后最简化配置信息都放在mongodb.conf文件中,如下图:

 

从上图中可以看到,三个mongodb,我建立了对应的三个文件夹来存放对应的三个db,其中“主服务器”的端口为27000,“备服务器“的端口为

27001,”仲裁服务器“端口为27002。 具体mongodb.conf内容如下:

 

2. 开启 “主服务器” 【27000】

 

3.  开启 “备服务器” 【27001】

 

4.  开启 “仲裁服务器” 【27002】

 

现在三台服务器都开启起来了,细心的你会发现,三个控制台都有这么一段英文单词” replSet info you may need to run replSetInitiate“。。。

既然都这么说了,我现在就去run这个func。

 

复制代码
db.runCommand({
    "replSetInitiate":{
        "_id":"datamip",
        "members":[
            {
                "_id":1,
                "host":"127.0.0.1:27000"
            },
            {
                "_id":2,
                "host":"127.0.0.1:27001"
            }
        ]
    }
})
复制代码

 

配置完了之后,然后我们把“仲裁服务器【27002】”加入到“datamip”这个双机热备分集群中。

 

rs.addArb( { host: "127.0.0.1:27002"} )

 

这个命令可以参考下官网的介绍:https://docs.mongodb.com/manual/reference/command/replSetInitiate/   好了,现在大致配置好了,接下

来我们用rs.Status()来查看下当前“主,备,仲裁”的分布情况。

 

从图中你应该看到了【27000】成为了主服务器,【27001】成为了备服务器,【27002】成为了仲裁服务器,到目前为止,搭建完成,是不是有

一个很爽的感觉呢???

 

三:使用驱动

既然mongodb的双机热备已经做好了,我们驱动也必须支持,这样我们才能够嗨,对伐???其实在配置中使用也很简单,里面有一个

MongoClientSettings,你需要配置一下”ReplicaSetName“和”Servers“列表即可,核心代码如下:

复制代码
 1         static MongoDBHelper()
 2         {
 3             var ips = connectionString.Split(';');
 4 
 5             var servicesList = new List<MongoServerAddress>();
 6 
 7             foreach (var ip in ips)
 8             {
 9                 var host = ip.Split(':')[0];
10                 var port = Convert.ToInt32(ip.Split(':')[1]);
11 
12                 servicesList.Add(new MongoServerAddress(host, port));
13             }
14 
15             setting = new MongoClientSettings();
16             setting.ReplicaSetName = "datamip";
17 
18             //集群中的服务器列表
19             setting.Servers = servicesList;
20         }
复制代码

 

其中ips的信息是配置在app.config中。

 <appSettings>
    <add key="mongodbServerList" value="127.0.0.1:27000;127.0.0.1:27001;127.0.0.1:27002"/>
  </appSettings>

 

然后我简单的封装了下mongodb。

复制代码
  1 namespace DataMipCRM.Common
  2 {
  3     public class MongoDBHelper<T>
  4     {
  5         private static readonly string connectionString = ConfigurationManager.AppSettings["mongodbServerList"];
  6 
  7         static MongoClientSettings setting = null;
  8         MongoServer server = null;
  9 
 10         public string tableName = "person";
 11 
 12         public string databaseName = "test";
 13 
 14         static MongoDBHelper()
 15         {
 16             var ips = connectionString.Split(';');
 17 
 18             var servicesList = new List<MongoServerAddress>();
 19 
 20             foreach (var ip in ips)
 21             {
 22                 var host = ip.Split(':')[0];
 23                 var port = Convert.ToInt32(ip.Split(':')[1]);
 24 
 25                 servicesList.Add(new MongoServerAddress(host, port));
 26             }
 27 
 28             setting = new MongoClientSettings();
 29             setting.ReplicaSetName = "datamip";
 30 
 31             //集群中的服务器列表
 32             setting.Servers = servicesList;
 33         }
 34 
 35         public MongoDBHelper(string databaseName, string tableName)
 36         {
 37             this.databaseName = databaseName;
 38             this.tableName = tableName;
 39 
 40             server = new MongoClient(setting).GetServer();
 41         }
 42 
 43         public bool Remove(Expression<Func<T, bool>> func)
 44         {
 45             try
 46             {
 47                 var database = server.GetDatabase(databaseName);
 48 
 49                 var collection = database.GetCollection<T>(tableName);
 50 
 51                 var query = Query<T>.Where(func);
 52 
 53                 var result = collection.Remove(query);
 54 
 55                 return result.Response["ok"].AsInt32 > 0 ? true : false;
 56             }
 57             catch (Exception ex)
 58             {
 59                 return false;
 60             }
 61         }
 62 
 63         public bool RemoveAll()
 64         {
 65             try
 66             {
 67                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
 68 
 69                 var collection = database.GetCollection<T>(tableName);
 70 
 71                 var result = collection.RemoveAll();
 72 
 73                 return result.Response["ok"].AsInt32 > 0 ? true : false;
 74             }
 75             catch (Exception ex)
 76             {
 77                 return false;
 78             }
 79         }
 80 
 81         #region 单条插入
 82         /// <summary>
 83         /// 单条插入
 84         /// </summary>
 85         /// <typeparam name="T"></typeparam>
 86         /// <param name="t"></param>
 87         public bool Insert(T t)
 88         {
 89             try
 90             {
 91                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
 92 
 93                 var collection = database.GetCollection<T>(tableName);
 94 
 95                 var result = collection.Insert(t);
 96                 return result.DocumentsAffected > 0;
 97             }
 98             catch (Exception ex)
 99             {
100                 return false;
101             }
102         }
103         #endregion
104 
105         #region 单条覆盖,如果不存在插入,如果存在覆盖
106         /// <summary>
107         /// 单条覆盖,如果不存在插入,如果存在覆盖
108         /// </summary>
109         /// <typeparam name="T"></typeparam>
110         /// <param name="t"></param>
111         public bool Save(T t)
112         {
113             try
114             {
115                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
116 
117                 var collection = database.GetCollection<T>(tableName);
118                 var result = collection.Save(t);
119                 return result.DocumentsAffected > 0;
120             }
121             catch (Exception ex)
122             {
123                 return false;
124             }
125         }
126         #endregion
127 
128         #region 批量插入
129         /// <summary>
130         /// 批量插入
131         /// </summary>
132         /// <typeparam name="T"></typeparam>
133         /// <param name="t"></param>
134         public bool Insert(IEnumerable<T> t)
135         {
136             try
137             {
138                 var database = server.GetDatabase(databaseName);   //mongodb中的数据库
139 
140                 var collection = database.GetCollection<T>(tableName);
141 
142                 collection.InsertBatch(t);
143 
144                 return true;
145             }
146             catch (Exception ex)
147             {
148                 return false;
149             }
150         }
151         #endregion
152 
153         #region 批量查询
154 
155         public List<T> Search(Expression<Func<T, bool>> func, bool forcemaster = false)
156         {
157             var list = new List<T>();
158 
159             try
160             {
161                 //是否强制使用 “主服务器”
162                 if (forcemaster)
163                 {
164                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
165 
166                     var collection = database.GetCollection<T>(tableName);
167                     list = collection.Find(Query<T>.Where(func)).ToList();
168                 }
169                 else
170                 {
171                     var database = server.GetDatabase(databaseName);    //mongodb中的数据库
172 
173                     var collection = database.GetCollection<T>(tableName);
174 
175                     list = collection.Find(Query<T>.Where(func)).ToList();
176                 }
177             }
178             catch (Exception ex)
179             {
180                 throw;
181             }
182 
183             return list;
184         }
185 
186         #endregion
187 
188         #region 单条查询
189         /// <summary>
190         /// 单条查询
191         /// </summary>
192         public T SearchOne(Expression<Func<T, bool>> func, bool forcemaster = false)
193         {
194             T t = default(T);
195 
196             try
197             {
198                 if (forcemaster)
199                 {
200                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
201 
202                     var collection = database.GetCollection<T>(tableName);
203 
204                     t = collection.FindOne(Query<T>.Where(func));
205                 }
206                 else
207                 {
208                     var database = server.GetDatabase(databaseName);   //mongodb中的数据库
209 
210                     var collection = database.GetCollection<T>(tableName);
211 
212                     t = collection.FindOne(Query<T>.Where(func));
213                 }
214 
215                 return t;
216             }
217             catch (Exception ex)
218             {
219                 return t;
220             }
221         }
222         #endregion
223 
224         /// <summary>
225         /// 查询所有数据
226         /// </summary>
227         /// <returns></returns>
228         public List<T> SearchAll()
229         {
230             var list = new List<T>();
231 
232             try
233             {
234                 var database = server.GetDatabase(databaseName);    //mongodb中的数据库
235 
236                 var collection = database.GetCollection<T>(tableName);
237 
238                 list = collection.FindAll().ToList();
239 
240                 return list;
241             }
242             catch (Exception ex)
243             {
244                 return list;
245             }
246         }
247     }
248 }
复制代码

 

四:测试一下

1. 首先向mongodb中插入一条记录,dbname=mydb, tablename=test,插入后我们用mongodUVE看一下数据:

复制代码
 1 namespace ConsoleApplication2
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 7             MongoDBHelper<MongodbCustomerModel> helper = new MongoDBHelper<MongodbCustomerModel>("mydb", "test");
 8 
 9             helper.Save(new MongodbCustomerModel()
10             {
11                 SendLastTime = DateTime.Now,
12                 ShopID = 1
13             });
14         }
15     }
16 
17     public class MongodbCustomerModel
18     {
19         public ObjectId _id { get; set; }
20 
21         public int ShopID { get; set; }
22 
23         public DateTime SendLastTime { get; set; }
24     }
25 }
复制代码

 

2. 然后我把【27000】 这个primary关闭掉,通过rs.Status看看“主备情况”。

 

3. 接下来,我们继续用mongodbHelper执行一下search,看是否能捞取到数据,如果可以,说明一台机器挂了没关系,这个“主备集群”还是活的。

 

是不是很牛逼的感觉,虽然挂了一台,我的客户端程序还是可以继续从mognodb中获取到刚才插入的数据,好了,大概就说这么多,洗洗睡了,