Django分库分表

·  阅读 2459
Django分库分表

Django分库分表

1. Django分表方案

当系统数据越来越多的时候,查询变得缓慢,即使加了索引,由于表数据的增加,索引的维护也会成为数据库性能的限制问题,所以此时可以通过分表,将数据通过某种准则分别存储到不同的表中,以实现缓解单表的压力。

分表的方法大部分都是通过主键id取数据库分表个数的余。最简单的方法就是定义多个Model对象,然后通过一个map的映射,当我们获取具体的Model的时候,直接就通过id与表个数取余,然后通过map的映射我们可以获取到具体的表model对象。

class User(models.Model): 
    user_id = models.IntegerField(primary_key=True)
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)

class User0(User):
    class Meta:
        db_table = 'user_0'
class User1(User):
    class Meta:
        db_table = 'user_1'
class User2(User):
    class Meta:
        db_table = 'user_2'
user_model_map = {
    0: User0,
    1: User1,
    2: User2,
}
table_num = 3
# 获取表的model
def get_user_db_model(user_id):
    key = user_id % table_num
    return user_model_map[key]
复制代码

但如果表数量躲到几百甚至上千,这种方案就很不使用。

所以我们使用第二种方案,首先我们需要思考为什么在我们使用User.objects.first()的时候,Django可以找到具体的User表,这是因为设置了Meta.db_table具体名称,django可以找到具体的表进行数据的查询。

如果是多张表呢,我们可以想到,可以动态的创建多个表的具体名称,这样的话,在我们程序运行过程中,只要我们传入一个id,此时可以动态的获取到具体的表的名称,就可以找到具体的表,实现具体的分表作用。

要想实现动态数据变更,就需要使用到反射,Python原生支持反射的,我们可以使用type完成新类的创建。实际上主要的功能就是获取表model的时候动态修改内部的Meta.db_table部分的信息即可。

SHARD_TABLE_NUM = 3
class User(models.Model):
    @classmethod
    def get_student_db_model(cls, user_id=None):
        suffix = user_id % SHARD_TABLE_NUM
        table_name = 'user_%s' % suffix
        # construct a private field _user_model_dict to store the model,
        # it can help to accelerate the speed of get model
        if table_name in cls._user_model_dict:
            return cls._user_model_dict[table_name]

        class Meta:
            db_table = table_name

        attrs = {
            '__module__': cls.__module__,
            'Meta': Meta
        }
				# the first param is obejct name
        # second: class
        # the class field info
        user_db_model = type(str('User_%s') % suffix, (cls,), attrs)
        cls._user_model_dict[table_name] = user_db_model
        return user_db_model

    _user_model_dict = {}  # help to reuse the model object
    id = models.AutoField(primary_key=True)
    user_name = models.CharField(max_length=256)
    password = models.CharField(max_length=256)

    class Meta:
        abstract = True
复制代码

上面的代码通过编写一个类方法,先获取到表的名称,具体的获取方法就是采用id取余的方法来实现的。在获取到表名之后,通过class Meta对象,最后通过attrs的属性装配,最后由type实现新类的构建。

def __init__(cls, what, bases=None, dict=None): 
  # known special case of type.__init__
  """
        type(object) -> the object's type
        type(name, bases, dict) -> a new type # 构建新的type即类对象
        # (copied from class doc)
        """
  pass
复制代码

最后就可以实现具体的分表操作,但是需要注意,当我们插入的时候,因为需要提前知道id,这个时候最好采用一个辅助的Model类来协助id的生成,便于我们后续具体分表的实施,具体表的设计如下:

# the sharding table of Django
class UserIndex(models.Model):
    id = models.AutoField(primary_key=True)

    class Meta:
        db_table = 'user_index_tab'
复制代码

2. Django分库方案

分库的方案有两种,

  • 采取路由的方式设置具体的app_label,按照app_label的不同分配到不同的库
  • 采用自己编写方法,在具体的Model中配置好相应的库从而实现分库

2.1 DB路由方式

DB路由方式,设置一个DB路由的规则,根据规则的不同,对应的数据库的读写会映射到不同的库上面,以User为例,假设sharding项目的数据存储到sharding库中,sharding_one项目的数据存储到sharding_one数据库中,此时可以编写一个DbRouter,如下

class DbRouter(object):
    def db_for_read(self, model, **hints):
        if model._meta.app_label == 'sharding_one': # 判断app_label标签,这个可以在model中设置
            return 'sharding_one'
        return None

    def db_for_write(self, model, **hints):
        if model._meta.app_label == 'sharding_one':
            return 'sharding_one'
        return None
复制代码

为什么不为sharding_one就返回None呢,因为这里仅有两个项目,一个对应着sharding库,一个对应着sharding_one库,而django程序有个默认库default,返回None的话表示直接对应sharding库。

具体的Model中的设置:

# sharding_one
class Meta:
  abstract = True
  app_label = 'sharding_one'
复制代码

这样最后只需要在不同的项目中执行数据读取或者写入操作,库的切换就通过DB路由切换到了设置的库,从而实现了分库的操作。

2.2 Config配置方式

采用Config配置方式是一种比较方便的形式,即在Model中配置一个内部类Config,而Config中的属性则对映射具体的写数据和读数据的库操作。

这种方式的话需要写一个获取DB节点的操作,可以使用objects.using('db_name')指定连接具体的数据库。

首先在model中添加具体的Config配置

class Config:
  db_for_read = 'sharding_one'
  db_for_write = 'sharding_one'
复制代码

写一个获取db节点的方法

这个方法先从Config中获取到具体的数据库节点名称,在指定自己使用当前的库

def get_db_obj(objects):
    db_name = objects.model.Config.db_for_write
    return objects.using(db_name)
复制代码

最后写入和查询的代码分别如下:

def search_user_service(user_id):
	# get_student_db_model()就是前面的分表方案中的设计,获取到具体的指定表的model信息,然后从中获取到objects
  # 然后通过这个表对象,指定具体的库即可,最后从库中查询出具体的数据
  obj = get_db_obj(User.get_student_db_model(user_id).objects)
  user = obj.first()
  return user
复制代码
def insert_user_service(user_name, password):
    index = UserIndex() # 这里是因为分表之后,需要插入数据的话,怎么提前获得到主键呢,采用user_index表获取一个自增的主键,或者按照自己设计的方式生成的主键
    index.save()
    user_id = index.id
    # 这里与之前一样,但是由于是插入,所以对象构造成功之后需要取出内部的model进行数据的填充操作
    model = get_db_obj(User.get_student_db_model(user_id=user_id).objects).model(user_id, user_name, password)
    try:
        model.save() # 最后数据保存即可
    except Exception as e:
        print "[insert_user] exception error %s" % e
复制代码

通过上面的方式我们可以实现具体的分库分表操作,这种方式比较有效,对于分库较多的操作,比如写主库,读从库的操作可以通过这个Config配置直接可以实现,而获取db的时候,需要多补写几个方法,就是指定使用db库的方法,这样看起来会更加的直观!

3. 小结

之前是看过学习java的分表操作,由于java比较成熟,各种三方工具包的引入,可以很轻松的完成分表以及分库操作,但对于Python而言,Django的ORM是不支持分库分表的,所以需要构造具体的分库分表逻辑,分表的话可以采用动态构造类Model的方式来实现,分库的话可以借助具体的DB路由的配置,编写路由配置类,来实现具体的库名称的获取,从而实现分库操作,同时我们还可以自己通过给Model添加config的属性,从而利用objects.using(db_name)的方式来获取具体的库,实现分库。

上面的用例sql脚本

-- User
create table user_0(
`id` int(20) not null primary key comment '主键id',
`user_name` varchar(256) not null comment '用户名',
`password` varchar(256) not null comment '用户密码'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- user_index
create table user_index_tab(
`id` int(20) not null auto_increment primary key comment '主键id'
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
复制代码

Keep thinking, keep coding! 2021年06月19日17:43:44 写于深圳

分类:
后端
标签:
收藏成功!
已添加到「」, 点击更改