A versão inicial do projeto usando Dangdang sharding-JDBC ser sub-biblioteca de operação de banco de dados sub-tabela, siga-up projeto para substituir o banco de dados de auto-estudo elástica armazenada. Resuma aprender Dangdang middleware banco de dados sharding-jdbc, e completar o demo, corrida, mostra o código de demonstração listados a seguir:
Construído tabela SQL
/*
Navicat MySQL Data Transfer 在Navicat中直接运行本sql文件创建表
* 两个库：test_msg1 包含两个表： t_order_0 t_order_1
* test_msg2 包含两个表： t_order_0 t_order_1
* 建表sql如下
*/
SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `users`
-- ----------------------------
DROP TABLE IF EXISTS `t_order_0`;
CREATE TABLE `t_order_0` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键id',
`order_id` varchar(32) DEFAULT NULL COMMENT '顺序编号',
`user_id` varchar(32) DEFAULT NULL COMMENT '用户编号',
`userName` varchar(32) DEFAULT NULL COMMENT '用户名',
`passWord` varchar(32) DEFAULT NULL COMMENT '密码',
`user_sex` varchar(32) DEFAULT NULL,
`nick_name` varchar(32) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=28 DEFAULT CHARSET=utf8;
arquivo pom:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.chun</groupId>
<artifactId>spring-boot-mybatis-sharding-jdbc</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>1.4.2.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<java.version>1.8</java.version>
</properties>
<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>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.mybatis.spring.boot</groupId>
<artifactId>mybatis-spring-boot-starter</artifactId>
<version>1.1.1</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-devtools</artifactId>
<optional>true</optional>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--sharding-jdbc -->
<dependency>
<groupId>com.dangdang</groupId>
<artifactId>sharding-jdbc-core</artifactId>
<version>1.5.4</version>
</dependency>
<!--<dependency>-->
<!--<groupId>javax.persistence</groupId>-->
<!--<artifactId>persistence-api</artifactId>-->
<!--<version>1.0</version>-->
<!--</dependency>-->
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
<configuration>
<fork>true</fork>
</configuration>
</plugin>
</plugins>
</build>
</project>
O sub-biblioteca principal sub-tabela tem várias configurações:
- Quantas fontes de dados
- O nome lógico de cada mesa e uma mesa de todos os nomes de tabela física
- Divide bibliotecas e sub-bibliotecas algoritmo que colunas
- Que mesa parte de uma coluna, e um algoritmo de sub tabela
é dividida em duas piscinas:test_msg1 , test_msg2,
cada biblioteca contém duas tabelas:t_order_0 , t_order_1
usouser_idcomo uma sub-biblioteca colunas;
utilizadosorder_idcomo um colunas sub-mesa;
perfis:
application.properties
atributos de fonte de dados de dados de configuração associado.
mybatis.config-locations=classpath:mybatis/mybatis-config.xml
#datasource
spring.devtools.remote.restart.enabled=false
#data source1
spring.datasource.test1.driverClassName=com.mysql.jdbc.Driver
spring.datasource.test1.url=jdbc:mysql://127.0.0.1:3306/test_msg1
spring.datasource.test1.username=root
spring.datasource.test1.password=root
#data source2
spring.datasource.test2.driverClassName=com.mysql.jdbc.Driver
spring.datasource.test2.url=jdbc:mysql://127.0.0.1:3306/test_msg2
spring.datasource.test2.username=root
spring.datasource.test2.password=root
Inscrição
Application.java
package com.chun;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.transaction.annotation.EnableTransactionManagement;
/**
* Created by Kane on 2018/1/17.
*/
@SpringBootApplication
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) //排除DataSourceConfiguratrion
@EnableTransactionManagement(proxyTargetClass = true) //开启事物管理功能
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
definição da entidade de classes de entidade
UserEntity.java
package com.chun.entity;
import com.chun.enums.UserSexEnum;
import java.io.Serializable;
/**
* Created by Kane on 2018/1/17.
*/
public class UserEntity implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
private Long order_id;
private Long user_id;
private String userName;
private String passWord;
private UserSexEnum userSex;
private String nickName;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public Long getOrder_id() {
return order_id;
}
public void setOrder_id(Long order_id) {
this.order_id = order_id;
}
public Long getUser_id() {
return user_id;
}
public void setUser_id(Long user_id) {
this.user_id = user_id;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassWord() {
return passWord;
}
public void setPassWord(String passWord) {
this.passWord = passWord;
}
public UserSexEnum getUserSex() {
return userSex;
}
public void setUserSex(UserSexEnum userSex) {
this.userSex = userSex;
}
public String getNickName() {
return nickName;
}
public void setNickName(String nickName) {
this.nickName = nickName;
}
}
UserSexEnum.java
package com.chun.enums;
/**
* Created by Kane on 2018/1/17.
*/
public enum UserSexEnum {
MAN, WOMAN
}
Camada de serviço
User1Service.java
package com.chun.service;
import com.chun.entity.UserEntity;
import com.chun.mapper.User1Mapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* Created by Kane on 2018/1/17.
*/
@Slf4j
@Service
public class User1Service {
@Autowired
private User1Mapper user1Mapper;
public List<UserEntity> getUsers() {
List<UserEntity> users=user1Mapper.getAll();
return users;
}
// @Transactional(value="test1TransactionManager",rollbackFor = Exception.class,timeout=36000) //说明针对Exception异常也进行回滚，如果不标注，则Spring 默认只有抛出 RuntimeException才会回滚事务
public void updateTransactional(UserEntity user) {
try{
user1Mapper.insert(user);
log.error(String.valueOf(user));
}catch(Exception e){
log.error("find exception!");
throw e; // 事物方法中，如果使用trycatch捕获异常后，需要将异常抛出，否则事物不回滚。
}
}
}
camada mapeador
User1Mapper.java
package com.chun.mapper;
import com.chun.entity.UserEntity;
import java.util.List;
/**
* Created by Kane on 2018/1/17.
*/
public interface User1Mapper {
List<UserEntity> getAll();
void update(UserEntity user);
}
Dados de configuração de origem e configuração MyBatis:
Uma pluralidade de fontes de dados, nomes de fonte de dados melhor ter uma certa regra, organizado para facilitar a regra de cálculo do sub-biblioteca;
configuração de regras de origem de dados, ou seja, uma pluralidade de fontes de dados para a gestão sharding-jdbc, e pode definir a fonte de dados padrão quando nenhuma tabela regra sub-biblioteca usando a configuração padrão da fonte de dados;
sub-biblioteca: user_id % 2 = 0os dados são armazenados test_msg1, os dados 1 é armazenado na test_msg0
tabela de parte: order_id % 2 = 0os dados são armazenados t_order_0, os dados são armazenados no 1t_order_1
DataSourceConfig.java
package com.chun;
import com.chun.strategy.ModuloDatabaseShardingAlgorithm;
import com.chun.strategy.ModuloTableShardingAlgorithm;
import com.dangdang.ddframe.rdb.sharding.api.ShardingDataSourceFactory;
import com.dangdang.ddframe.rdb.sharding.api.rule.BindingTableRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.DataSourceRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.ShardingRule;
import com.dangdang.ddframe.rdb.sharding.api.rule.TableRule;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.DatabaseShardingStrategy;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.TableShardingStrategy;
import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import javax.sql.DataSource;
import java.sql.SQLException;
import java.util.*;
/**
* 数据源及分表配置
* Created by Kane on 2018/1/17.
*/
@Configuration
@MapperScan(basePackages = "com.chun.mapper", sqlSessionTemplateRef = "test1SqlSessionTemplate")
public class DataSourceConfig {
/**
* 配置数据源0，数据源的名称最好要有一定的规则，方便配置分库的计算规则
* @return
*/
@Bean(name="dataSource0")
@ConfigurationProperties(prefix = "spring.datasource.test1")
public DataSource dataSource0(){
return DataSourceBuilder.create().build();
}
/**
* 配置数据源1，数据源的名称最好要有一定的规则，方便配置分库的计算规则
* @return
*/
@Bean(name="dataSource1")
@ConfigurationProperties(prefix = "spring.datasource.test2")
public DataSource dataSource1(){
return DataSourceBuilder.create().build();
}
/**
* 配置数据源规则，即将多个数据源交给sharding-jdbc管理，并且可以设置默认的数据源，
* 当表没有配置分库规则时会使用默认的数据源
* @param dataSource0
* @param dataSource1
* @return
*/
@Bean
public DataSourceRule dataSourceRule(@Qualifier("dataSource0") DataSource dataSource0,
@Qualifier("dataSource1") DataSource dataSource1){
Map<String, DataSource> dataSourceMap = new HashMap<>(); //设置分库映射
dataSourceMap.put("dataSource0", dataSource0);
dataSourceMap.put("dataSource1", dataSource1);
return new DataSourceRule(dataSourceMap, "dataSource0"); //设置默认库，两个库以上时必须设置默认库。默认库的数据源名称必须是dataSourceMap的key之一
}
/**
* 配置数据源策略和表策略，具体策略需要自己实现
* @param dataSourceRule
* @return
*/
@Bean
public ShardingRule shardingRule(DataSourceRule dataSourceRule){
//具体分库分表策略
TableRule orderTableRule = TableRule.builder("t_order")
.actualTables(Arrays.asList("t_order_0", "t_order_1"))
.tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
.dataSourceRule(dataSourceRule)
.build();
//绑定表策略，在查询时会使用主表策略计算路由的数据源，因此需要约定绑定表策略的表的规则需要一致，可以一定程度提高效率
List<BindingTableRule> bindingTableRules = new ArrayList<BindingTableRule>();
bindingTableRules.add(new BindingTableRule(Arrays.asList(orderTableRule)));
return ShardingRule.builder()
.dataSourceRule(dataSourceRule)
.tableRules(Arrays.asList(orderTableRule))
.bindingTableRules(bindingTableRules)
.databaseShardingStrategy(new DatabaseShardingStrategy("user_id", new ModuloDatabaseShardingAlgorithm()))
.tableShardingStrategy(new TableShardingStrategy("order_id", new ModuloTableShardingAlgorithm()))
.build();
}
/**
* 创建sharding-jdbc的数据源DataSource，MybatisAutoConfiguration会使用此数据源
* @param shardingRule
* @return
* @throws SQLException
*/
@Bean(name="dataSource")
public DataSource shardingDataSource(ShardingRule shardingRule) throws SQLException {
return ShardingDataSourceFactory.createDataSource(shardingRule);
}
/**
* 需要手动配置事务管理器
* @param dataSource
* @return
*/
@Bean
public DataSourceTransactionManager transactitonManager(@Qualifier("dataSource") DataSource dataSource){
return new DataSourceTransactionManager(dataSource);
}
@Bean(name = "test1SqlSessionFactory")
@Primary
public SqlSessionFactory testSqlSessionFactory(@Qualifier("dataSource") DataSource dataSource) throws Exception {
SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
bean.setDataSource(dataSource);
bean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/*.xml"));
return bean.getObject();
}
@Bean(name = "test1SqlSessionTemplate")
@Primary
public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
return new SqlSessionTemplate(sqlSessionFactory);
}
}
implementação de políticas sub-biblioteca:
ModuloDatabaseShardingAlgorithm.java
package com.chun.strategy;
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.database.SingleKeyDatabaseShardingAlgorithm;
import com.google.common.collect.Range;
import java.util.Collection;
import java.util.LinkedHashSet;
/**
* 分库策略的简单实现
* Created by Kane on 2018/1/22.
*/
public class ModuloDatabaseShardingAlgorithm implements SingleKeyDatabaseShardingAlgorithm<Long> {
@Override
public String doEqualSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
for (String each : databaseNames) {
if (each.endsWith(Long.parseLong(shardingValue.getValue().toString()) % 2 + "")) {
return each;
}
}
throw new IllegalArgumentException();
}
@Override
public Collection<String> doInSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(databaseNames.size());
for (Long value : shardingValue.getValues()) {
for (String tableName : databaseNames) {
if (tableName.endsWith(value % 2 + "")) {
result.add(tableName);
}
}
}
return result;
}
@Override
public Collection<String> doBetweenSharding(Collection<String> databaseNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(databaseNames.size());
Range<Long> range = (Range<Long>) shardingValue.getValueRange();
for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
for (String each : databaseNames) {
if (each.endsWith(i % 2 + "")) {
result.add(each);
}
}
}
return result;
}
}
Método de depuração doEqualSharding vai encontrar:
Sub-biblioteca .png código
doEqualSharding parâmetros .png
Retorna o nome da biblioteca de roteamento com base no valor de user_id.
Sub-bibliotecas:
dados id_usuario% 2 = 0 é armazenado no test_msg1, os dados de armazenar um de test_msg0,
A estratégia básica para alcançar sub-meter
necessidade sub-tabela lógico para implementar SingleKeyTableShardingAlgorithmtrês métodos da interfacedoBetweenSharding、doEqualSharding、doInSharding
ModuloTableShardingAlgorithm.java
package com.chun.strategy;
import com.dangdang.ddframe.rdb.sharding.api.ShardingValue;
import com.dangdang.ddframe.rdb.sharding.api.strategy.table.SingleKeyTableShardingAlgorithm;
import com.google.common.collect.Range;
import java.util.Collection;
import java.util.LinkedHashSet;
/**
* 分表策略的基本实现
* Created by Kane on 2018/1/22.
*/
public class ModuloTableShardingAlgorithm implements SingleKeyTableShardingAlgorithm<Long> {
@Override
public String doEqualSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
for (String each : tableNames) {
if (each.endsWith(shardingValue.getValue() % 2 + "")) {
return each;
}
}
throw new IllegalArgumentException();
}
@Override
public Collection<String> doInSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(tableNames.size());
for (Long value : shardingValue.getValues()) {
for (String tableName : tableNames) {
if (tableName.endsWith(value % 2 + "")) {
result.add(tableName);
}
}
}
return result;
}
@Override
public Collection<String> doBetweenSharding(Collection<String> tableNames, ShardingValue<Long> shardingValue) {
Collection<String> result = new LinkedHashSet<>(tableNames.size());
Range<Long> range = (Range<Long>) shardingValue.getValueRange();
for (Long i = range.lowerEndpoint(); i <= range.upperEndpoint(); i++) {
for (String each : tableNames) {
if (each.endsWith(i % 2 + "")) {
result.add(each);
}
}
}
return result;
}
}
camada controlador
UserController.java
package com.chun.web;
import com.chun.entity.UserEntity;
import com.chun.enums.UserSexEnum;
import com.chun.service.User1Service;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* Created by Kane on 2018/1/17.
*/
@Service
@RestController
public class UserController {
@Autowired
private User1Service user1Service;
@RequestMapping("/getUsers")
public List<UserEntity> getUsers() {
List<UserEntity> users=user1Service.getUsers();
return users;
}
//测试
@RequestMapping(value="update1")
public String updateTransactional(@RequestParam(value = "id") Long id,
@RequestParam(value = "user_id") Long user_id,
@RequestParam(value = "order_id") Long order_id,
@RequestParam(value = "nickName") String nickName,
@RequestParam(value = "passWord") String passWord,
@RequestParam(value = "userName") String userName
) {
UserEntity user2 = new UserEntity();
user2.setId(id);
user2.setUser_id(user_id);
user2.setOrder_id(order_id);
user2.setNickName(nickName);
user2.setPassWord(passWord);
user2.setUserName(userName);
user2.setUserSex(UserSexEnum.WOMAN);
user1Service.updateTransactional(user2);
return "test";
}
}
perfil MyBatis
resources/mybatis/mapper/UserMapper.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
<mapper namespace="com.chun.mapper.User1Mapper" >
<resultMap id="BaseResultMap" type="com.chun.entity.UserEntity" >
<id column="id" property="id" jdbcType="BIGINT" />
<result column="order_id" property="order_id" jdbcType="BIGINT" />
<result column="user_id" property="user_id" jdbcType="BIGINT" />
<result column="userName" property="userName" jdbcType="VARCHAR" />
<result column="passWord" property="passWord" jdbcType="VARCHAR" />
<result column="user_sex" property="userSex" javaType="com.chun.enums.UserSexEnum"/>
<result column="nick_name" property="nickName" jdbcType="VARCHAR" />
</resultMap>
<sql id="Base_Column_List" >
id, userName, passWord, user_sex, nick_name
</sql>
<select id="getAll" resultMap="BaseResultMap" >
SELECT
<include refid="Base_Column_List" />
FROM t_order
</select>
<insert id="insert" parameterType="com.chun.entity.UserEntity" >
INSERT INTO
t_order
(order_id,user_id,userName,passWord,user_sex)
VALUES
(#{order_id},#{user_id},#{userName}, #{passWord}, #{userSex})
</insert>
</mapper>
resources/mybatis/mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN" "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<typeAliases>
<typeAlias alias="Integer" type="java.lang.Integer" />
<typeAlias alias="Long" type="java.lang.Long" />
<typeAlias alias="HashMap" type="java.util.HashMap" />
<typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
<typeAlias alias="ArrayList" type="java.util.ArrayList" />
<typeAlias alias="LinkedList" type="java.util.LinkedList" />
</typeAliases>
</configuration>
No projeto da fragmentação banco de dados mysql, a base é muito importante é escolher SHARD CHAVE e SHARD CHAVE como distribuição.
SHARD CHAVE seleccionar um princípio básico de acordo com os tipos de serviços é possível tornar os dados dispersos em uma pluralidade de servidores Sharding.
O primeiro método é seleccionado como um campo ESTILHAÇO CHAVE, de acordo com as características de ESTILHAÇO CHAVE pode ser seleccionado com base na Sharding de hash, Range, e lista.
Exemplo, existem três nós Sharding, de acordo com o CHAVE valor ESTILHAÇO respectivamente em esse hash três nós sharding .Range significa que para
um determinado intervalo de valores SHARD CHAVE serão armazenados em um nós sharding distribuídos ao longo de vários compartilhada, e eu acredito que a compreensão da partição de
amigos deve estar muito familiarizado com. por exemplo, há um ordens de mesa estrutura de mesa como se segue:
criar order_item mesa
(inteiro ID,
número inteiro uid,
valor inteiro)
ALTER TABLE order_item adicionar chave primária (ID );
ID de aplicação gerar um número, e em seguida fazer a operação em conformidade com um ID de hash, tais como id 12302, por função hash, o resultado é um, dados de um nó.
Tal CHAVE ESTILHAÇO métodos de distribuição são um lugar muito bom é quando você precisa para aumentar ou diminuir o nó compartilhado da situação não é partido
terá todos os dados antes de re-distribuição de grandes quantidades de dados no caso de este processo será muito consumo tempo.
Outro método através da criação de uma tabela de tradução, tais como a criação de uma lista de servidores, e, em seguida, seleccionar um pedido na lista por uma função aleatório aleatório
processamento nó Sharding, tal como
IP ID do caco
172.28.10.11 1
2 172.28.10.12
3 172.28.10.13
Aleatoriamente gerado pela aplicação de números aleatórios 1-3, e, em seguida, determinar qual o servidor para processamento. A vantagem dessa abordagem é aumentar os nós de exclusão Sharding e
são nó Sharding muito conveniente. Inadequações desta forma não é SHARD KEY, dados completamente processo aleatório, mas pelos Redis ou
alguma otimização memcached, como rastreamento plano original para fazer os valores de campo SHARD chave que foram armazenados em que nó.
Ao rastrear Redis ou id memcached e o servidor de armazenamento correspondente, como id 12302 2 está localizado no servidor. Quando o aplicativo precisa
consultar uma ID de registro, começando com a verificação de cache o ID de servidor correspondente é os primeiros números sobre ele, que já não é calculado por SHARD CHAVE SHAREDING próprias regras
nó, e depois ir visitar o correspondente servidor.
Referências:
https://www.jianshu.com/p/74c02a2a89de
