一種簡單易懂的 MyBatis 分庫分表方案

時間  2019-11-16
標籤 一種 簡單 易懂 mybatis 分庫 分表 方案 欄目 MyBatis 简体版
原文   原文鏈接

數據庫分庫分表除了使用中間件來代理請求分發以外，另一種常見的方法就是在客戶端層面來分庫分表 —— 經過適當地包裝客戶端代碼使得分庫分表的數據庫訪問操做代碼編寫起來也很方便。本文的分庫分表方案基於 MyBatis 框架，可是又不一樣於市面上經常使用的方案，它們通常都是經過編寫複雜的 MyBatis 插件來重寫 SQL 語句，這樣的插件代碼會巨複雜無比，可能最終只有插件的原做者本身能夠徹底吃透相關代碼，給項目的維護性帶來必定問題。本文的方案很是簡單易懂，並且也不失使用上的便捷性。它的設計哲學來源於 Python —— Explicit is better than Implicit，也就是顯式優於隱式，它不會將分庫分表的過程隱藏起來。java

不少分庫分表的設計在實現上會盡可能將分庫分表的邏輯隱藏起來，其實這是毫無必要的。使用者必須知道背後確實進行了分庫分表，不然他怎麼會沒法進行全局的索引查找？他怎麼會沒法隨意進行多表的 join 操做。若是你真的將它當成單表來用，到上線時必然會出大問題。node

項目名稱叫：shardino，項目地址：github.com/pyloque/sha…mysql

接下來咱們來看看在本文的方案之下，數據庫操做代碼的形式是怎樣的git

帖子表一共分出來 64 個表，不一樣的記錄會各自分發到其中一個表，能夠是按 hash 分發，也能夠按照日期分發，分發邏輯由用戶代碼本身來決定。在不一樣的環境中能夠將分表數量設置爲不一樣的值，好比在單元測試下分表設爲 4 個，而線上可能須要設置爲 64 個。github

@Configuration
public class PartitionConfig {

    private int post = 64;

    public int post() {
        return post;
    }

    public void post(int post) {
        this.post = post;
    }
}
複製代碼

帖子表又會被分配到多個庫，這裏就直接取模分配。假設有 4 個帖子庫，帖子表總共分出來 64 個表，分別是 post_0、post_一、post_2 一直到 post_63。那麼 post_0、post_四、post_8 等分配到 0 號庫，post_一、post_五、post_9 等分配到 1 號庫，post_二、post_六、post_10 等分配到 2 號庫，post_三、post_五、post_11 等分配到 4 號庫。算法

從配置文件中構建 MySQLGroupStore 數據庫組對象，這個對象是咱們執行 MySQL 操做的入口，經過它能夠找到具體的物理的 MySQL 主從數據源。spring

@Configuration
public class RepoConfig {

    @Autowired
    private Environment env;

    private MySQLGroupBuilder mysqlGroupBuilder = new MySQLGroupBuilder();

    @Bean
    @Qualifier("post")
    public MySQLGroupStore replyMySQLGroupStore() {
        MySQLGroupStore store = mysqlGroupBuilder.buildStore(env, "post");
        store.prepare(factory -> {
            factory.getConfiguration().addMapper(PostMapper.class);
        });
        return store;
    }
}
複製代碼

配置文件 application.properties 以下sql

mysql.post0.master.addrWeights=localhost:3306
mysql.post0.master.db=sample
mysql.post0.master.user=sample
mysql.post0.master.password=123456
mysql.post0.master.poolSize=10

mysql.post0.slave.addrWeights=localhost:3307=100&localhost:3308=100
mysql.post0.slave.db=sample
mysql.post0.slave.user=sample
mysql.post0.slave.password=123456
mysql.post0.slave.poolSize=10

mysql.post1.master.addrWeights=localhost:3309
mysql.post1.master.db=sample
mysql.post1.master.user=sample
mysql.post1.master.password=123456
mysql.post1.master.poolSize=10

mysql.post1.slave.addrWeights=localhost:3310=100&localhost:3311=100
mysql.post1.slave.db=sample
mysql.post1.slave.user=sample
mysql.post1.slave.password=123456
mysql.post1.slave.poolSize=10

mysqlgroup.post.nodes=post0,post1
mysqlgroup.post.slaveEnabled=true
複製代碼

這裏的數據庫組是由多個對等的 Master-Slaves 對構成，每一個 Master-Slaves 是由一個主庫和多個不一樣權重的從庫構成，Master-Slaves 對的數量就是分庫的數量。docker

mysqlgroup 還有一個特殊的配置選項 slaveEnabled 來控制是否須要從庫，從而關閉讀寫分離，默認是關閉的，這樣就不會去構建從庫實例相關對象。數據庫

post_k 這張表後綴 k 咱們稱之爲 partition number，也就是後續代碼中處處在用的 partition 變量，代表當前的記錄被分配到對應物理數據表的序號。咱們須要根據記錄的內容計算出 partition number，再根據 partition number 決定出這條記錄所在的物理表屬於那個物理數據庫，而後對這個物理數據庫進行相應的讀寫操做。

在本例中，帖子表按照 userId 字段 hash 出 64 張表，平均分配到 2 對物理庫中，每一個物理庫包含一個主庫和2個從庫。

有了 MySQLGroupStore 實例，咱們就能夠盡情操縱全部數據庫了。

@Repository
public class PostMySQL {

    @Autowired
    private PartitionConfig partitions;

    @Autowired
    @Qualifier("post")
    private MySQLGroupStore mysql;

    public void createTables() {
        for (int i = 0; i < partitions.post(); i++) {
            int k = i;
            mysql.master(k).execute(session -> {
                PostMapper mapper = session.getMapper(PostMapper.class);
                mapper.createTable(k);
            });
        }
    }

    public void dropTables() {
        for (int i = 0; i < partitions.post(); i++) {
            int k = i;
            mysql.master(k).execute(session -> {
                PostMapper mapper = session.getMapper(PostMapper.class);
                mapper.dropTable(k);
            });
        }
    }

    public Post getPostFromMaster(String userId, String id) {
        Holder<Post> holder = new Holder<>();
        int partition = this.partitionFor(userId);
        mysql.master(partition).execute(session -> {
            PostMapper mapper = session.getMapper(PostMapper.class);
            holder.value(mapper.getPost(partition, id));
        });
        return holder.value();
    }

    public Post getPostFromSlave(String userId, String id) {
        Holder<Post> holder = new Holder<>();
        int partition = this.partitionFor(userId);
        mysql.slave(partition).execute(session -> {
            PostMapper mapper = session.getMapper(PostMapper.class);
            holder.value(mapper.getPost(partition, id));
        });
        return holder.value();
    }

    public void savePost(Post post) {
        int partition = this.partitionFor(post);
        mysql.master(partition).execute(session -> {
            PostMapper mapper = session.getMapper(PostMapper.class);
            Post curPost = mapper.getPost(partition, post.getId());
            if (curPost != null) {
                mapper.updatePost(partition, post);
            } else {
                mapper.insertPost(partition, post);
            }
        });
    }

    public void deletePost(String userId, String id) {
        int partition = this.partitionFor(userId);
        mysql.master(partition).execute(session -> {
            PostMapper mapper = session.getMapper(PostMapper.class);
            mapper.deletePost(partition, id);
        });
    }

    private int partitionFor(Post post) {
        return Post.partitionFor(post.getUserId(), partitions.post());
    }

    private int partitionFor(String userId) {
        return Post.partitionFor(userId, partitions.post());
    }
}
複製代碼

從上面的代碼中能夠看出全部的讀寫、建立、刪除表操做的第一步都是計算出 partition number，而後根據它來選出目標主從庫再進一步對目標的數據表進行操做。這裏我默認開啓了autocommit，因此不須要顯式來 session.commit() 了。

mysql.master(partition)
mysql.slave(partition)

// 若是沒有分庫
mysql.master()
mysql.slave()

// 若是既沒有分庫也沒有讀寫分離
mysql.db()

// 操做具體的表時要帶 partition
mapper.getPost(partition, postId)
mapper.savePost(partition, post)
複製代碼

在對數據表的操做過程當中，又須要將具體的 partition number 傳遞過去，如此 MyBatis 才能知道具體操做的是哪一個分表。

public interface PostMapper {

    @Update("create table if not exists post_#{partition}(id varchar(128) primary key not null, user_id varchar(1024) not null, title varchar(1024) not null, content text, create_time timestamp not null) engine=innodb")
    public void createTable(int partition);

    @Update("drop table if exists post_#{partition}")
    public void dropTable(int partition);

    @Results({@Result(property = "createTime", column = "create_time"),
            @Result(property = "userId", column = "user_id")})
    @Select("select id, user_id, title, content, create_time from post_#{partition} where id=#{id}")
    public Post getPost(@Param("partition") int partition, @Param("id") String id);

    @Insert("insert into post_#{partition}(id, user_id, title, content, create_time) values(#{p.id}, ${p.userId}, #{p.title}, #{p.content}, #{p.createTime})")
    public void insertPost(@Param("partition") int partition, @Param("p") Post post);

    @Update("update post_#{partition} set title=#{p.title}, content=#{p.content}, create_time=#{p.createTime} where id=#{p.id}")
    public void updatePost(@Param("partition") int partition, @Param("p") Post post);

    @Delete("delete from post_#{partition} where id=#{id}")
    public void deletePost(@Param("partition") int partition, @Param("id") String id);
}
複製代碼

在每一條數據庫操做中都必須帶上 partition 參數，你可能會以爲這有點繁瑣。可是這也很直觀，它明確地告訴咱們目前正在操做的是哪個具體的分表。

在 MyBatis 的註解 Mapper 類中，若是方法含有多個參數，須要使用 @Param 註解進行名稱標註，這樣才能夠在 SQL 語句中直接使用相應的註解名稱。不然你得使用默認的變量佔位符名稱 param0、param1 來表示，這就很不直觀。

咱們將分表的 hash 算法寫在實體類 Post 中，這裏使用 CRC32 算法進行 hash。

public class Post {
    private String id;
    private String userId;
    private String title;
    private String content;
    private Date createTime;

    public Post() {}

    public Post(String id, String userId, String title, String content, Date createTime) {
        this.id = id;
        this.userId = userId;
        this.title = title;
        this.content = content;
        this.createTime = createTime;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public Date getCreateTime() {
        return createTime;
    }

    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }

    public int partitionFor(int num) {
        return partitionFor(userId, num);
    }

    public static int partitionFor(String userId, int num) {
        CRC32 crc = new CRC32();
        crc.update(userId.getBytes(Charsets.UTF8));
        return (int) (Math.abs(crc.getValue()) % num);
    }
}
複製代碼

代碼中的 partitionFor 方法的參數 num 就是一共要分多少表。若是是按日期來分表，這個參數可能就不須要，直接返回日期的整數就行好比 20190304。

還有最後一個問題是多個帶權重的從庫是如何作到機率分配的。這裏就要使用到 spring-jdbc 自帶的 AbstractRoutingDataSource —— 帶路由功能的數據源。它能夠包含多個子數據源，而後根據必定的策略算法動態挑選出一個數據源來，這裏就是使用權重隨機。

可是有個問題，我這裏只須要這一個類，可是須要引入整個 spring-boot-jdbc-starter 包，有點拖泥帶水的感受。我研究了一下 AbstractRoutingDataSource 類的代碼，發現它的實現很是簡單，若是就仿照它本身實現了一個簡單版的，這樣就不須要引入整個包代碼了。

public class RandomWeightedDataSource extends DataSourceAdapter {
    private int totalWeight;
    private Set<PooledDataSource> sources;
    private Map<Integer, PooledDataSource> sourceMap;

    public RandomWeightedDataSource(Map<PooledDataSource, Integer> srcs) {
        this.sources = new HashSet<>();
        this.sourceMap = new HashMap<>();
        for (Entry<PooledDataSource, Integer> entry : srcs.entrySet()) {
            // 權重值不宜過大
            int weight = Math.min(10000, entry.getValue());
            for (int i = 0; i < weight; i++) {
                sourceMap.put(totalWeight, entry.getKey());
                totalWeight++;
            }
            this.sources.add(entry.getKey());
        }
    }

    private PooledDataSource getDataSource() {
        return this.sourceMap.get(ThreadLocalRandom.current().nextInt(totalWeight));
    }

    public void close() {
        for (PooledDataSource ds : sources) {
            ds.forceCloseAll();
        }
    }

    @Override
    public Connection getConnection() throws SQLException {
        return getDataSource().getConnection();
    }

    @Override
    public Connection getConnection(String username, String password) throws SQLException {
        return getDataSource().getConnection(username, password);
    }
}
複製代碼

還需進一步深刻理解其實現代碼的能夠將 shardino 代碼倉庫拉到本地跑一跑

git clone https://github.com/pyloque/shardino.git
複製代碼

裏面有單元測試能夠運行起來，運行以前須要確保本機安裝了 docker 環境

docker-compose up -d
複製代碼

這條指令會啓動2對主從庫，各1主兩從。

在本例中雖然用到了 springboot ，其實也只是用了它方便的依賴注入和單元測試功能，shardino 徹底能夠脫離 springboot 而獨立存在。

shardino 並非一個完美的開源庫，它只是一份實現代碼的樣板，若是讀者使用的是其它數據庫或者 MySQL 的其它版本，那就須要本身微調一下代碼來適配了。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程