springboot + sharding-jdbc 学习

官网地址：http://shardingsphere.io/document/current/cn/overview/

sharding-jdbc事务:https://blog.csdn.net/yanyan19880509/article/details/78335935

1简介

通过docker搭建四台mysql，两主，每台一从；springboot搭建简单的web项目，并配置sharding-jdbc实现分库分表+独写分离；

sharding-jdbc是在datasource层做的代理，对应用透明，只需在datasource配置好读写分离/分库分表策略即可，原理可参见官网；

2 docker搭建mysql

硬件环境：虚拟机 centos7 4G内存 20G硬盘 mysql5.7.13

1 安装docker ： yum install docker 并启动

2 获取mysql镜像： docker pull mysql:5.7.13

3 在虚拟机上配置四台mysql配置文件my.cnf，目录结构如下，主要是配置log-bin和server-id，主从之间server-id不能相同

tip：可以先启动一台mysql容器，然后拷贝容器的配置到本地 docker cp mysql:/etc/mysql/my.cnf /etc/mysql/master-order0/，再在这配置中修改log-bin和server-id

4 启动mysql容器：

docker run --name master-order0 -d -p 13306:3306 -v /etc/mysql/master-order0/my.cnf:/etc/mysql/my.cnf -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.13 //主 master0

docker run --name master-order1 -d -p 23306:3306 -v /etc/mysql/master-order1/my.cnf:/etc/mysql/my.cnf -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.13 //主master1

docker run --name slave-order0 -d -p 13307:3306 -v /etc/mysql/slave-order0/my.cnf:/etc/mysql/my.cnf -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.13 //从slave0 作为master0的从

docker run --name slave-order1 -d -p 23307:3306 -v /etc/mysql/master-order0/my.cnf:/etc/mysql/my.cnf -e MYSQL_ROOT_PASSWORD=123456 mysql:5.7.13 //从slave1 作为master1的从

说明 --name 指定容器名称，-d后台运行 -v 使用本地配置代替容器自身的配置文件 -e 设置mysql root密码

配置主从：配置前需要关闭虚拟机防火墙： service firewalld stop

进入 slave-order0： docker exec -it slave-order0 /bin/bash

进入mysql：mysql -uroot -p123456

配置主从： change master to MASTER_HOST='主机ip'，MASTER_PORT=13306,MASTER_USER='ROOT',MASTER_PASSWORD='123456',

MASTER_LOG_FILE='主中的log-bin名称'，MASTER_LOG_POS=主机log-bin的pos ；

其中MASTER_LOG_FILE和MASTER_LOG_POS需要到主上查看，进入主master-order0数据库，show master status \G 可以查看到这两个参数

另外的master-order1和slave-order1配置方式相同；

在两主上建立相同的库和表，库 tyyd; 每个库上新建两张表 order0，order1 表结构相同，表id不要设置为自增，由sharding-jdbc生成；

可以到从数据库上查看到对应的库和表也已经生成；

3springboot+sharding-jdbc搭建web项目

idea中新建web项目，引入sharding-jdbc maven依赖

<!-- https://mvnrepository.com/artifact/io.shardingsphere/sharding-jdbc -->
<dependency>
    <groupId>io.shardingsphere</groupId>
    <artifactId>sharding-jdbc</artifactId>
    <version>3.0.0.M2</version>
</dependency>
1 配置sharding-jdbc 分库分表+独写分离 datasource（也可以采用只独写分离或只分库分表），可以有多种配置方式，我采用的是代码的配置方式：

/**
 * @author cgl
 * @date 2018/8/15 11:12
 * <p>
 * 读写分离+分库分表
 */
@Configuration
public class ShardingJDBCSplitAndMsDataSourceConfig {
    @Bean
    DataSource getDataSource() throws SQLException {
        ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
        shardingRuleConfig.getTableRuleConfigs().add(getOrderTableRuleConfiguration());
//        shardingRuleConfig.getTableRuleConfigs().add(getOrderItemTableRuleConfiguration());
//        shardingRuleConfig.getBindingTableGroups().add("t_order, t_order_item");

//分库策略：根据参数userId取摸计算，此处的ds和下面一行中的order都是逻辑库/表名
        shardingRuleConfig.setDefaultDatabaseShardingStrategyConfig(new InlineShardingStrategyConfiguration("user_id", "ds${user_id % 2}"));
//分表策略：根据参数id取模计算
        shardingRuleConfig.setDefaultTableShardingStrategyConfig(new InlineShardingStrategyConfiguration("id", "order${id % 2}"));
        shardingRuleConfig.setMasterSlaveRuleConfigs(getMasterSlaveRuleConfigurations());
//实际项目需自定义keyGenerator或使用默认的
        shardingRuleConfig.setDefaultKeyGenerator(System::currentTimeMillis );
        return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), shardingRuleConfig, new HashMap<>(), new Properties());
    }

    TableRuleConfiguration getOrderTableRuleConfiguration() {
        TableRuleConfiguration result = new TableRuleConfiguration();
        result.setLogicTable("order");
        result.setActualDataNodes("ds${0..1}.order${0..1}");
        result.setKeyGeneratorColumnName("id");
        return result;
    }

    List<MasterSlaveRuleConfiguration> getMasterSlaveRuleConfigurations() {
        MasterSlaveRuleConfiguration masterSlaveRuleConfig1 = new MasterSlaveRuleConfiguration("ds0", "ds_master_0", Arrays.asList("ds_master_0_slave_0"));
        MasterSlaveRuleConfiguration masterSlaveRuleConfig2 = new MasterSlaveRuleConfiguration("ds1", "ds_master_1", Arrays.asList("ds_master_1_slave_0"));
        return Lists.newArrayList(masterSlaveRuleConfig1, masterSlaveRuleConfig2);
    }

    Map<String, DataSource> createDataSourceMap() {
        final Map<String, DataSource> result = new HashMap<>();
        result.put("ds_master_0", createDatasource("com.mysql.jdbc.Driver", "jdbc:mysql://192.168.137.128:13306/tyyd?useUnicode=true&characterEncoding=utf-8&useSSL=false", "root", "123456"));
        result.put("ds_master_1", createDatasource("com.mysql.jdbc.Driver", "jdbc:mysql://192.168.137.128:23306/tyyd?useUnicode=true&characterEncoding=utf-8&useSSL=false", "root", "123456"));
        result.put("ds_master_0_slave_0", createDatasource("com.mysql.jdbc.Driver", "jdbc:mysql://192.168.137.128:13307/tyyd?useUnicode=true&characterEncoding=utf-8&useSSL=false", "root", "123456"));
        result.put("ds_master_1_slave_0", createDatasource("com.mysql.jdbc.Driver", "jdbc:mysql://192.168.137.128:23307/tyyd?useUnicode=true&characterEncoding=utf-8&useSSL=false", "root", "123456"));
        return result;
    }

    private HikariDataSource createDatasource(String driverClassName, String jdbcUrl, String userName, String password) {
        HikariConfig hikariConfig0 = new HikariConfig();
        hikariConfig0.setDriverClassName(driverClassName);
        hikariConfig0.setJdbcUrl(jdbcUrl);
        hikariConfig0.setUsername(userName);
        hikariConfig0.setPassword(password);
        return new HikariDataSource(hikariConfig0);
    }
}

2 编写order Controller crud操作

package com.sj.web.controller;
import com.sj.client.request.order.OrderAddRequest;
import com.sj.client.request.order.OrderUpdateRequest;
import com.sj.client.response.order.OrderDetail;
import com.sj.client.service.order.OrderService;
import com.sj.web.dto.BaseResponse;
import com.sj.web.dto.order.OrderDTO;
import org.apache.commons.lang3.RandomUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

/**
 * @author cgl
 * @date 2018/8/16 15:00
 */
@RestController
@RequestMapping("/order")
public class OrderController {

    @Autowired
    private OrderService orderService;
    @RequestMapping("/get/{id}/{userId}")
    public OrderDTO getOrderInfo(@PathVariable("id") long id,@PathVariable("userId") long userId){
        Optional<OrderDetail> orderDetailOptional = orderService.getOrderInfoByOrderId(id,userId);
        if(orderDetailOptional.isPresent()){
            OrderDetail detail = orderDetailOptional.get();
            return convert(detail);
        }
        return new OrderDTO();
    }

    private OrderDTO convert(OrderDetail detail) {
        OrderDTO dto=new OrderDTO();
        dto.setId(detail.getId());
        dto.setPrice(detail.getPrice());
        dto.setProdId(detail.getProdId());
        dto.setUserId(detail.getUserId());
        return dto;
    }

    @RequestMapping("/delete/{id}/{userId}")
    public BaseResponse delete(@PathVariable("id") long id,@PathVariable("userId") long userId){
        orderService.deleteOrder(id,userId);
        return new BaseResponse();
    }

    @RequestMapping("/update")
    public BaseResponse update(@RequestBody OrderDTO order){
        OrderUpdateRequest updateOrder=new OrderUpdateRequest();
        updateOrder.setId(order.getId());
        updateOrder.setPrice(order.getPrice());
        updateOrder.setProdId(order.getProdId());
        updateOrder.setUserId(order.getUserId());
        orderService.updateOrder(updateOrder);
        return new BaseResponse();
    }

    @RequestMapping("/add")
    public BaseResponse add(@RequestBody OrderDTO order){
        OrderAddRequest request=new OrderAddRequest();
        request.setPrice(order.getPrice());
        request.setProdId(order.getProdId());
        request.setUserId(RandomUtils.nextInt(10,20));
        orderService.insertOrder(request);
        BaseResponse baseResponse = new BaseResponse();
        return baseResponse;
    }

    @RequestMapping("/getlist/{userId}")
    public BaseResponse orderList(@PathVariable long userId){
        List<OrderDetail>orders= orderService.getOrderListByUserId(userId);
        List<OrderDTO> orderDTOS = orders.stream().map(this::convert).collect(Collectors.toList());
        BaseResponse response=new BaseResponse();
        response.setSuccess(true);
        response.setCode(200);
        response.setData(orderDTOS);
        return response;
    }
}

其他service层代码就是简单调用，mapper代码

@Mapper
public interface OrderMapper {

    @Select("select id,prod_id prodId,user_id userId,price  from order where id =#{id} and user_id=#{userId}")
    Order selectByPrimaryKey(@Param("id") long id,@Param("userId") long userId);

//此处不应出现id，否则sharding-jdbc不会自动生成id
    @Insert("insert into order (prod_id,user_id,price) value(#{prodId},#{userId},#{price} )")
    void insertOrder(Order order);

    @Delete("delete from order where id=#{id} and user_id=#{userId}")
    void deleteById(@Param("id") long id,@Param("userId")long userId);

    @Update("update order set prod_id=#{prodId},user_id=#{userId},price=#{price} where id=#{id}")
    void updateOrder(Order order);

    @Select("select id,prod_id prodId,user_id userId,price  from order where user_id=#{userId}")
    List<Order> selectListByUserId(long userId);
}

4测试

新增/获取/获取列表等都正常。测试结果略

以上是这两天学习sharding-jdbc的简单入门demo，前路漫漫~~