.Net使用分表分库框架ShardingCore实现多字段分片

介绍

本期主角: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

到此这篇关于.net使用分表分库框架shardingcore实现多字段分片的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持。