什么是 ShardingSphere？

1、一套开源的分布式数据库中间件解决方案
2、有三个产品：Sharding-JDBC 和 Sharding-Proxy
3、定位为关系型数据库中间件，合理在分布式环境下使用关系型数据库操作
 
什么是分库分表
 
1、数据库数据量不可控的，随着时间和业务发展，造成表里面数据越来越多，如果再去对数据库表 curd 操作时候，造成性能问题。
2、方案 1：从硬件上
3、方案 2：分库分表
* 为了解决由于数据量过大而造成数据库性能降低问题。

分库分表的方式 
1、分库分表有两种方式：垂直切分和水平切分
2、垂直切分：垂直分表和垂直分库
3、水平切分：水平分表和水平分库
4、垂直分表
（1）操作数据库中某张表，把这张表中一部分字段数据存到一张新表里面，再把这张表另一
部分字段数据存到另外一张表里面
 
 

5、垂直分库
（1）把单一数据库按照业务进行划分，专库专表 

6、水平分库
 

7、水平分表 

分库分表应用和问题 
1、应用
（1）在数据库设计时候考虑垂直分库和垂直分表
（2）随着数据库数据量增加，不要马上考虑做水平切分，首先考虑缓存处理，读写分离，使用索引等等方式，如果这些方式不能根本解决问题了，再考虑做水平分库和水平分表
2、分库分表问题
（1）跨节点连接查询问题（分页、排序）
（2）多数据源管理问题 
 
 
 
 
 
 
 
Sharding-JDBC 简介 
1、是轻量级的 java 框架，是增强版的 JDBC 驱动
2、Sharding-JDBC
（1）主要目的是：简化对分库分表之后数据相关操作

Sharding-JDBC 实现水平分表 

（4）引入需要的依赖

<dependencies>

 <dependency>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-starter</artifactId>

 </dependency>

 <dependency>

 <groupId>org.springframework.boot</groupId>

 <artifactId>spring-boot-starter-test</artifactId>

 </dependency>

 <dependency>

 <groupId>com.alibaba</groupId>

 <artifactId>druid-spring-boot-starter</artifactId>

 <version>1.1.20</version>

 </dependency>

 <dependency>

 <groupId>mysql</groupId>

 <artifactId>mysql-connector-java</artifactId>

 </dependency>

 <dependency>

 <groupId>org.apache.shardingsphere</groupId>

 <artifactId>sharding-jdbc-spring-boot-starter</artifactId>

 <version>4.0.0-RC1</version>

 </dependency>

 <dependency>

 <groupId>com.baomidou</groupId>

 <artifactId>mybatis-plus-boot-starter</artifactId>

 <version>3.0.5</version>

 </dependency>

 <dependency>

 <groupId>org.projectlombok</groupId>

 <artifactId>lombok</artifactId>

 </dependency>

</dependencies>
2、按照水平分表的方式，创建数据库和数据库表
（1）创建数据库 course_db
（2）在数据库创建两张表 course_1 和 course_2
（3）约定规则：如果添加课程 id 是偶数把数据添加 course_1，如果奇数添加到 course_2

 
3、编写代码实现对分库分表后数据的操作
1）创建实体类，mapper

4、配置 Sharding-JDBC 分片策略
（1）在项目 application.properties 配置文件中进行配置 
# shardingjdbc 分片策略

# 配置数据源，给数据源起名称

spring.shardingsphere.datasource.names=m1

# 一个实体类对应两张表，覆盖

spring.main.allow-bean-definition-overriding=true #配置数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/course_db?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m1.username=root

 spring.shardingsphere.datasource.m1.password=root
 #指定 course 表分布情况，配置表在哪个数据库里面，表名称都是什么 m1.course_1 ,m1.course_2
 spring.shardingsphere.sharding.tables.course.actual-data-nodes=m1.course_$->{1..2}
 # 指定 course 表里面主键 cid 生成策略 SNOWFLAKE
 spring.shardingsphere.sharding.tables.course.key-generator.column=cid
 spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE
 # 指定分片策略 约定 cid 值偶数添加到 course_1 表，如果 cid 是奇数添加到 course_2表
 spring.shardingsphere.sharding.tables.course.table-strategy.inline.sharding-column=cid
 spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithm-expression=course_$->{cid % 2 + 1}
 # 打开 sql 输出日志
 spring.shardingsphere.props.sql.show=true 
5、编写测试代码
@RunWith(SpringRunner.class)

@SpringBootTest

public class ShardingjdbcdemoApplicationTests {

 //注入 mapper

 @Autowired

 private CourseMapper courseMapper;

 //添加课程的方法

 @Test

 public void addCourse() {

 　　for(int i=1;i<=10;i++) {

 　　　　Course course = new Course();

 　　　　course.setCname("java"+i);

 　　　　course.setUserId(100L);

 　　　　course.setCstatus("Normal"+i);

 　　　　courseMapper.insert(course);

 　　}

 }

 //查询课程的方法

 @Test

 public void findCourse() {

 　　　　QueryWrapper<Course> wrapper = new QueryWrapper<>();

　　　　 wrapper.eq("cid",465114665106538497L);

 　　　　Course course = courseMapper.selectOne(wrapper);

 　　　　System.out.println(course);

 　　} 
}
（1）上面测试代码执行，报错了 

（2）解决方案，在配置文件中添加一行配置
# 一个实体类对应两张表，覆盖

spring.main.allow-bean-definition-overriding=true
Sharding-JDBC 实现水平分库 
1、需求分析

2、创建数据库和表 

3、在 SpringBoot 配置文件配置数据库分片规则 
# shardingjdbc 分片策略

# 配置数据源，给数据源起名称,

# 水平分库，配置两个数据源

spring.shardingsphere.datasource.names=m1,m2

# 一个实体类对应两张表，覆盖

spring.main.allow-bean-definition-overriding=true

#配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m1.username=root

spring.shardingsphere.datasource.m1.password=root 

#配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m2.username=root

spring.shardingsphere.datasource.m2.password=root 

#指定数据库分布情况，数据库里面表分布情况

# m1 m2 course_1 course_2

spring.shardingsphere.sharding.tables.course.actual-data-nodes=m$->{1..2}.course_$->{1..2}


# 指定 course 表里面主键 cid 生成策略 SNOWFLAKE

spring.shardingsphere.sharding.tables.course.key-generator.column=cid

spring.shardingsphere.sharding.tables.course.key-generator.type=SNOWFLAKE


# 指定表分片策略 约定 cid 值偶数添加到 course_1 表，如果 cid 是奇数添加到course_2 表

spring.shardingsphere.sharding.tables.course.table-strategy.inline.shardingcolumn=cid

spring.shardingsphere.sharding.tables.course.table-strategy.inline.algorithmexpression=course_$->{cid % 2 + 1}


# 指定数据库分片策略 约定 user_id 是偶数添加 m1，是奇数添加 m2

#spring.shardingsphere.sharding.default-database-strategy.inline.shardingcolumn=user_id

#spring.shardingsphere.sharding.default-database-strategy.inline.algorithm- expression=m$->{user_id % 2 + 1}

spring.shardingsphere.sharding.tables.course.databasestrategy.inline..sharding-column=user_id

spring.shardingsphere.sharding.tables.course.databasestrategy.inline.algorithm-expression=m$->{user_id % 2 + 1}

# 打开 sql 输出日志

spring.shardingsphere.props.sql.show=tru
4、编写测试方法 
//======================测试水平分库=====================

//添加操作

@Test

public void addCourseDb() {

 Course course = new Course();

 course.setCname("javademo1");

 //分库根据 user_id

 course.setUserId(111L);

 course.setCstatus("Normal1");

 courseMapper.insert(course);

}

//查询操作

@Test

public void findCourseDb() {

 QueryWrapper<Course> wrapper = new QueryWrapper<>();

 //设置 userid 值

 wrapper.eq("user_id",100L);

 //设置 cid 值

 wrapper.eq("cid",465162909769531393L);

 Course course = courseMapper.selectOne(wrapper);

 System.out.println(course);

}
 
Sharding-JDBC 实现垂直分库 
1、需求分析 

2、创建数据库和表

3、编写操作代码
（1）创建 user 实体类和 mapper 
@Data

@TableName(value = "t_user") //指定对应表

public class User {

 private Long userId;

 private String username;

 private String ustatus; }

（2）配置垂直分库策略 
* 在 application.properties 进行配置

# shardingjdbc 分片策略

# 配置数据源，给数据源起名称,

# 水平分库，配置两个数据源

spring.shardingsphere.datasource.names=m1,m2,m0

# 一个实体类对应两张表，覆盖

spring.main.allow-bean-definition-overriding=true 

#配置第一个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m1.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m1.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m1.url=jdbc:mysql://localhost:3306/edu_db_1?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m1.username=root

spring.shardingsphere.datasource.m1.password=root

 #配置第二个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m2.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m2.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m2.url=jdbc:mysql://localhost:3306/edu_db_2?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m2.username=root

spring.shardingsphere.datasource.m2.password=root

#配置第三个数据源具体内容，包含连接池，驱动，地址，用户名和密码

spring.shardingsphere.datasource.m0.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.m0.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.m0.url=jdbc:mysql://localhost:3306/user_db?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.m0.username=root

spring.shardingsphere.datasource.m0.password=root


# 配置 user_db 数据库里面 t_user 专库专表

spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user


# 指定 course 表里面主键 cid 生成策略 SNOWFLAKE

spring.shardingsphere.sharding.tables.t_user.key-generator.column=user_id

spring.shardingsphere.sharding.tables.t_user.key-generator.type=SNOWFLAKE


# 指定表分片策略 约定 cid 值偶数添加到 course_1 表，如果 cid 是奇数添加到course_2 表

spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.shardingcolumn=user_id

spring.shardingsphere.sharding.tables.t_user.table-strategy.inline.algorithmexpression=t_user
（3）编写测试代码
//注入 user 的 mapper

@Autowired

private UserMapper userMapper;

//======================测试垂直分库==================

//添加操作

@Test

public void addUserDb() {

 User user = new User();

 user.setUsername("lucy");

 user.setUstatus("a");

 userMapper.insert(user);

}
Sharding-JDBC 操作公共表
1、公共表
（1）存储固定数据的表，表数据很少发生变化，查询时候经常进行关联
（2）在每个数据库中创建出相同结构公共表
2、在多个数据库都创建相同结构公共表

3、在项目配置文件 application.properties 进行公共表配置 
# 配置公共表

spring.shardingsphere.sharding.broadcast-tables=t_udict

spring.shardingsphere.sharding.tables.t_udict.key-generator.column=dictid

spring.shardingsphere.sharding.tables.t_udict.key-generator.type=SNOWFLAKE
4、编写测试代码
（1）创建新实体类和 mapper
@Data

@TableName(value = "t_udict")

public class Udict {

 private Long dictid;

 private String ustatus;

 private String uvalue; }

（2）编写添加和删除方法进行测试 
@Autowired

private UdictMapper udictMapper;

//======================测试公共表===================

//添加操作

@Test

public void addDict() {

 Udict udict = new Udict();

 udict.setUstatus("a");

 udict.setUvalue("已启用");

 udictMapper.insert(udict);

}

//删除操作

@Test

public void deleteDict() {

 QueryWrapper<Udict> wrapper = new QueryWrapper<>();

 //设置 userid 值

 wrapper.eq("dictid",465191484111454209L);

 udictMapper.delete(wrapper);

}
Sharding-JDBC 实现读写分离
1、读写分离概念 
为了确保数据库产品的稳定性，很多数据库拥有双机热备功能，也就是，第一台数据库服务器，是对外提供增删改业务的生成服务器，第二台数据库服务器，主要进行读的操作。
原理：让主数据库（master）处理事务性增、改、删操作，而从数据库（slave）处理select查询操作。
 

读写分离原理：

Sharding-JDBC 通过 sql 语句语义分析，实现读写分离过程，不会做数据同步

2、MySQL 配置读写分离
第一步 创建两个 MySQL 数据库服务，并且启动两个 MySQL 服务
（1）复制之前 MySQL 目录

（2）修改复制之后配置文件 

修改端口号，文件路径
需要把数据文件目录再复制一份
 

（3）把复制修改之后从数据库在 windows 安装服务
　　* 使用命令： mysqld install mysqls1 --defaults-file="D:\Program Files\MySQL\MySQLServer-s1\my.ini" 

因为从库是从主库复制过来的，因此里面的数据完全一致，可使用原来的账号、密码登录

第二步 配置 MySQL 主从服务器
（1）在主服务器配置文件   主库my.ini文件[mysqld]
#开启日志

log‐bin = mysql‐bin

#设置服务id，主从不能一致

server‐id = 1
#设置需要同步的数据库

binlog‐do‐db=user_db

#屏蔽系统库同步

binlog‐ignore‐db=mysql

binlog‐ignore‐db=information_schema

binlog‐ignore‐db=performance_schema
（2）在从服务器配置文件    从库my.ini文件
[mysqld]

#开启日志

log‐bin = mysql‐bin

#设置服务id，主从不能一致

server‐id = 2 
#设置需要同步的数据库

replicate_wild_do_table=user_db.%

#屏蔽系统库同步

replicate_wild_ignore_table=mysql.%

replicate_wild_ignore_table=information_schema.%

replicate_wild_ignore_table=performance_schema.%
（3）把主和从服务器重启 
 第三步 创建用于主从复制的账号 
#切换至主库bin目录，登录主库

mysql ‐h localhost ‐uroot ‐p

#授权主备复制专用账号

GRANT REPLICATION SLAVE ON *.* TO 'db_sync'@'%' IDENTIFIED BY 'db_sync'; #刷新权限

FLUSH PRIVILEGES;

#确认位点 记录下文件名以及位点

show master status;

第四步 主从数据同步设置
#切换至从库bin目录，登录从库

mysql ‐h localhost ‐P3307 ‐uroot ‐p


#先停止同步

STOP SLAVE;



#修改从库指向到主库，使用上一步记录的文件名以及位点

CHANGE MASTER TO

master_host = 'localhost',

master_user = 'db_sync',

master_password = 'db_sync',

master_log_file = 'mysql-bin.000177',

master_log_pos = 107; 

#启动同步

START SLAVE;



#查看Slave_IO_Runing和Slave_SQL_Runing字段值都为Yes，表示同步配置成功。如果不为Yes，请排

查相关异常。

show slave status

3、Sharding-JDBC 操作 
（1）配置读写分离策略
# user_db 从服务器

spring.shardingsphere.datasource.s0.type=com.alibaba.druid.pool.DruidDataSource

spring.shardingsphere.datasource.s0.driver-class-name=com.mysql.cj.jdbc.Driver

spring.shardingsphere.datasource.s0.url=jdbc:mysql://localhost:3307/user_db?serverTimezone=GMT%2B8

spring.shardingsphere.datasource.s0.username=root

spring.shardingsphere.datasource.s0.password=root


# 主库从库逻辑数据源定义 ds0 为 user_db

spring.shardingsphere.sharding.master-slave-rules.ds0.master-data-sourcename=m0

spring.shardingsphere.sharding.master-slave-rules.ds0.slave-data-sourcenames=s0


# 配置 user_db 数据库里面 t_user 专库专表

#spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=m$->{0}.t_user


# t_user 分表策略，固定分配至 ds0 的 t_user 真实表

spring.shardingsphere.sharding.tables.t_user.actual-data-nodes=ds0.t_user
（2）编写测试代码 
//添加操作

@Test

public void addUserDb() {

 User user = new User();

 user.setUsername("lucymary");

 user.setUstatus("a");

 userMapper.insert(user);

}

//查询操作

@Test

public void findUserDb() {

 QueryWrapper<User> wrapper = new QueryWrapper<>();

 //设置 userid 值

 wrapper.eq("user_id",465508031619137537L);

 User user = userMapper.selectOne(wrapper);

 System.out.println(user);

}
 
Sharding-Proxy 简介
1、定位为透明的数据库代理端

 
2、Sharding-Proxy 独立应用，需要安装服务，进行分库分表或者读写分离配置，启动
使用
3、安装
（1）下载安装软件 

（2）把下载之后压缩文件，解压，启动 bin 目录启动文件就可以了

Sharding-Proxy 配置（分表） 
1、进入 conf 目录，修改文件 server.yaml，去掉两段内容注释，打开即可

2、进入 conf 目录，修改 config-sharding.yaml 

 

（1）复制 mysql 驱动 jar 包到 lib 目录

（2）配置分库分表规则 
schemaName: sharding_db

dataSources:

 ds_0:

 url: jdbc:mysql://127.0.0.1:3306/edu_1?serverTimezone=UTC&useSSL=false

 username: root

 password: root

 connectionTimeoutMilliseconds: 30000

 idleTimeoutMilliseconds: 60000

 maxLifetimeMilliseconds: 1800000

 maxPoolSize: 50

shardingRule:

 tables:

 t_order:

 actualDataNodes: ds_${0}.t_order_${0..1}

 tableStrategy:

 inline:

 shardingColumn: order_id

 algorithmExpression: t_order_${order_id % 2}

 keyGenerator:

 type: SNOWFLAKE

 column: order_id

 bindingTables:

 - t_order

 defaultDatabaseStrategy:

 inline:

 shardingColumn: user_id

 algorithmExpression: ds_${0}

 defaultTableStrategy:

 none:
3、启动 Sharding-Proxy 服务 
（1）Sharding-Proxy 默认端口号 3307

4、通过 Sharding-Proxy 启动端口进行连接
（1）打开 cmd 窗口连接 Sharding-Proxy，连接方式和连接 mysql 一样的

（2）进行 sql 命令操作看到只有一个库

（3）在 sharding_db 数据库创建表

（4）向表添加一条记录

5、回到本地 3306 端口实际数据库中，看到已经创建好了表和添加数据 

Sharding-Proxy 配置（分库）

2、找到 conf 目录，config-sharding.yaml
schemaName: sharding_db

dataSources:

 ds_0:

 url: jdbc:mysql://127.0.0.1:3306/edu_db_1?serverTimezone=UTC&useSSL=false

 username: root

 password: root

 connectionTimeoutMilliseconds: 30000

 idleTimeoutMilliseconds: 60000

 maxLifetimeMilliseconds: 1800000

 maxPoolSize: 50

 ds_1:

 url: jdbc:mysql://127.0.0.1:3306/edu_db_2?serverTimezone=UTC&useSSL=false

 username: root

password: root
connectionTimeoutMilliseconds: 30000
idleTimeoutMilliseconds: 60000
maxLifetimeMilliseconds: 1800000
maxPoolSize: 50
shardingRule:
tables:
t_order:
actualDataNodes: ds_${0..1}.t_order_${1..2}
tableStrategy:
inline:
shardingColumn: order_id
algorithmExpression: t_order_${order_id % 2 + 1}
keyGenerator:
type: SNOWFLAKE
column: order_id
bindingTables:
- t_order
defaultDatabaseStrategy:
inline:
shardingColumn: user_id
algorithmExpression: ds_${user_id % 2}
defaultTableStrategy:
none:
3、启动 Sharding-Proxy 服务 
4、打开 cmd 仓库，连接 Sharding-Proxy 服务 

（1）创建数据库表，向表添加记录 
（2）连接本地 3306 的 MySql 数据库服务器，表已经创建出来，表里面有数据

 

Sharding-Proxy 配置（读写分离）
1、创建三个数据 

2、修改 conf 里面配置文件，config-master-slave.yaml 

schemaName: master_slave_db

dataSources:

 master_ds:

 url: jdbc:mysql://127.0.0.1:3306/demo_ds_master?serverTimezone=UTC&useSSL=false

 username: root

 password: root

 connectionTimeoutMilliseconds: 30000

 idleTimeoutMilliseconds: 60000

 maxLifetimeMilliseconds: 1800000

 maxPoolSize: 50

 slave_ds_0:

url: jdbc:mysql://127.0.0.1:3306/demo_ds_slave_0?serverTimezone=UTC&useSSL=false

 username: root

 password: root

 connectionTimeoutMilliseconds: 30000

 idleTimeoutMilliseconds: 60000

 maxLifetimeMilliseconds: 1800000

 maxPoolSize: 50

 slave_ds_1:

 url: jdbc:mysql://127.0.0.1:3306/demo_ds_slave_1?serverTimezone=UTC&useSSL=false

 username: root

 password: root

 connectionTimeoutMilliseconds: 30000

 idleTimeoutMilliseconds: 60000

 maxLifetimeMilliseconds: 1800000

 maxPoolSize: 50

masterSlaveRule:

 name: ms_ds

 masterDataSourceName: master_ds

 slaveDataSourceNames:

 - slave_ds_0

 - slave_ds_1
3、启动 Sharding-Proxy 服务 
4、通过 cmd 连接 Sharding-Proxy，进行创建表和添加记录操作
（1）在主数据库和从数据库里面，都创建数据库表

（2）向表添加记录，不指定向哪个库添加
* 把添加数据添加到主数据库里面
 

Sharding Sphere的分库分表的更多相关文章

  1. 分库分表后跨分片查询与Elastic Search

    携程酒店订单Elastic Search实战:http://www.lvesu.com/blog/main/cms-610.html 为什么分库分表后不建议跨分片查询:https://www.jian ...

  2. 【大数据和云计算技术社区】分库分表技术演进&最佳实践笔记

    1.需求背景 移动互联网时代,海量的用户每天产生海量的数量,这些海量数据远不是一张表能Hold住的.比如 用户表:支付宝8亿,微信10亿.CITIC对公140万,对私8700万. 订单表:美团每天几千 ...

  3. java 取模运算% 实则取余 简述 例子 应用在数据库分库分表

    java 取模运算%  实则取余 简述 例子 应用在数据库分库分表 取模运算 求模运算与求余运算不同.“模”是“Mod”的音译,模运算多应用于程序编写中. Mod的含义为求余.模运算在数论和程序设计中 ...

  4. 分库分表技术演进&最佳实践

    每个优秀的程序员和架构师都应该掌握分库分表,这是我的观点. 移动互联网时代,海量的用户每天产生海量的数量,比如: 用户表 订单表 交易流水表 以支付宝用户为例,8亿:微信用户更是10亿.订单表更夸张, ...

  5. 分库分表利器之Sharding Sphere（深度好文，看过的人都说好）

    Sharding-Sphere Sharding-JDBC 最早是当当网内部使用的一款分库分表框架,到2017年的时候才开始对外开源,这几年在大量社区贡献者的不断迭代下,功能也逐渐完善,现已更名为 S ...

  6. 数据库分库分表(sharding)系列(一) 拆分规则

    第一部分:实施策略 数据库分库分表(sharding)实施策略图解 1. 垂直切分垂直切分的依据原则是:将业务紧密,表间关联密切的表划分在一起,例如同一模块的表.结合已经准备好的数据库ER图或领域模型 ...

  7. 转数据库分库分表(sharding)系列(二) 全局主键生成策略

    本文将主要介绍一些常见的全局主键生成策略,然后重点介绍flickr使用的一种非常优秀的全局主键生成方案.关于分库分表(sharding)的拆分策略和实施细则,请参考该系列的前一篇文章:数据库分库分表( ...

  8. 转数据库分库分表(sharding)系列(一) 拆分实施策略和示例演示

    本文原文连接: http://blog.csdn.net/bluishglc/article/details/7696085 ,转载请注明出处!本文着重介绍sharding切分策略,如果你对数据库sh ...

  9. 数据库分库分表(sharding)系列【转】

    原文地址:http://www.uml.org.cn/sjjm/201211212.asp数据库分库分表(sharding)系列 目录; (一) 拆分实施策略和示例演示 (二) 全局主键生成策略 (三 ...

随机推荐

  1. python selenium表单定位

    在Web应用中经常会遇到frame/iframe 表单嵌套页面的应用,WebDriver 只能在一个页面上对元素识别与定位,对于frame/iframe 表单内嵌页面上的元素无法直接定位.这时就需要通 ...

  2. LuoguP4759 [CERC2014]Sums 题解

    Content 给定 \(t\) 组数据,每组数据给定一个数 \(n\),判断 \(n\) 是否能够分解成连续正整数和,能的话给出最小数最大的方案. 数据范围:\(1\leqslant n\leqsl ...

  3. 为什么需要两次eval才转化为需要的JSON数据，好奇怪

    为什么需要两次eval才转化为需要的JSON数据,好奇怪

  4. ACwing2.01背包问题

    题目: 有 N 件物品和一个容量是 V 的背包.每件物品只能使用一次. 第 i 件物品的体积是 vi,价值是 wi. 求解将哪些物品装入背包,可使这些物品的总体积不超过背包容量,且总价值最大. 输出最 ...

  5. 【九度OJ】题目1185：特殊排序 解题报告

    [九度OJ]题目1185:特殊排序 解题报告 标签(空格分隔): 九度OJ [LeetCode] http://ac.jobdu.com/problem.php?pid=1185 题目描述: 输入一系 ...

  6. 【LeetCode】49. Group Anagrams 解题报告（Python & Java & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 排序+hash 日期 题目地址:https://le ...

  7. 【LeetCode】684. Redundant Connection 解题报告（Python & C++）

    作者: 负雪明烛 id: fuxuemingzhu 个人博客: http://fuxuemingzhu.cn/ 目录 题目描述 题目大意 解题方法 并查集 日期 题目地址:https://leetco ...

  8. The Monkey King(hdu5201)

    The Monkey King Time Limit: 8000/4000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)T ...

  9. 第十七个知识点：描述和比较DES和AES的轮结构

    第十七个知识点:描述和比较DES和AES的轮结构 这是密码学52件事中的第17篇.本周我们描述和比较DES和AES的结构. DES和AES都是迭代分组密码的例子.分组密码通过重复使用一个简单的轮函数来 ...

  10. 想看Vue文档，cn放错位置，误入xx网站...

    昨晚,DD在微信群(点击加入)里看到有小伙伴说,想去Vue官网看中文文档,不当心把cn写错了位置,结果进入了xx网站... 老司机们应该都知道,Vue官网的中文文档地址是:https://cn.vue ...