.NET 5 全自动分表组件，.NET 分表方案 ，分表架构与设计
Posted 孙凯旋
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了.NET 5 全自动分表组件，.NET 分表方案 ，分表架构与设计相关的知识，希望对你有一定的参考价值。
一、疑问&目的
1.1 分表使用场景
（1）可扩展架构设计，比如一个ERP用5年不卡，到了10就卡了因为数据太多了，这个时候很多人都是备份然后清空数据，这个工作大并且麻烦，以前的数据很难在使用
（2） 数据量太多 ，例如每天都有 几十上百万的数据进入库，如果不分表后面查询将会非常缓慢
(3) 性能瓶颈 ，数据库现有数据超过1个亿，很多情况下索引会莫名失效，性能大大下降，如果使用分表，我们只需要针对一个分表进行操作性能大大提升
1.2 我的目的
说到ORM很多会想到EF Core Dapper SqlSugar Chloe Freesql等，但是说到分表组件或许者大家想不到一个名词
我写这一篇文章最大的目的是想大家记住 全自动的分表组件 【 SqlSugar 】
没错SqlSugar是一个ORM框架，并且已经完美支持了自动分表 ，希望你能喜欢
二、SqlSugar分表优势
2.1 简单
CURD和分表一体化 ，小白也能很好的使用分表，只要会使用 ORM 就会使用分表 ，2者语法同步 就多 一个 .SplitTable
2.2 功能强大
支持 表结构同步，自动建表，强大的查询语句，插入，更新，删除
2.3 组件化设计
默认集成了按 日、周、月、季、年的方式表, 比如，我想根据加密算法分表，或者根据多个字段分表，或者不满意现在的分表 都可以已扩展实现
//实现下面接口就能将自定义的分表集成到ORM中
public interface ISplitTableService
{
//1 根据现有表选出当前分表
List<SplitTableInfo> GetAllTables(ISqlSugarClient db,EntityInfo EntityInfo,List<DbTableInfo> tableInfos);
//2 获取表名
string GetTableName(ISqlSugarClient db, EntityInfo EntityInfo);
string GetTableName(ISqlSugarClient db, EntityInfo EntityInfo, SplitType type);
string GetTableName(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object fieldValue);
//3 获取分组字段的值
object GetFieldValue(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object entityValue);
}
//说白了重写接口分为3类，基本要的参数都有现成的，可以模仿我现有分表的代码轻松实现
三、 自带分表的使用
自带分表支持按年、按月、按日、按季、按周进行分表
3.1 定义实体
我们定义一个实体，主键不能用自增或者int ，设为long或者guid都可以，我例子就用自带的雪花ID实现分表
[SplitTable(SplitType.Year)]//按年分表 （自带分表支持 年、季、月、周、日）
[SugarTable("SplitTestTable_{year}{month}{day}")]//生成表名格式 3个变量必须要有
public class SplitTestTable
{
[SugarColumn(IsPrimaryKey =true)]
public long Id { get; set; }
public string Name { get; set; }
[SplitField] //分表字段 在插入的时候会根据这个字段插入哪个表，在更新删除的时候也能可方便的用这个字段找出相关表
public DateTime CreateTime { get; set; }
}
3.2 初始化和同步结构
（1）如果一张表没有 查询肯定会报错，所以程序启动时需要建一张表
（2）假如分了20张表，实体类发生变更，那么 20张表可以自动同步结构，与实体一致
db.CodeFirst.SplitTables().InitTables<SplitTestTable>(); //程序启动时加这一行
3.2 查询用法
（1）基础筛选
下面表达式中的tas可以对当前分表进行筛选，Take(3) 表示最近3张表，如果是按年那么就是最近3年的数据，按月就是最近3个月的数据
Db.Queryable<SplitTestTable>().Where(it => it.Name.Contains("a")).SplitTable(tas => tas.Take(3)).ToList();//先过滤在合并
Db.Queryable<SplitTestTable>().SplitTable(tas => tas.Take(3)).Where(it => it.Name.Contains("a")).ToList();//先合并在过滤
(2)精准筛选
根据分表字段的值可以精准的定位到具体是哪一个分表
比Take(N)性能要高出很多
var name=Db.SplitHelper<SplitTestTable>().GetTableName(data.CreateTime); Db.Queryable<SplitTestTable>().Where(it => it.Id==data.Id).SplitTable(tas => tas.InTableNames(name)).ToList();
（3）表达式过滤
Db.Queryable<SplitTestTable>().Where(it => it.Id==data.Id).SplitTable(tas => tas.Where(y=>y.TableName.Contains("2019"))).ToList();
(4) 联表查询
//分表使用联表查询
var list=db.Queryable<Order>()
.SplitTable(tabs=>tabs.Take(3))//Order表只取最近3张表和Custom JOIN
.LeftJoin<Custom>((o,c)=>o.CustomId==c.Id).Select((o,c)=>new { name=o.Name,cname=c.Name }).ToPageList(1,2);
(5) 分页查询
var count = 0;
db.Queryable<SplitTestTable>().Where(it => it.Name.Contains("a")).SplitTable(tas => tas.Take(3)).ToPageList(1,2,ref count);//
3.3 插入
因为我们用的是Long所以采用雪ID插入(guid也可以禁止使用自增列), 实体结构看上面 3.1
var data = new SplitTestTable()
{
CreateTime=Convert.ToDateTime("2019-12-1"),
Name="jack"
};
db.Insertable(data).SplitTable().ExecuteReturnSnowflakeId();//插入并返回雪花ID
因为我们是根据CreateTime进行的分表，生成的SQL语句如下：
INSERT INTO [SplitTestTable_20190101] --如果表不存在会自动建表
([Id],[Name],[CreateTime])
VALUES
(@Id,@Name,@CreateTime) ;
批量插入
var datas = new List<SplitTestTable>(){new SplitTestTable(){CreateTime=Convert.ToDateTime("2019-12-1"),Name="jack"} ,
new SplitTestTable(){CreateTime=Convert.ToDateTime("2022-02-1"),Name="jack"},
new SplitTestTable(){CreateTime=Convert.ToDateTime("2020-02-1"),Name="jack"},
new SplitTestTable(){CreateTime=Convert.ToDateTime("2021-12-1"),Name="jack"}};
db.Insertable(datas).SplitTable().ExecuteReturnSnowflakeIdList();//插入返回雪花ID集合
执行完生成的表
生成的Sql:
自动识别4条记录，分别插入4个不同的表中
3.4 删除数据
（1）懒人模式删除
最近3张表都执行一遍删除
db.Deleteable<SplitTestTable>().In(id).SplitTable(tas=>tas.Take(3)).ExecuteCommand();
生在的SQL如下：
DELETE FROM [SplitTestTable_20220101] WHERE [Id] IN (1454675372531515392) DELETE FROM [SplitTestTable_20210101] WHERE [Id] IN (1454675372531515392) DELETE FROM [SplitTestTable_20200101] WHERE [Id] IN (1454675372531515392)
（2）精准删除
相对于上面的操作性能更高，可以精准找到具体表
var deldata = new SplitTestTable()
{
Id = id,
CreateTime = DateTime.Now
};
var tableName = db.SplitHelper(deldata).GetTableNames();
db.Deleteable<SplitTestTable>().Where(deldata).SplitTable(tas=>tas.InTableNames(tableName)).ExecuteCommand();
生成的SQL如下:
DELETE FROM [SplitTestTable_20210101] WHERE [Id] IN (1454676863531089920)
3.5 更新数据
更新的用法基本上和删除一样
//更新近3张表
db.Updateable(deldata).SplitTable(tas=>tas.Take(3)).ExecuteCommand();
//精准找到表名并且更新数据
var tableName = db.SplitHelper(deldata).GetTableNames();
db.Updateable(deldata).SplitTable(tas => tas.InTableNames(tableName)).ExecuteCommand();
//通过表达式过滤出要更新的表
db.Updateable(deldata).SplitTable(tas => tas.Where(y=>y.TableName.Contains("_2019"))).ExecuteCommand();
四、 自定义分表使用
上面的分表功能是我们自带集成的，比如我想实现自定义的分表我该如何实现呢？
4.1 按首字母拼音分表
我们就写个按24个字母进行分表的小例子，来学习一下如何自定义分表
4.2 创建分表类
我们新建一个类继承成ISplitTableService 接口
public class WordSplitService : ISplitTableService
{
/// <summary>
/// 返回数据用于 tas 进行筛选
/// </summary>
/// <param name="db"></param>
/// <param name="EntityInfo"></param>
/// <param name="tableInfos"></param>
/// <returns></returns>
public List<SplitTableInfo> GetAllTables(ISqlSugarClient db, EntityInfo EntityInfo, List<DbTableInfo> tableInfos)
{
List<SplitTableInfo> result = new List<SplitTableInfo>();
foreach (var item in tableInfos)
{
if (item.Name.Contains(EntityInfo.DbTableName+"_First")) //区分标识如果不用正则符复杂一些，防止找错表
{
SplitTableInfo data = new SplitTableInfo()
{
TableName = item.Name //要用item.name不要写错了
};
result.Add(data);
}
}
return result.OrderBy(it=>it.TableName).ToList();
}
/// <summary>
/// 获取分表字段的值
/// </summary>
/// <param name="db"></param>
/// <param name="entityInfo"></param>
/// <param name="splitType"></param>
/// <param name="entityValue"></param>
/// <returns></returns>
public object GetFieldValue(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object entityValue)
{
var splitColumn = entityInfo.Columns.FirstOrDefault(it => it.PropertyInfo.GetCustomAttribute<SplitFieldAttribute>() != null);
var value = splitColumn.PropertyInfo.GetValue(entityValue, null);
return value;
}
/// <summary>
/// 默认表名
/// </summary>
/// <param name="db"></param>
/// <param name="EntityInfo"></param>
/// <returns></returns>
public string GetTableName(ISqlSugarClient db, EntityInfo entityInfo)
{
return entityInfo.DbTableName + "_FirstA";
}
public string GetTableName(ISqlSugarClient db, EntityInfo entityInfo, SplitType type)
{
return entityInfo.DbTableName + "_FirstA";//目前模式少不需要分类(自带的有 日、周、月、季、年等进行区分)
}
public string GetTableName(ISqlSugarClient db, EntityInfo entityInfo, SplitType splitType, object fieldValue)
{
return entityInfo.DbTableName + "_First" + GetFirstCode(fieldValue+""); //根据值按首字母
}
#region 获取首字母
/// <summary>
/// 在指定的字符串列表CnStr中检索符合拼音索引字符串
/// </summary>
/// <param name="CnStr">汉字字符串</param>
/// <returns>相对应的汉语拼音首字母串</returns>
private static string GetFirstCode(string CnStr)
{
string Surname = CnStr.Substring(0, 1);
string strTemp = GetSpellCode(Surname);
return strTemp;
}
/// <summary>
/// 得到一个汉字的拼音第一个字母，如果是一个英文字母则直接返回大写字母
/// </summary>
/// <param name="CnChar">单个汉字</param>
/// <returns>单个大写字母</returns>
private static string GetSpellCode(string CnChar)
{
long iCnChar;
byte[] arrCN = System.Text.Encoding.Default.GetBytes(CnChar);
//如果是字母，则直接返回
if (arrCN.Length == 1)
{
CnChar = CnChar.ToUpper();
}
else
{
int area = (short)arrCN[0];
int pos = (short)arrCN[1];
iCnChar = (area << 8) + pos;
// iCnChar match the constant
string letter = "ABCDEFGHJKLMNOPQRSTWXYZ";
int[] areacode = { 45217, 45253, 45761, 46318, 46826, 47010, 47297, 47614, 48119, 49062, 49324, 49896, 50371, 50614, 50622, 50906, 51387, 51446, 52218, 52698, 52980, 53689, 54481, 55290 };
for (int i = 0; i < 23; i++)
{
if (areacode[i] <= iCnChar && iCnChar < areacode[i + 1])
{
CnChar = letter.Substring(i, 1);
break;
}
}
}
return CnChar;
}
#endregion
}
4.2 创建实体类
/// <summary>
/// 随便设置一个分类
/// </summary>
[SplitTable(SplitType._Custom01)]
public class WordTestTable
{
[SugarColumn(IsPrimaryKey =true)]
public long Id { get; set; }
[SplitField] //标识一下分表字段
public string Name { get; set; }
public DateTime CreateTime { get; set; }
}
4.3 使用自定义分表
代码：
//使用自定义分表
db.CurrentConnectionConfig.ConfigureExternalServices.SplitTableService =new WordSplitService();
//插入数据
db.Insertable(new WordTestTable(){CreateTime=DateTime.Now,Name="BC"}).SplitTable().ExecuteReturnSnowflakeId();
db.Insertable(new WordTestTable(){CreateTime = DateTime.Now,Name = "AC"}).SplitTable().ExecuteReturnSnowflakeId();
db.Insertable(new WordTestTable(){ CreateTime = DateTime.Now, Name = "ZBZ"}).SplitTable().ExecuteReturnSnowflakeId();
执行完数据库就多了3张表，因为是按首字母分的表 ，插入了3条记录自动创建了3张表
插入生成的SQL：
INSERT INTO [WordTestTable_FirstB]
([Id],[Name],[CreateTime])
VALUES
(@Id,@Name,@CreateTime) ;
INSERT INTO [WordTestTable_FirstA]
([Id],[Name],[CreateTime])
VALUES
(@Id,@Name,@CreateTime) ;
INSERT INTO [WordTestTable_FirstZ]
([Id],[Name],[CreateTime])
VALUES
(@Id,@Name,@CreateTime) ;
查询指定表
var listall = db.Queryable<WordTestTable>().Where(it => it.Name == "all").SplitTable(tas => tas.ContainsTableNames("_FirstA")).ToList();
生成的SQL:
SELECT * FROM (SELECT [Id],[Name],[CreateTime] FROM [WordTestTable_FirstA] WHERE ( [Name] = @Name0UnionAll1 )) unionTable
SqlSugar ORM 新语法
需要 NUGET安装 SqlSugarCore 5.0.4.3-proview-03
以前有些人说SQLSUGAR联表不优美，所以我也支了最优美联表语法：
新语法1：
简单的联表
var leftQueryable = db.Queryable<Custom>()
.LeftJoin<OrderItem>((c, i) => c.Id == i.ItemId)
.Select(c =>c).ToList();
SQL如下：
SELECT c.* FROM [Custom] c Left JOIN [OrderDetail] i ON ( [c].[Id] = [i].[ItemId] )
新语法2:
表 和 Queryable 进行联表
var rigtQueryable = db.Queryable<Custom>()
.LeftJoin<OrderItem>((o, i) => o.Id == i.ItemId)
.Select(o => o);
var List = db.Queryable<Order>()
.LeftJoin(rigtQueryable, (c, j) => c.CustomId == j.Id)
.Select(c => c).ToList();
SQL如下：
SELECT c.* FROM [Order] c Left JOIN (SELECT o.* FROM [Custom] o Left JOIN [OrderDetail] i ON ( [o].[Id] = [i].[ItemId] ) ) j ON ( [c].[CustomId] = [j].[Id] )
新语法3
Queryable 和表 进行联表
var leftQueryable = db.Queryable<Custom>()
.LeftJoin<OrderItem>((c, i) => c.Id == i.ItemId)
.Select(c =>c) ;
var List = db.Queryable(leftQueryable)
.LeftJoin<Order>((o, cu) => o.Id == cu.Id)
.Select(o => o).ToList();
SQL如下：
SELECT o.* FROM (SELECT * FROM (SELECT c.* FROM [Custom] c Left JOIN [OrderDetail] i ON ( [c].[Id] = [i].[ItemId] ) ) t ) o Left JOIN [Order] cu ON ( [o].[Id] = [cu].[Id] )
总结
SqlSugar 一直在创新，并且越来越好，相信分表功能，新的语法一定会让很多人喜欢
源码下载：
https://github.com/donet5/SqlSugar 没点关注的点一波关注 ，你们的赞或者一个star就是我们这些开源些的动力
Nuget 安装
.Net下你不得不看的分表分库解决方案-多字段分片
.Net下你不得不看的分表分库解决方案-多字段分片
介绍
本期主角:ShardingCore 一款ef-core下高性能、轻量级针对分表分库读写分离的解决方案，具有零依赖、零学习成本、零业务代码入侵
dotnet下唯一一款全自动分表,多字段分表框架,拥有高性能,零依赖、零学习成本、零业务代码入侵,并且支持读写分离动态分表分库,同一种路由可以完全自定义的新星组件,通过本框架你不但可以学到很多分片的思想和技巧,并且更能学到Expression的奇思妙用
你的star和点赞是我坚持下去的最大动力,一起为.net生态提供更好的解决方案
项目地址
- github地址 https://github.com/xuejmnet/sharding-core
- gitee地址 https://gitee.com/dotnetchina/sharding-core
背景
直接开门见山,你有没有这种情况你需要将一批数据用时间分片来进行存储比如订单表,订单表的分片字段是订单的创建时间,并且id是雪花id，订单编号是带时间信息的编号,因为.net下的所有分片方案几乎都是只支持单分片字段,所以当我们不使用分片字段查询也就是订单创建时间查询的话会带来全表查询,导致性能下降,譬如我想用雪花id或者订单编号进行查询，但是带来的却是内部低效的结果,针对这种情况是否有一个好的解决方案呢,有但是需要侵入业务代码,根据雪花id或者订单编号进行解析出对应的时间然后手动指定分片前提是框架支持手动指定.基于上述原因ShardingCore 带来了全新版本 x.3.2.x+ 支持多字段分片路由,并且拥有很完美的实现,废话不多说我们直接开始吧！！！！！！！！！！！
原理
我们现在假定一个很简单的场景,依然是订单时间按月分片,查询进行如下语句
//这边演示不使用雪花id因为雪花id很难在演示中展示所以使用订单编号进行演示格式:yyyyMMddHHmmss+new Random().Next(0,10000).ToString().PadLeft(4,\'0\')
var dateTime = new DateTime(2021, 11, 1);
var order = await _myDbContext.Set<Order>().Where(o => o.OrderNo== 202112201900001111&&o.CreateTime< dateTime).FirstOrDefaultAsync();
上述语句OrderNo会查询Order_202112这张表，然后时间索引会查询......Order_202108、Order_202109、Order_202110,然后两者取一个交集我们发现其实是没有结果的,这个时候应该是返回默认值null或者直接报错
这就是一个简单的原理
直接开始
接下来我将用订单编号和创建时间来为大演示,数据库采用sqlserver(你也可以换成任意efcore支持的数据库),其中编号格式yyyyMMddHHmmss+new Random().Next(0,10000).ToString().PadLeft(4,\'0\'),创建时间是DateTime格式并且创建时间按月分表,这边不采用雪花id是因为雪花id的实现会根据workid和centerid的不一样而出现不一样的效果,接下来我们通过简单的5步操作实现多字段分片
添加依赖
首先我们添加两个依赖,一个是ShardingCore一个EFCore.SqlServer
//请安装最新版本目前x.3.2.x+,第一个版本号6代表efcore的版本号
Install-Package ShardingCore -Version 6.3.2
Install-Package Microsoft.EntityFrameworkCore.SqlServer -Version 6.0.1
创建一个订单对象
public class Order
public string Id get; set;
public string OrderNo get; set;
public string Name get; set;
public DateTime CreateTime get; set;
创建DbContext
这边就简单的创建了一个dbcontext,并且设置了一下order如何映射到数据库,当然你可以采用attribute的方式而不是一定要fluentapi
/// <summary>
/// 如果需要支持分表必须要实现<see cref="IShardingTableDbContext"/>
/// </summary>
public class DefaultDbContext:AbstractShardingDbContext,IShardingTableDbContext
public DefaultDbContext(DbContextOptions options) : base(options)
protected override void OnModelCreating(ModelBuilder modelBuilder)
base.OnModelCreating(modelBuilder);
modelBuilder.Entity<Order>(o =>
o.HasKey(p => p.Id);
o.Property(p => p.OrderNo).IsRequired().HasMaxLength(128).IsUnicode(false);
o.Property(p => p.Name).IsRequired().HasMaxLength(128).IsUnicode(false);
o.ToTable(nameof(Order));
);
public IRouteTail RouteTail get; set;
创建分片路由
这边我们采用订单创建时间按月分表
public class OrderVirtualRoute : AbstractSimpleShardingMonthKeyDateTimeVirtualTableRoute<Order>
/// <summary>
/// 配置主分表字段是CreateTime,额外分表字段是OrderNo
/// </summary>
/// <param name="builder"></param>
public override void Configure(EntityMetadataTableBuilder<Order> builder)
builder.ShardingProperty(o => o.CreateTime);
builder.ShardingExtraProperty(o => o.OrderNo);
/// <summary>
/// 是否要在程序运行期间自动创建每月的表
/// </summary>
/// <returns></returns>
public override bool AutoCreateTableByTime()
return true;
/// <summary>
/// 分表从何时起创建
/// </summary>
/// <returns></returns>
public override DateTime GetBeginTime()
return new DateTime(2021, 9, 1);
/// <summary>
/// 配置额外分片路由规则
/// </summary>
/// <param name="shardingKey"></param>
/// <param name="shardingOperator"></param>
/// <param name="shardingPropertyName"></param>
/// <returns></returns>
public override Expression<Func<string, bool>> GetExtraRouteFilter(object shardingKey, ShardingOperatorEnum shardingOperator, string shardingPropertyName)
switch (shardingPropertyName)
case nameof(Order.OrderNo): return GetOrderNoRouteFilter(shardingKey, shardingOperator);
default: throw new NotImplementedException(shardingPropertyName);
/// <summary>
/// 订单编号的路由
/// </summary>
/// <param name="shardingKey"></param>
/// <param name="shardingOperator"></param>
/// <returns></returns>
private Expression<Func<string, bool>> GetOrderNoRouteFilter(object shardingKey,
ShardingOperatorEnum shardingOperator)
//将分表字段转成订单编号
var orderNo = shardingKey?.ToString() ?? string.Empty;
//判断订单编号是否是我们符合的格式
if (!CheckOrderNo(orderNo, out var orderTime))
//如果格式不一样就直接返回false那么本次查询因为是and链接的所以本次查询不会经过任何路由,可以有效的防止恶意攻击
return tail => false;
//当前时间的tail
var currentTail = TimeFormatToTail(orderTime);
//因为是按月分表所以获取下个月的时间判断id是否是在临界点创建的
var nextMonthFirstDay = ShardingCoreHelper.GetNextMonthFirstDay(DateTime.Now);
if (orderTime.AddSeconds(10) > nextMonthFirstDay)
var nextTail = TimeFormatToTail(nextMonthFirstDay);
return DoOrderNoFilter(shardingOperator, orderTime, currentTail, nextTail);
//因为是按月分表所以获取这个月月初的时间判断id是否是在临界点创建的
if (orderTime.AddSeconds(-10) < ShardingCoreHelper.GetCurrentMonthFirstDay(DateTime.Now))
//上个月tail
var previewTail = TimeFormatToTail(orderTime.AddSeconds(-10));
return DoOrderNoFilter(shardingOperator, orderTime, previewTail, currentTail);
return DoOrderNoFilter(shardingOperator, orderTime, currentTail, currentTail);
private Expression<Func<string, bool>> DoOrderNoFilter(ShardingOperatorEnum shardingOperator, DateTime shardingKey, string minTail, string maxTail)
switch (shardingOperator)
case ShardingOperatorEnum.GreaterThan:
case ShardingOperatorEnum.GreaterThanOrEqual:
return tail => String.Compare(tail, minTail, StringComparison.Ordinal) >= 0;
case ShardingOperatorEnum.LessThan:
var currentMonth = ShardingCoreHelper.GetCurrentMonthFirstDay(shardingKey);
//处于临界值 o=>o.time < [2021-01-01 00:00:00] 尾巴20210101不应该被返回
if (currentMonth == shardingKey)
return tail => String.Compare(tail, maxTail, StringComparison.Ordinal) < 0;
return tail => String.Compare(tail, maxTail, StringComparison.Ordinal) <= 0;
case ShardingOperatorEnum.LessThanOrEqual:
return tail => String.Compare(tail, maxTail, StringComparison.Ordinal) <= 0;
case ShardingOperatorEnum.Equal:
var isSame = minTail == maxTail;
if (isSame)
return tail => tail == minTail;
else
return tail => tail == minTail || tail == maxTail;
default:
return tail => true;
private bool CheckOrderNo(string orderNo, out DateTime orderTime)
//yyyyMMddHHmmss+new Random().Next(0,10000).ToString().PadLeft(4,\'0\')
if (orderNo.Length == 18)
if (DateTime.TryParseExact(orderNo.Substring(0, 14), "yyyyMMddHHmmss", CultureInfo.InvariantCulture,
DateTimeStyles.None, out var parseDateTime))
orderTime = parseDateTime;
return true;
orderTime = DateTime.MinValue;
return false;
这边我来讲解一下为什么用额外字段分片需要些这么多代码呢,其实是这样的因为你是用订单创建时间CreateTime来进行分片的那么CreateTime和OrderNo的赋值原理上说应该在系统里面是不可能实现同一时间赋值的肯定有先后关系可能是几微妙甚至几飞秒,但是为了消除这种差异这边采用了临界点兼容算法来实现，让我们来看下一下代码
var order=new Order()
//执行这边生成出来的id是2021-11-30 23:59:59.999.999
order.OrderNo=DateTime.Now.ToString("yyyyMMddHHmmss")+"xxx";
//business code //具体执行时间不确定,哪怕没有business code也没有办法保证两者生成的时间一致,当然如果你可以做到一致完全不需要这么复杂的编写
............
//执行这边生成出来的时间是2021-12-01 00:00:00.000.000
order.CreateTime=DateTime.Now;
当然系统里面采用了前后添加10秒是一个比较保守的估算你可以采用前后一秒甚至几百毫秒都是ok的,具体业务具体实现,因为大部分的创建时间可能是由框架在提交后才会生成而不是new Order的时候,当然也不排除这种情况,当然如果你只需要考虑equal一种情况可以只编写equal的判断而不需要全部情况都考虑
ShardingCore启动配置
ILoggerFactory efLogger = LoggerFactory.Create(builder =>
builder.AddFilter((category, level) => category == DbLoggerCategory.Database.Command.Name && level == LogLevel.Information).AddConsole();
);
var builder = WebApplication.CreateBuilder(args);
// Add services to the container.
builder.Services.AddControllers();
builder.Services.AddShardingDbContext<DefaultDbContext>((conStr,builder)=>builder
.UseSqlServer(conStr)
.UseLoggerFactory(efLogger)
)
.Begin(o =>
o.CreateShardingTableOnStart = true;
o.EnsureCreatedWithOutShardingTable = true;
).AddShardingTransaction((connection, builder) =>
builder.UseSqlServer(connection).UseLoggerFactory(efLogger);
).AddDefaultDataSource("ds0","Data Source=localhost;Initial Catalog=ShardingMultiProperties;Integrated Security=True;")//如果你是sqlserve只需要修改这边的链接字符串即可
.AddShardingTableRoute(op =>
op.AddShardingTableRoute<OrderVirtualRoute>();
)
.AddTableEnsureManager(sp=>new SqlServerTableEnsureManager<DefaultDbContext>())//告诉ShardingCore启动时有哪些表
.End();
var app = builder.Build();
// Configure the HTTP request pipeline.
app.Services.GetRequiredService<IShardingBootstrapper>().Start();
app.UseAuthorization();
app.MapControllers();
//额外添加一些种子数据
using (var serviceScope = app.Services.CreateScope())
var defaultDbContext = serviceScope.ServiceProvider.GetService<DefaultDbContext>();
if (!defaultDbContext.Set<Order>().Any())
var orders = new List<Order>(8);
var beginTime = new DateTime(2021, 9, 5);
for (int i = 0; i < 8; i++)
var orderNo = beginTime.ToString("yyyyMMddHHmmss") + i.ToString().PadLeft(4, \'0\');
orders.Add(new Order()
Id = Guid.NewGuid().ToString("n"),
CreateTime = beginTime,
Name = $"Order" + i,
OrderNo = orderNo
);
beginTime = beginTime.AddDays(1);
if (i % 2 == 1)
beginTime = beginTime.AddMonths(1);
defaultDbContext.AddRange(orders);
defaultDbContext.SaveChanges();
app.Run();
整个配置下来其实也就两个地方需要配置还是相对比较简单的,直接启动开始我们的测试模式
测试
默认配置下的测试
public async Task<IActionResult> Test1()
//订单名称全表扫描
Console.WriteLine("--------------Query Name Begin--------------");
var order1 = await _defaultDbContext.Set<Order>().Where(o=>o.Name=="Order3").FirstOrDefaultAsync();
Console.WriteLine("--------------Query Name End--------------");
//订单编号查询 精确定位
Console.WriteLine("--------------Query OrderNo Begin--------------");
var order2 = await _defaultDbContext.Set<Order>().Where(o=>o.OrderNo== "202110080000000003").FirstOrDefaultAsync();
Console.WriteLine("--------------Query OrderNo End--------------");
//创建时间查询 精确定位
Console.WriteLine("--------------Query OrderCreateTime Begin--------------");
var dateTime = new DateTime(2021,10,08);
var order4 = await _defaultDbContext.Set<Order>().Where(o=>o.CreateTime== dateTime).FirstOrDefaultAsync();
Console.WriteLine("--------------Query OrderCreateTime End--------------");
//订单编号in 精确定位
Console.WriteLine("--------------Query OrderNo Contains Begin--------------");
var orderNos = new string[] "202110080000000003", "202111090000000004" ;
var order5 = await _defaultDbContext.Set<Order>().Where(o=> orderNos.Contains(o.OrderNo)).ToListAsync();
Console.WriteLine("--------------Query OrderNo Contains End--------------");
//订单号和创建时间查询 精确定位 无路由结果 抛错或者返回default
Console.WriteLine("--------------Query OrderNo None Begin--------------");
var time = new DateTime(2021,11,1);
var order6 = await _defaultDbContext.Set<Order>().Where(o=> o.OrderNo== "202110080000000003"&&o.CreateTime> time).FirstOrDefaultAsync();
Console.WriteLine("--------------Query OrderNo None End--------------");
//非正确格式订单号 抛错或者返回default防止击穿数据库
Console.WriteLine("--------------Query OrderNo Not Check Begin--------------");
var order3 = await _defaultDbContext.Set<Order>().Where(o => o.OrderNo == "a02110080000000003").FirstOrDefaultAsync();
Console.WriteLine("--------------Query OrderNo Not Check End--------------");
return Ok();
测试结果
测试结果非常完美除了无法匹配路由的时候那么我们该如何设置呢
测试无路由返回默认值
builder.Services.AddShardingDbContext<DefaultDbContext>(...)
.Begin(o =>
....
o.ThrowIfQueryRouteNotMatch = false;//配置默认不抛出异常
)
我们再次来看下测试结果
为何我们测试是不经过数据库直接查询,原因就是在我们做各个属性分片交集的时候返回了空那么框架会选择抛出异常或者返回默认值两种选项,并且我们在编写路由的时候判断格式不正确返回 return tail => false;直接让所有的交集都是空所以不会进行一次无意义的数据库查询
总结
看到这边你应该已经看到了本框架的强大之处,本框架不但可以实现多字段分片还可以实现自定义分片,而不是单单按时间分片这么简单,我完全可以设置订单从2021年后的订单按月分片,2021年前的订单按年分片,对于sharding-core而言这简直轻而易举,但是据我所知.Net下目前除了我没有任何一款框架可以做到真正的全自动分片+多字段分片,所以我们在设计框架分片的时候尽可能的将有用的信息添加到一些无意义的字段上比如Id可以有效的解决很多在大数据下发生的问题,你可以简单理解为我加了一个索引并且附带了额外列,我加了一个id并且带了分表信息在里面,也可以完全设计出一款附带分库的属性到id里面使其可以支持分表分库
最后的最后
demo地址 https://github.com/xuejmnet/MultiShardingProperties
您都看到这边了确定不点个star或者赞吗,一款.Net不得不学的分库分表解决方案,简单理解为sharding-jdbc在.net中的实现并且支持更多特性和更优秀的数据聚合,拥有原生性能的97%,并且无业务侵入性,支持未分片的所有efcore原生查询
以上是关于.NET 5 全自动分表组件，.NET 分表方案 ，分表架构与设计的主要内容，如果未能解决你的问题，请参考以下文章