sharding sphere4.0.1——简单实现分表分库，读写分离，xa分布式事务

最新推荐文章于 2023-12-04 17:51:28 发布
最新推荐文章于 2023-12-04 17:51:28 发布
阅读量1.3k 收藏 5
点赞数
分类专栏： mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39506978/article/details/105354557
版权

一 简介官网

始于当当开源的shardingjdbc，功能较单一，2018进入Apache基金会孵化器。目前最新apache版本ShardingSphere是4.0.1。ShardingSphere一套开源的分布式数据库中间件解决方案组成的生态圈，它由Sharding-JDBC、Sharding-Proxy和Sharding-Sidecar（计划中）这3款相互独立的产品组成.常用核心功能有分表分库（行表达式）与读写分离（基于SQL语句类型路由DQL/DML），分布式事务（xa事务，默认atomicos，如果能接受2pc的性能损失，分分钟解决分布式事务）

二 依赖

        <!--分表分库与读写分离-->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.0.1</version>
        </dependency>

        <!--XA分布式事务依赖-->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-transaction-xa-core</artifactId>
            <version>4.0.1</version>
        </dependency>

三  配置文件

spring:
  shardingsphere:
    datasource:
      names: ds0,ds0slave0,ds0slave1,ds1,ds1slave0,ds1slave1
      ds0:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3306/ds0
        username: root
        password: 123456
      ds0slave0:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3301/ds0
        username: root
        password: 123456
      ds0slave1:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3302/ds0
        username: root
        password: 123456
      ds1:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3306/ds1
        username: root
        password: 123456
      ds1slave0:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3301/ds1
        username: root
        password: 123456
      ds1slave1:
        type: com.zaxxer.hikari.HikariDataSource
        driverClassCame: com.mysql.jdbc.Driver
        jdbcUrl: jdbc:mysql://192.168.203.132:3302/ds1
        username: root
        password: 123456
    sharding:
      tables:
        t_order:
          actual-data-nodes: ms_ds$->{0..1}.t_order$->{0..1} #行表达式 ds1.t_order1,$->{}是为了区分spring 的${}
          ## 指定分库规则
          database-strategy:
            inline:
              sharding-column: user_id
              algorithm-expression: ms_ds$->{user_id % 2}
          ## 指定分表规则
          table-strategy:
            inline:
              sharding-column: order_id
              algorithm-expression: t_order$->{order_id % 2}

        t_order_item:
          actual-data-nodes: ms_ds$->{0..1}.t_order_item$->{0..1}
          ## 通过hint方式自定义分库规则,这里需要根据userid路由，但order_item表没有该路由键，固自定义hint,然后绑定主表与子表，避免关联查询导致的全数据源路由
          database-strategy:
            hint:
              algorithmClassName: com.construn.vehicle.user.core.HintSharding
          ## 指定分表规则
          table-strategy:
            inline:
              sharding-column: order_id
              algorithm-expression: t_order_item$->{order_id % 2}
          ## 雪花算法主键生成
          key-generator:
            column: item_id
            type: SNOWFLAKE

      ## 绑定主表与子表，避免关联查询导致的全数据源路由
      binding-tables: t_order,t_order_item

      ## 配置广播表：以广播的形式增删改所有库（如果只涉及查询的话可以不配置，轮询查询）
      broadcast-tables: t_config
    
   
    ## 读写分离
      masterSlaveRules:
        ms_ds0:
          masterDataSourceName: ds0
          slaveDataSourceNames:
          - ds0slave0
          - ds0slave1
          loadBalanceAlgorithmType: ROUND_ROBIN
        ms_ds1:
          masterDataSourceName: ds1
          slaveDataSourceNames:
          - ds1slave0
          - ds1slave1
          loadBalanceAlgorithmType: ROUND_ROBIN
    ## 打印sql，显示当前sql路由的数据库
    props:
      sql:
        show: true

四/测试。参考https://blog.csdn.net/u011212394/article/details/101101633

建表脚本

create table t_config
(
  id               int                                 not null
    primary key,
  remark           varchar(50)                         null,
  create_time      timestamp default CURRENT_TIMESTAMP not null,
  last_modify_time timestamp default CURRENT_TIMESTAMP not null
  on update CURRENT_TIMESTAMP
);

create table t_order0
(
  order_id         int                                 not null
    primary key,
  user_id          int                                 not null,
  config_id        int                                 not null,
  remark           varchar(50)                         null,
  create_time      datetime default CURRENT_TIMESTAMP  not null,
  last_modify_time timestamp default CURRENT_TIMESTAMP not null
  on update CURRENT_TIMESTAMP
);

create table t_order1
(
  order_id         int                                 not null
    primary key,
  user_id          int                                 not null,
  config_id        int                                 not null,
  remark           varchar(50)                         null,
  create_time      timestamp default CURRENT_TIMESTAMP not null,
  last_modify_time timestamp default CURRENT_TIMESTAMP not null
  on update CURRENT_TIMESTAMP
);

create table t_order_item0
(
  item_id          bigint auto_increment
    primary key,
  order_id         bigint                              not null,
  remark           varchar(50)                         null,
  create_time      timestamp default CURRENT_TIMESTAMP not null,
  last_modify_time timestamp default CURRENT_TIMESTAMP not null
  on update CURRENT_TIMESTAMP
);

create table t_order_item1
(
  item_id          bigint auto_increment
    primary key,
  order_id         bigint                              not null,
  remark           varchar(50)                         null,
  create_time      timestamp default CURRENT_TIMESTAMP not null,
  last_modify_time timestamp default CURRENT_TIMESTAMP not null
  on update CURRENT_TIMESTAMP
);

Config.java

@Setter
@Getter
@ToString
public class Config {
 
    private Integer id;
 
    private String remark;
 
    private Date createTime;
 
    private Date lastModifyTime;
}

Order.java

@Getter
@Setter
@ToString
public class Order {
 
    private Integer orderId;
 
    private Integer userId;
 
    private Integer configId;
 
    private String remark;
 
    private Date createTime;
 
    private Date lastModifyTime;
}

OrderItem.java

@Getter
@Setter
@ToString
public class OrderItem {
    
    private Long itemId;
 
    private Integer orderId;
 
    private String remark;
 
    private Date createTime;
 
    private Date lastModifyTime;
}

ConfigMapper.java

@Mapper
public interface ConfigMapper {
    @Insert("insert into t_config(id,remark) values(#{id},#{remark})")
    Integer save(Config config);
 
    @Select("select * from t_config  where id = #{id}")
    Config selectById(Integer id);
}

OrderMapper.java

@Mapper
public interface OrderMapper {
 
    @Insert("insert into t_order(order_id,user_id,config_id,remark) values(#{orderId},#{userId},#{configId},#{remark})")
    Integer save(Order order);
 
    @Select("select order_id orderId, user_id userId, config_id configId, remark from t_order  where user_id = #{userId}")
    Order selectByUserId(Integer userId);
 
    @Select("select o.order_id orderId, o.user_id userId, o.config_id configId, o.remark from " +
            "t_order o inner join t_order_item i on o.order_id = i.order_id " +
            "where o.user_id =#{userId} and o.order_id =#{orderId}")
    List<Order> selectOrderJoinOrderItem(Integer userId, Integer orderId);
 
    @Select("select  o.order_id orderId, o.user_id userId, o.config_id configId, o.remark " +
            "from t_order o inner join t_config c on o.config_id = c.id " +
            "where o.user_id =#{userId} and o.order_id =#{orderId}")
    List<Order> selectOrderJoinConfig(Integer userId, Integer orderId);
}

OrderItemMapper.java

@Mapper
public interface OrderItemMapper {
    @Insert("insert into t_order_item(order_id,remark) values(#{orderId},#{remark})")
    Integer save(OrderItem orderItem);
}

OrderService.java

public interface OrderService {
    Integer saveOrder(Order order);
 
    Integer saveOrderItem(OrderItem orderItem, Integer userId);
 
    Order selectByUserId(Integer userId);
 
    List<Order> selectOrderJoinOrderItem(Integer userId, Integer orderId);
 
    List<Order> selectOrderJoinOrderItemNoSharding(Integer userId, Integer orderId);
 
    List<Order> selectOrderJoinConfig(Integer userId, Integer orderId);
 
    Integer saveConfig(Config config);
 
    Config selectConfig(Integer id);
}

OrderServiceImpl

@Service
public class OrderServiceImpl implements OrderService {
 
    @Autowired
    private OrderMapper orderMapper;
 
    @Autowired
    private OrderItemMapper orderItemMapper;
 
    @Autowired
    private ConfigMapper configMapper;
 
    @Override
    public Integer saveOrder(Order order) {
        return orderMapper.save(order);
    }
 
    @Override
    public Integer saveOrderItem(OrderItem orderItem, Integer userId) {
        try (HintManager hintManager = HintManager.getInstance()) {
            hintManager.addDatabaseShardingValue("t_order_item", userId);
            return orderItemMapper.save(orderItem);
        }
    }
 
    @Override
    public Order selectByUserId(Integer userId) {
        return orderMapper.selectByUserId(userId);
    }
 
    @Override
    public List<Order> selectOrderJoinOrderItem(Integer userId, Integer orderId) {
        try (HintManager hintManager = HintManager.getInstance()) {
            hintManager.addDatabaseShardingValue("t_order_item", userId);
            return orderMapper.selectOrderJoinOrderItem(userId, orderId);
        }
    }
 
    @Override
    public List<Order> selectOrderJoinOrderItemNoSharding(Integer userId, Integer orderId) {
        return orderMapper.selectOrderJoinOrderItem(userId, orderId);
    }
 
    @Override
    public List<Order> selectOrderJoinConfig(Integer userId, Integer orderId) {
        return orderMapper.selectOrderJoinConfig(userId, orderId);
    }
 
    @Override
    public Integer saveConfig(Config config) {
        return configMapper.save(config);
    }
 
    @Override
    public Config selectConfig(Integer id) {
        return configMapper.selectById(id);
    }
}

 

hint自定义分库路由

public class HintSharding implements HintShardingAlgorithm<Integer> {
    @Override
    public Collection<String> doSharding(Collection<String> availableTargetNames, HintShardingValue<Integer> hintShardingValue) {
        Collection<String> result = new ArrayList<>();
        for (String each : availableTargetNames) {
            for (Integer value : hintShardingValue.getValues()) {
                if (each.endsWith(String.valueOf(value % 2))) {
                    result.add(each);
                }
            }
        }
        return result;
    }
}

单元测试


@RunWith(SpringRunner.class)
@SpringBootTest
public class VehicleUserApplicationTests {


        @Autowired
        private OrderService orderService;

        @Test
        @ShardingTransactionType(value = TransactionType.XA)
        @Transactional(rollbackFor = Exception.class)

        public void testSaveOrder() {
            for (int i = 0; i < 10; i++) {
                Integer orderId = 1000 + i;
                Integer userId = 10 + i;

                Order o = new Order();
                o.setOrderId(orderId);
                o.setUserId(userId);
                o.setConfigId(i);
                o.setRemark("save.order");
                orderService.saveOrder(o);
                if (orderId>1005) {
                  int a=1/0;
                }
                OrderItem oi = new OrderItem();
                oi.setOrderId(orderId);
                oi.setRemark("save.orderItem");
                orderService.saveOrderItem(oi, userId);
            }
        }

        /**
         * 根据分片键查询
         *
         * @param
         * @return void
         * @author hujy
         * @date 2019-09-20 11:26
         */
        @Test
        public void testSelectByUserId() {
            Integer userId = 12;
            HintManager.getInstance().setMasterRouteOnly();
            Order o1 = orderService.selectByUserId(userId);
            System.out.println(o1);

            userId = 17;
            Order o2 = orderService.selectByUserId(userId);
            System.out.println(o2);

        }

        /**
         * 与分片子表关联
         *
         * @param
         * @return void
         * @author hujy
         * @date 2019-09-20 11:24
         */
        @Test
        public void testSelectOrderJoinOrderItem() {
            // 指定了子表分片规则
            List<Order> o1 = orderService.selectOrderJoinOrderItem(12, 1002);
            System.out.println(o1);
            // 未指定子表分片规则：导致子表的全路由
            List<Order> o2 = orderService.selectOrderJoinOrderItemNoSharding(12, 1002);
            System.out.println(o2);
        }

        /**
         * 与广播表关联
         *
         * @param
         * @return void
         * @author hujy
         * @date 2019-09-20 11:24
         */
        @Test
        public void testSelectOrderJoinConfig() {
            List<Order> o1 = orderService.selectOrderJoinConfig(12, 1002);
            System.out.println(o1);
            List<Order> o2 = orderService.selectOrderJoinConfig(17, 1007);
            System.out.println(o2);
        }

        /**
         * 广播表保存
         * 对所有数据源进行广播
         *
         * @param
         * @return void
         * @author hujy
         * @date 2019-09-20 11:23
         */
        @Test
        public void testSaveConfig() {
            for (int i = 0; i < 10; i++) {
                Config config = new Config();
                config.setId(i);
                config.setRemark("config " + i);
                orderService.saveConfig(config);
                System.out.println();
            }
        }

        /**
         * 广播表查询
         * 随机选择数据源
         *
         * @param
         * @return void
         * @author hujy
         * @date 2019-09-20 11:23
         */
        @Test
        public void testSelectConfig() {
            Config config1 = orderService.selectConfig(5);
            System.out.println(config1);

            Config config2 = orderService.selectConfig(7);
            System.out.println(config2);
        }

    @Test
    public void testUpdateConfig() {
        for (int i = 0; i < 10; i++) {
            Config config = new Config();
            config.setId(i);
            config.setRemark("configNEW " + i);
            orderService.updateConfig(config);
        }
    }

    }

五/其它注意事项

  1. 读写分离配置也可以通过java配置方式，详解官方文档
  2. 读写分离还是要依赖mysql的bin-log日志主从复制实现，主从复制有延迟，有时候必须主库读取，可以读数据前加入代码HintManager.getInstance().setMasterRouteOnly();强制路由到主库。主从复制数据源名貌似不能使用下划线，如ds0_slave0报错

  3. shardingjdbc实现xa分布式事务只需要加入依赖（也支持seata等），增加注解

    @ShardingTransactionType(value = TransactionType.XA)
@Transactional(rollbackFor = Exception.class)

 

 

 

jwolf2
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java猿社区—ShardingSphere-4.0.1之实现分库分表+读写分离
阿祥小王子的博客
03-16 2813
Java猿社区—ShardingSphere-4.0.1之实现分库分表+读写分离 文章目录Java猿社区—ShardingSphere-4.0.1之实现分库分表+读写分离技术体系背景ShardingSphere介绍ShardingShpere支持的功能数据分片分布式事务技术准备mysql安装配置POM配置分库分表+读写分离mysql配置环境sql脚本配置分库分表与读写分离application.p...
Java猿社区—ShardingSphere-4.0.1之实现读写分离
阿祥小王子的博客
03-15 3650
Java猿社区—ShardingSphere-4.0.1之实现读写分离 文章目录Java猿社区—ShardingSphere-4.0.1之实现读写分离技术体系背景ShardingSphere介绍注意事项ShardingShpere支持的功能数据分片分布式事务技术准备mysql安装配置POM配置读写分离——一主双从mysql配置环境sql脚本配置读写分离application.propertiesM...
SpringBoot 2.0 整合sharding-jdbc中间件实现数据分库分表
08-25
主要介绍了SpringBoot 2.0 整合sharding-jdbc中间件，实现数据分库分表，本文图文并茂给大家介绍的非常详细，具有一定的参考借鉴价值 ,需要的朋友可以参考下
sharding-jdbc之——分库分表实例完整源码
02-25
sharding-jdbc之——分库分表实例完整源码，详情请参见博文：http://blog.csdn.net/l1028386804/article/details/79368021
sharding-sphere-demo 分表分库
04-28
sharding-sphere-demo 分表分库
ShardingSphere新一代读写分离、分库分表神器
zfxgf123456789的博客
08-09 677
ShardingSphere是京东开源目前交给Apache的一个专门解决分库分表和读写分离等问题的框架，它是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角，关注它们之间的协作多于数据库自身。
基于springboot使用sharding-sphere实现智能化分库分表
Emmmmmm_m的博客
05-21 753
话不多说，直接先上代码 pom.xml文件引入依赖 <dependency> <groupId>org.apache.shardingsphere</groupId> <artifactId>sharding-jdbc-core</artifactId> <version>4.0.1</version> </dependency> springboot配置文件中加入如下配置 spring: #
Spring Boot与Sharding-JDBC分表实战：快速入门与配置解析
最新发布
qq_35716085的博客
12-04 1万+
本文旨在为Spring Boot开发者提供一种简单的分表解决方案，通过整合Sharding-JDBC来实现数据分表。文章详细介绍了在Spring Boot项目中引入Sharding-JDBC依赖、配置application.properties或application.yml，以及如何解析sharding配置。我们将重点关注分表策略的实施，确保在不分库的情况下提升数据库性能。通过跟随本文的步骤，读者可以快速掌握在Spring Boot环境中使用Sharding-JDBC进行分表操作的方法。
MySQL从入门到精通【实践篇】之使用Sharding-JDBC 分库分表详解
日拱一卒无有尽，功不唐捐终入海
09-06 692
Sharding-JDBC 是一款开源的分布式数据库中间件，主要目标是充分利用数据库的水平扩展能力，尽可能地避免改变已有的应用程序代码，简化分布式系统的开发难度。本文主要是使用sharding-jdbc 实现分库分表 以及各种分库分表策略实战验证。在学习本文之前建议 先看下我之前写的两篇文章《MySQL从入门到精通【进阶篇】MySQL分库分表详解》《MySQL从入门到精通【进阶篇】MySQL的读写分离详解》分库分表是一种常见的数据库扩展策略，它通过将数据分散到多个数据库或表中，来提高系统的性能和可扩展性。
sharding-sphere读写分离分库分表.zip
08-13
《基于Sharding-Sphere的数据库分库分表与读写分离技术详解》 在现代互联网应用中，随着数据量的快速增长，单个数据库往往难以承受高并发和大数据量的挑战，这时就需要采用分库分表和读写分离等技术来优化数据库...
Spring Boot 集成 Sharding-JDBC + Mybatis-Plus 实现分库分表功能
09-07
Sharding-JDBC支持水平和垂直切分，能够帮助开发者实现数据库分片、读写分离以及分布式事务等功能。它的核心特性包括： 1. 数据分片：根据预设规则将数据分散到多个数据库或表中，以减轻单个数据库的压力。 2. 读写...
使用ShardingJDBC实现按时间维度分表轻松支撑千万级数据
热门推荐
Ian的博客
08-28 1万+
文章目录前言一、框架搭建二、代码编写最麻烦的分页查询三、题外话源码下载 前言 之前在公司开发的一个产品，数据量巨大，疫情期间更是单月数据量增长超过100万，我们的单机MySQL数据库查询速度已经完全力不从心了，于是走上了分表的道路。我们的产品目标客户主要是学校，根据产品经理给的业务需求，决定按学期分表，即按主表数据入库时间按学期存放到对应分表，将原来超大的主表拆分成无数的小表，拆分后单表最大数据量为300万。 经过一段时间的考察研究决定使用ShardingJDBC来简化分表后的业务开发工作，Shardin
sharing-sphere单库分表（入门级示例）
JustryDeng
10-07 1875
sharding-sphere分库分表
ShardingSphere-Sharding-JDBC-4.0.×版+Spring+Mybatis+XML Namespace配置分库分表（十三）
astra_zhao的专栏
11-21 3302
1.Spring MVC,Spring,Mybatis+XML Namespache配置 关于这个部分如何配置，大家可以参考下Jeesite 2.×框架，或者网上找寻相关脚手架项目，这里不做过多介绍。 ２.配置applicationContext.xml和mybatis和sharding-jdbc的xml文件 applicationContext.xml加入如下配置文件： &lt...
centos7安装MySQL5.7踩到的几个坑
MJ的博客
08-17 2586
无论是tar包安装还是yum安装，（我选择的是yum）最后多半要踩到这么两个坑， 大概记录一下流程》》》》》》》》》》》 清理战场 找出之前的MySQL垃圾： rpm -qa|grep -i mysql ； yum list installed | grep mysql 逐个删除之：yum remove mysql57-community-release.noarch...
mysql binlog删除后不能重启解决方案
MJ的博客
02-04 1478
1.现象 systemctl start mysqld启动报错，提示查看系统日志journalctl -ex ;/var/log/message但无详细信息，从my.cnf指向的error log可以看到启动读取某个bin log日志文件被删了 2、解决方案 方案一：注释my.cnf的log-bin配置；方案二：如果需要开启bin-log，那就删除bin-log日志目录里的mysql-...
mysql的函数、存储过程、视图、触发器、事件等
MJ的博客
05-04 886
1.字符串函数、日期函数等    当前日期+1天的日期：SELECT DATE_ADD(NOW(),INTERVAL 1 DAY)查询两个日期间隔天数：SELECT DATEDIFF(NOW(),create_time) FROM t_quick_answer获取创建时间的小时：SELECT HOUR(TIME(create_time)) FROM t_quick_answer查询员工平均服务年限...
SQL多表关联原理研究-实验验证
MJ的博客
04-18 709
数据准备-建表语句及数据 CREATE TABLE testdb.table_a ( Aid int(11) PRIMARY KEY NOT NULL, A_field1 varchar(12), A_field2 varchar(12), A_field3 varchar(12), Bid int(11), Did int(11) ); ...
ShardingSphere：分库分表与分布式事务全面指南
Apache ShardingSphere 是一个开源的分布式数据库中间件，提供了数据分片、分布式事务以及数据库治理等功能，以帮助开发人员在大规模数据处理场景中提高系统的扩展性和性能。本文档主要关注的是 ShardingSphere 的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值