.NET Core中反解ObjectId

前言

在设计数据库的时候,我们通常需要给业务数据表分配主键,很多时候,为了省事,我都是直接使用 GUID/UUID 的方式,但是在 MonggoDB 中,其内部实现了 ObjectId(以下统称为Oid)。并且在.NETCore 的驱动中给出了源代码的实现。

经过仔细研读官方的源码后发现,其实现原理非常的简单易学,在最新的版本中,阉割了 UnPack 函数,可能是官方觉得解包是没什么太多的使用场景的,但是我们认为,对于数据溯源来说,解包的操作实在是非常有必要,特别是在目前的微服务大流行的背景下。

为此,在参考官方代码的基础上进行了部分改进,增加了一下自己的需求。本示例代码增加了解包的操作、对 string 的隐式转换、提供读取解包后数据的公开属性。

ObjectId 的数据结构

首先,我们来看 Oid 的数据结构的设计。

从上图可以看出,Oid 的数据结构主要由四个部分组成,分别是:Unix时间戳、机器名称、进程编号、自增编号。Oid 实际上是总长度为12个字节24的字符串,易记口诀为:4323,时间4字节,机器名3字节,进程编号2字节,自增编号3字节。

1、Unix时间戳:Unix时间戳以秒为记录单位,即从1970/1/1 00:00:00 开始到当前时间的总秒数。
2、机器名称:记录当前生产Oid的设备号
3、进程编号:当前运行Oid程序的编号
4、自增编号:在当前秒内,每次调用都将自动增长(已实现线程安全)

根据算法可知,当前一秒内产生的最大 id 数量为 2^24=16777216 条记录,所以无需过多担心 id 碰撞的问题。

实现思路

先来看一下代码实现后的类结构图。

通过上图可以发现,类图主要由两部分组成,ObjectId/ObjectIdFactory,在类 ObjectId 中,主要实现了生产、解包、计算、转换、公开数据结构等操作,而 ObjectIdFactory 只有一个功能,就是生产 Oid。

所以,我们知道,类 ObjectId 中的 NewId 实际是调用了 ObjectIdFactory 的 NewId 方法。

为了生产效率的问题,在 ObjectId 中声明了静态的 ObjectIdFactory 对象,有一些初始化的工作需要在程序启动的时候在 ObjectIdFactory 的构造函数内部完成,比如获取机器名称和进程编号,这些都是一次性的工作。

类 ObjectIdFactory 的代码实现

public class ObjectIdFactory
{
  private int increment;
  private readonly byte[] pidHex;
  private readonly byte[] machineHash;
  private readonly UTF8Encoding utf8 = new UTF8Encoding(false);
  private readonly DateTime unixEpoch = new DateTime(1970, 1, 1, 0, 0, 0, DateTimeKind.Utc);

  public ObjectIdFactory()
  {
    MD5 md5 = MD5.Create();
    machineHash = md5.ComputeHash(utf8.GetBytes(Dns.GetHostName()));
    pidHex = BitConverter.GetBytes(Process.GetCurrentProcess().Id);
    Array.Reverse(pidHex);
  }

  /// <summary>
  /// 产生一个新的 24 位唯一编号
  /// </summary>
  /// <returns></returns>
  public ObjectId NewId()
  {
    int copyIdx = 0;
    byte[] hex = new byte[12];
    byte[] time = BitConverter.GetBytes(GetTimestamp());
    Array.Reverse(time);
    Array.Copy(time, 0, hex, copyIdx, 4);
    copyIdx += 4;

    Array.Copy(machineHash, 0, hex, copyIdx, 3);
    copyIdx += 3;

    Array.Copy(pidHex, 2, hex, copyIdx, 2);
    copyIdx += 2;

    byte[] inc = BitConverter.GetBytes(GetIncrement());
    Array.Reverse(inc);
    Array.Copy(inc, 1, hex, copyIdx, 3);

    return new ObjectId(hex);
  }

  private int GetIncrement() => System.Threading.Interlocked.Increment(ref increment);
  private int GetTimestamp() => Convert.ToInt32(Math.Floor((DateTime.UtcNow - unixEpoch).TotalSeconds));
}

ObjectIdFactory 的内部实现非常的简单,但是也是整个 Oid 程序的核心,在构造函数中获取机器名称和进程编号以备后续生产使用,在核心方法 NewId 中,依次将 Timestamp、machineHash、pidHex、increment 写入数组中,最后调用 new ObjectId(hex) 返回生产好的 Oid。

类 ObjectId 的代码实现

类 ObjectId 的代码实现
public class ObjectId
{
  private readonly static ObjectIdFactory factory = new ObjectIdFactory();

  public ObjectId(byte[] hexData)
  {
    this.Hex = hexData;
    ReverseHex();
  }

  public override string ToString()
  {
    if (Hex == null)
      Hex = new byte[12];
    StringBuilder hexText = new StringBuilder();
    for (int i = 0; i < this.Hex.Length; i++)
    {
      hexText.Append(this.Hex[i].ToString("x2"));
    }
    return hexText.ToString();
  }

  public override int GetHashCode() => ToString().GetHashCode();

  public ObjectId(string value)
  {
    if (string.IsNullOrEmpty(value)) throw new ArgumentNullException("value");
    if (value.Length != 24) throw new ArgumentOutOfRangeException("value should be 24 characters");
    Hex = new byte[12];
    for (int i = 0; i < value.Length; i += 2)
    {
      try
      {
        Hex[i / 2] = Convert.ToByte(value.Substring(i, 2), 16);
      }
      catch
      {
        Hex[i / 2] = 0;
      }
    }
    ReverseHex();
  }

  private void ReverseHex()
  {
    int copyIdx = 0;
    byte[] time = new byte[4];
    Array.Copy(Hex, copyIdx, time, 0, 4);
    Array.Reverse(time);
    this.Timestamp = BitConverter.ToInt32(time, 0);
    copyIdx += 4;
    byte[] mid = new byte[4];
    Array.Copy(Hex, copyIdx, mid, 0, 3);
    this.Machine = BitConverter.ToInt32(mid, 0);
    copyIdx += 3;
    byte[] pids = new byte[4];
    Array.Copy(Hex, copyIdx, pids, 0, 2);
    Array.Reverse(pids);
    this.ProcessId = BitConverter.ToInt32(pids, 0);
    copyIdx += 2;
    byte[] inc = new byte[4];
    Array.Copy(Hex, copyIdx, inc, 0, 3);
    Array.Reverse(inc);
    this.Increment = BitConverter.ToInt32(inc, 0);
  }

  public static ObjectId NewId() => factory.NewId();

  public int CompareTo(ObjectId other)
  {
    if (other is null)
      return 1;
    for (int i = 0; i < Hex.Length; i++)
    {
      if (Hex[i] < other.Hex[i])
        return -1;
      else if (Hex[i] > other.Hex[i])
        return 1;
    }
    return 0;
  }

  public bool Equals(ObjectId other) => CompareTo(other) == 0;
  public static bool operator <(ObjectId a, ObjectId b) => a.CompareTo(b) < 0;
  public static bool operator <=(ObjectId a, ObjectId b) => a.CompareTo(b) <= 0;
  public static bool operator ==(ObjectId a, ObjectId b) => a.Equals(b);
  public override bool Equals(object obj) => base.Equals(obj);
  public static bool operator !=(ObjectId a, ObjectId b) => !(a == b);
  public static bool operator >=(ObjectId a, ObjectId b) => a.CompareTo(b) >= 0;
  public static bool operator >(ObjectId a, ObjectId b) => a.CompareTo(b) > 0;
  public static implicit operator string(ObjectId objectId) => objectId.ToString();
  public static implicit operator ObjectId(string objectId) => new ObjectId(objectId);
  public static ObjectId Empty { get { return new ObjectId("000000000000000000000000"); } }
  public byte[] Hex { get; private set; }
  public int Timestamp { get; private set; }
  public int Machine { get; private set; }
  public int ProcessId { get; private set; }
  public int Increment { get; private set; }
}

ObjectId 的代码量看起来稍微多一些,但是实际上,核心的实现方法就只有 ReverseHex() 方法,该方法在内部反向了 ObjectIdFactory.NewId() 的过程,使得调用者可以通过调用 ObjectId.Timestamp 等公开属性反向追溯 Oid 的生产过程。

其它的对象比较、到 string/ObjectId 的隐式转换,则是一些语法糖式的工作,都是为了提高编码效率的。

需要注意的是,在类 ObjectId 的内部,创建了静态对象 ObjectIdFactory,我们还记得在 ObjectIdFactory 的构造函数内部的初始化工作,这里创建的静态对象,也是为了提高生产效率的设计。

调用示例

在完成了代码改造后,我们就可以对改造后的代码进行调用测试,以验证程序的正确性。

NewId

我们尝试生产一组 Oid 看看效果。

for (int i = 0; i < 100; i++)
{
  var oid = ObjectId.NewId();
  Console.WriteLine(oid);
}

输出

通过上图可以看到,输出的这部分 Oid 都是有序的,这应该也可以成为替换 GUID/UUID 的一个理由。

生产/解包

var sourceId = ObjectId.NewId();
var reverseId = new ObjectId(sourceId);

通过解包可以看出,上图两个红框内的值是一致的,解包成功!

隐式转换

var sourceId = ObjectId.NewId();

// 转换为 string
var stringId = sourceId;
string userId= ObjectId.NewId();

// 转换为 ObjectId
ObjectId id = stringId;

隐式转换可以提高编码效率哟!

结束语

通过上面的代码实现,融入了一些自己的需求。现在,可以通过解包来实现业务的追踪和日志的排查,在某些场景下,是非常有帮助的,增加的隐式转换语法糖,也可以让编码效率得到提高;同时将代码优化到 .NETCore 3.1,也使用了一些 C# 的语法糖。

以上就是.NET Core中实现ObjectId反解的方法的详细内容,更多关于.NET Core ObjectId反解的资料请关注我们其它相关文章!

(0)

相关推荐

  • 深究从MongoDB的ObjectId中获取时间信息

    MongoDB默认使用_id字段作为主键,类型为ObjectId.ObjectId的生成有一定的规则,详情可以查看这篇文章 - MongoDB深究之ObjectId.如果你在写入数据库的时候忘记写入创建时间,不用担心,完全可以通过_id字段的值来还原当时的时间.看下面的mongodb script脚本: db.getCollection('fees').find({}).forEach(function(item){ var _str = item._id.toString().substr(1

  • python根据时间生成mongodb的ObjectId的方法

    本文实例讲述了python根据时间生成mongodb的ObjectId的方法.分享给大家供大家参考.具体分析如下: mongodb的_id为ObjectId类型,ObjectId内是包含时间戳信息的,这样我们在保存数据的时候就不需要再单独记录一个添加时间了,如果需要按照时间查询,我们可以先把时间变化成可查询的ObjectId,再通过_id字段查询,由于mongodb的_id是主键,查询效率非常高.下面的函数给出了如何把时间换算成ObjectId,同时该函数还可以指定时间的偏移量,比如多少天前的时

  • Node.js使用MongoDB的ObjectId作为查询条件的方法

    当往MongoDB中插入一条数据时,会自动生成ObjectId作为数据的主键. 那么如何通过ObjectId来做数据的唯一查询呢? 在MongoDB中插入一条数据 在MongoDB中插入一条如下结构的数据: { _id: 5d6a32389c825e24106624e4, title: 'GitHub 上有什么好玩的项目', content: '上个月有水友私信问我,GitHub 上有没有比较好玩的项目可以推荐?我跟他说:"有,过两天我整理一下".\n' + '\n' + '然而,一个

  • java查询mongodb中的objectid示例

    找了很久查询objectid的方法都是错的,用mongovue能查询出来,但就是用java不知道怎么查询 1.mongovue里的查询方式: 复制代码 代码如下: {"_id" : ObjectId("5326bfc0e6f780b21635248f")} 2.纯mongodb里的查询方式: 复制代码 代码如下: db.collect.find({ "_id" : ObjectId("5326bfc0e6f780b21635248f&q

  • MongoDB中ObjectId的误区及引起的一系列问题

    近期对两个应用进行改造,在上线过程中出现一系列问题(其中一部分是由于ObjectId误区导致的) 先来了解下ObjectId: TimeStamp 前 4位是一个unix的时间戳,是一个int类别,我们将上面的例子中的objectid的前4位进行提取"4df2dcec",然后再将他们安装十六进制 专为十进制:"1307761900",这个数字就是一个时间戳,为了让效果更佳明显,我们将这个时间戳转换成我们习惯的时间格式(精确到秒) $ date -d '1970-01

  • 关于C#生成MongoDB中ObjectId的实现方法

    ObjectId介绍在MongoDB中,文档(document)在集合(collection)中的存储需要一个唯一的_id字段作为主键.这个_id默认使用ObjectId来定义,因为ObjectId定义的足够短小,并尽最大可能的保持唯一性,同时能被快速的生成. ObjectId 是一个 12 Bytes 的 BSON 类型,其包含:1.4 Bytes 自纪元时间开始的秒数2.3 Bytes 机器描述符3.2 Bytes 进程ID4.3 Bytes 随机数 从定义可以看出,在同一秒内,在不同的机器

  • python将MongoDB里的ObjectId转换为时间戳的方法

    本文实例讲述了python将MongoDB里的ObjectId转换为时间戳的方法.分享给大家供大家参考.具体分析如下: MongoDB里的_id字段前四位是时间戳的16进制表示,通过Python可以很容易从_id中提取出时间戳来 def timestamp_from_objectid(objectid): result = 0 try: result = time.mktime(objectid.generation_time.timetuple()) except: pass return r

  • .NET Core中反解ObjectId

    前言 在设计数据库的时候,我们通常需要给业务数据表分配主键,很多时候,为了省事,我都是直接使用 GUID/UUID 的方式,但是在 MonggoDB 中,其内部实现了 ObjectId(以下统称为Oid).并且在.NETCore 的驱动中给出了源代码的实现. 经过仔细研读官方的源码后发现,其实现原理非常的简单易学,在最新的版本中,阉割了 UnPack 函数,可能是官方觉得解包是没什么太多的使用场景的,但是我们认为,对于数据溯源来说,解包的操作实在是非常有必要,特别是在目前的微服务大流行的背景下.

  • 详解ASP.Net Core 中如何借助CSRedis实现一个安全高效的分布式锁

    引言:最近回头看了看开发的.Net Core 2.1项目的复盘总结,其中在多处用到Redis实现的分布式锁,虽然在OnResultExecuting方法中做了防止死锁的处理,但在某些场景下还是会发生死锁的问题,下面我只展示部分代码: 问题: (1)这里setnx设置的值"1",我想问,你最后del的这个值一定是你自己创建的吗? (2)图中标注的步骤1和步骤2不是原子操作,会有死锁的概率吗? 大家可以思考一下先,下面让我们带着这两个问题往下看,下面介绍一下使用Redis实现分布式锁常用的

  • .NET Core中Object Pool的多种用法详解

    前言 复用,是一个重要的话题,也是我们日常开发中经常遇到的,不可避免的问题. 举个最为简单,大家最为熟悉的例子,数据库连接池,就是复用数据库连接. 那么复用的意义在那里呢? 简单来说就是减少不必要的资源损耗. 除了数据库连接,可能在不同的情景或需求下,还会有很多其他对象需要进行复用,这个时候就会有所谓的 Object Pool(对象池). 小伙伴们应该也自己实现过类似的功能,或用ConcurrentBag,或用ConcurrentQueue,或用其他方案. 这也里分享一个在微软文档中的实现 Ho

  • ASP.NET Core中如何使用表达式树创建URL详解

    表达式树(Expression Tree) 表达式树是不可执行的代码,它只是用于表示一种树状的数据结构,树上的每一个节点都表示为某种表达式类型,大概有25种表达式类型,它们都派生自Expression类.创建表达式树具体有两个优势: 1.对表达式树的代码进行编辑修改,使表达式树中的代码变成动态代码,根据不同的数据库修改树上的代码逻辑从而达到动态切换数据库查询语句的目的,用表达式树可以动态构建针对不同数据库的查询语句. 2.完成类似反射访问未知对象的属性,通过动态构造表达式树,生成委托. 当我们在

  • PyTorch中反卷积的用法详解

    pytorch中的 2D 卷积层 和 2D 反卷积层 函数分别如下: class torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, groups=1, bias=True) class torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=1, padding=0, output_padding=0, b

  • 详解在.net core中完美解决多租户分库分表的问题

    前几天有人想做一个多租户的平台,每个租户一个库,可以进行水平扩展,应用端根据登录信息,切换到不同的租户库 计划用ef core实现,他们说做不出来,需要动态创建dbContext,不好实现 然而这个使用CRL很轻松就能解决了 以下为演示数据库,有两个库testdb和testdb2,查询结果如下 目标: 根据传入登录信息连不不同的库,查询返回结果,如登录人为01,返回d1.default,登录人为02 返回 d2.default 实际上这个需求就是分库分表的实现,通过设置数据库/表映射关系,根据传

  • 详解ASP.NET Core中配置监听URLs的五种方式

    默认情况下,ASP. NET Core应用会监听一下2个Url: http://localhost:5000 https://localhost:5001 在本篇博文中,我将展示如何使用五种不同的方式改变应用监听的URLs. 在ASP.NET Core项目启动时,有多种配置监听Url的方式,在我之前的一篇博客中,已经展示了在ASP.NET Core 1.0中如何应用不同的方式配置,在ASP.NET Core 3.x中,大部分方式还是一样的. UseUrls() - 在Program.cs配置程序

  • 详解如何在C#/.NET Core中使用责任链模式

    最近我有一个朋友在研究经典的"Gang Of Four"设计模式.他经常来询问我在实际业务应用中使用了哪些设计模式.单例模式.工厂模式.中介者模式 - 都是我之前使用过,甚至写过相关文章的模式.但是有一种模式是我还没有写过文章,即责任链模式. 什么是责任链?# 责任链模式(之前我经常称之为命令链模式)是一种允许以使用分层方式"处理"对象的模式.在维基百科中的经典定义是 在面向对象设计中,责任链模式是一种由命令对象源及其一系列处理对象组成的设计模式.每个处理对象包含了

  • ASP.NET Core中的配置详解

    ASP.NET Core 提供了一个灵活可扩展,基于键值的配置系统. 但是配置系统独立于ASP.NET Core是Microsoft.Extensions 类库的部分. 它可以用于任何类型的应用程序 1.以键-值对的形式读取配置 appsettings.json 文件: { "Position": { "Title": "编辑器", "Name": "Joe Smith" }, "MyKey&qu

  • 详解如何在ASP.NET Core中编写高效的控制器

    通过遵循最佳实践,可以编写更好的控制器.所谓的"瘦"控制器(指代码更少.职责更少的控制器)更容易阅读和维护.而且,一旦你的控制器很瘦,可能就不需要对它们进行太多测试了.相反,你可以专注于测试业务逻辑和数据访问代码.瘦控制器的另一个优点是,它更容易维护控制器的多个版本. 这篇文章讨论了使控制器变胖的坏习惯,然后探索了使控制器变瘦和易于管理的方法.我列出编写控制器的最佳实践可能并不全面,但我已经讨论了最重要的一些,并在适当的情况下提供了相关的源代码.在接下来的几节中,我们将研究什么是胖控制

随机推荐