shardingsphere 实战 - 读写分离

最新推荐文章于 2024-02-22 14:36:33 发布
最新推荐文章于 2024-02-22 14:36:33 发布
阅读量260 收藏
点赞数 1
分类专栏： JAVA技术 文章标签： 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/imwgp/article/details/131457426
版权

前言

一般互联网应用，都是读多写少。并采用mysql主从架构，读写分离。

shardingsphere也支持读写分离，实现原理很简单：

  • 配置多个数据源，标注数据源是主还是从
  • 读默认读主库，也可以强制读主库
  • 读走从库，通过负载均衡选择其中一个从库

表结构设计

我在本地机器上，用3个库，模拟主从关系

在每个库中都建一个torder表

create database db1;

create database db2;

create database db3;

-- 在3个DB中建同样的表
CREATE TABLE torder (
	order_id BIGINT(20) PRIMARY KEY,
	status varchar(20) NOT NULL,
	gmt_create datetime NOT NULL,
	sku_code VARCHAR(50) NOT NULL,
	sku_name VARCHAR(50) NOT NULL,
	price DECIMAL(10, 2) NOT NULL,
	buyer_id BIGINT(20) NOT NULL
);

 测试数据


-- 在3个DB中插入同样数据
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (1,'INIT','2023-06-28 08:30:37','sku_1','商品_1',1000.10,1);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (2,'INIT','2023-06-28 08:30:37','sku_2','商品_2',1000.10,2);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (3,'INIT','2023-06-28 08:30:37','sku_3','商品_3',1000.10,3);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (4,'INIT','2023-06-28 08:30:37','sku_4','商品_4',1000.10,4);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (5,'INIT','2023-06-28 08:30:37','sku_5','商品_5',1000.10,5);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (6,'INIT','2023-06-28 08:30:37','sku_6','商品_6',1000.10,6);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (7,'INIT','2023-06-28 08:30:37','sku_7','商品_7',1000.10,7);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (8,'INIT','2023-06-28 08:30:37','sku_8','商品_8',1000.10,8);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (9,'INIT','2023-06-28 08:30:37','sku_9','商品_9',1000.10,9);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (10,'INIT','2023-06-28 08:30:37','sku_10','商品_10',1000.10,10);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (11,'INIT','2023-06-28 08:30:37','sku_11','商品_11',1000.10,11);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (12,'INIT','2023-06-28 08:30:37','sku_12','商品_12',1000.10,12);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (13,'INIT','2023-06-28 08:30:37','sku_13','商品_13',1000.10,13);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (14,'INIT','2023-06-28 08:30:37','sku_14','商品_14',1000.10,14);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (15,'INIT','2023-06-28 08:30:37','sku_15','商品_15',1000.10,15);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (16,'INIT','2023-06-28 08:30:37','sku_16','商品_16',1000.10,16);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (17,'INIT','2023-06-28 08:30:37','sku_17','商品_17',1000.10,17);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (18,'INIT','2023-06-28 08:30:37','sku_18','商品_18',1000.10,18);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (19,'INIT','2023-06-28 08:30:37','sku_19','商品_19',1000.10,19);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (20,'INIT','2023-06-28 08:30:37','sku_20','商品_20',1000.10,20);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (21,'INIT','2023-06-28 08:30:37','sku_21','商品_21',1000.10,21);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (22,'INIT','2023-06-28 08:30:37','sku_22','商品_22',1000.10,22);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (23,'INIT','2023-06-28 08:30:37','sku_23','商品_23',1000.10,23);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (24,'INIT','2023-06-28 08:30:37','sku_24','商品_24',1000.10,24);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (25,'INIT','2023-06-28 08:30:37','sku_25','商品_25',1000.10,25);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (26,'INIT','2023-06-28 08:30:37','sku_26','商品_26',1000.10,26);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (27,'INIT','2023-06-28 08:30:37','sku_27','商品_27',1000.10,27);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (28,'INIT','2023-06-28 08:30:37','sku_28','商品_28',1000.10,28);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (29,'INIT','2023-06-28 08:30:37','sku_29','商品_29',1000.10,29);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (30,'INIT','2023-06-28 08:30:37','sku_30','商品_30',1000.10,30);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (31,'INIT','2023-06-28 08:30:37','sku_31','商品_31',1000.10,31);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (32,'INIT','2023-06-28 08:30:37','sku_32','商品_32',1000.10,32);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (33,'INIT','2023-06-28 08:30:37','sku_33','商品_33',1000.10,33);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (34,'INIT','2023-06-28 08:30:37','sku_34','商品_34',1000.10,34);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (35,'INIT','2023-06-28 08:30:37','sku_35','商品_35',1000.10,35);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (36,'INIT','2023-06-28 08:30:37','sku_36','商品_36',1000.10,36);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (37,'INIT','2023-06-28 08:30:37','sku_37','商品_37',1000.10,37);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (38,'INIT','2023-06-28 08:30:37','sku_38','商品_38',1000.10,38);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (39,'INIT','2023-06-28 08:30:37','sku_39','商品_39',1000.10,39);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (40,'INIT','2023-06-28 08:30:37','sku_40','商品_40',1000.10,40);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (41,'INIT','2023-06-28 08:30:37','sku_41','商品_41',1000.10,41);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (42,'INIT','2023-06-28 08:30:37','sku_42','商品_42',1000.10,42);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (43,'INIT','2023-06-28 08:30:37','sku_43','商品_43',1000.10,43);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (44,'INIT','2023-06-28 08:30:37','sku_44','商品_44',1000.10,44);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (45,'INIT','2023-06-28 08:30:37','sku_45','商品_45',1000.10,45);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (46,'INIT','2023-06-28 08:30:37','sku_46','商品_46',1000.10,46);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (47,'INIT','2023-06-28 08:30:37','sku_47','商品_47',1000.10,47);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (48,'INIT','2023-06-28 08:30:37','sku_48','商品_48',1000.10,48);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (49,'INIT','2023-06-28 08:30:37','sku_49','商品_49',1000.10,49);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (50,'INIT','2023-06-28 08:30:37','sku_50','商品_50',1000.10,50);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (51,'INIT','2023-06-28 08:30:37','sku_51','商品_51',1000.10,51);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (52,'INIT','2023-06-28 08:30:37','sku_52','商品_52',1000.10,52);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (53,'INIT','2023-06-28 08:30:37','sku_53','商品_53',1000.10,53);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (54,'INIT','2023-06-28 08:30:37','sku_54','商品_54',1000.10,54);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (55,'INIT','2023-06-28 08:30:37','sku_55','商品_55',1000.10,55);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (56,'INIT','2023-06-28 08:30:37','sku_56','商品_56',1000.10,56);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (57,'INIT','2023-06-28 08:30:37','sku_57','商品_57',1000.10,57);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (58,'INIT','2023-06-28 08:30:37','sku_58','商品_58',1000.10,58);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (59,'INIT','2023-06-28 08:30:37','sku_59','商品_59',1000.10,59);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (60,'INIT','2023-06-28 08:30:37','sku_60','商品_60',1000.10,60);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (61,'INIT','2023-06-28 08:30:37','sku_61','商品_61',1000.10,61);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (62,'INIT','2023-06-28 08:30:37','sku_62','商品_62',1000.10,62);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (63,'INIT','2023-06-28 08:30:37','sku_63','商品_63',1000.10,63);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (64,'INIT','2023-06-28 08:30:37','sku_64','商品_64',1000.10,64);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (65,'INIT','2023-06-28 08:30:37','sku_65','商品_65',1000.10,65);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (66,'INIT','2023-06-28 08:30:37','sku_66','商品_66',1000.10,66);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (67,'INIT','2023-06-28 08:30:37','sku_67','商品_67',1000.10,67);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (68,'INIT','2023-06-28 08:30:37','sku_68','商品_68',1000.10,68);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (69,'INIT','2023-06-28 08:30:37','sku_69','商品_69',1000.10,69);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (70,'INIT','2023-06-28 08:30:37','sku_70','商品_70',1000.10,70);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (71,'INIT','2023-06-28 08:30:37','sku_71','商品_71',1000.10,71);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (72,'INIT','2023-06-28 08:30:37','sku_72','商品_72',1000.10,72);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (73,'INIT','2023-06-28 08:30:37','sku_73','商品_73',1000.10,73);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (74,'INIT','2023-06-28 08:30:37','sku_74','商品_74',1000.10,74);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (75,'INIT','2023-06-28 08:30:37','sku_75','商品_75',1000.10,75);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (76,'INIT','2023-06-28 08:30:37','sku_76','商品_76',1000.10,76);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (77,'INIT','2023-06-28 08:30:37','sku_77','商品_77',1000.10,77);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (78,'INIT','2023-06-28 08:30:37','sku_78','商品_78',1000.10,78);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (79,'INIT','2023-06-28 08:30:37','sku_79','商品_79',1000.10,79);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (80,'INIT','2023-06-28 08:30:37','sku_80','商品_80',1000.10,80);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (81,'INIT','2023-06-28 08:30:37','sku_81','商品_81',1000.10,81);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (82,'INIT','2023-06-28 08:30:37','sku_82','商品_82',1000.10,82);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (83,'INIT','2023-06-28 08:30:37','sku_83','商品_83',1000.10,83);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (84,'INIT','2023-06-28 08:30:37','sku_84','商品_84',1000.10,84);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (85,'INIT','2023-06-28 08:30:37','sku_85','商品_85',1000.10,85);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (86,'INIT','2023-06-28 08:30:37','sku_86','商品_86',1000.10,86);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (87,'INIT','2023-06-28 08:30:37','sku_87','商品_87',1000.10,87);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (88,'INIT','2023-06-28 08:30:37','sku_88','商品_88',1000.10,88);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (89,'INIT','2023-06-28 08:30:37','sku_89','商品_89',1000.10,89);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (90,'INIT','2023-06-28 08:30:37','sku_90','商品_90',1000.10,90);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (91,'INIT','2023-06-28 08:30:37','sku_91','商品_91',1000.10,91);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (92,'INIT','2023-06-28 08:30:37','sku_92','商品_92',1000.10,92);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (93,'INIT','2023-06-28 08:30:37','sku_93','商品_93',1000.10,93);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (94,'INIT','2023-06-28 08:30:37','sku_94','商品_94',1000.10,94);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (95,'INIT','2023-06-28 08:30:37','sku_95','商品_95',1000.10,95);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (96,'INIT','2023-06-28 08:30:37','sku_96','商品_96',1000.10,96);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (97,'INIT','2023-06-28 08:30:37','sku_97','商品_97',1000.10,97);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (98,'INIT','2023-06-28 08:30:37','sku_98','商品_98',1000.10,98);
INSERT INTO `torder` (`order_id`,`status`,`gmt_create`,`sku_code`,`sku_name`,`price`,`buyer_id`) VALUES (99,'INIT','2023-06-28 08:30:37','sku_99','商品_99',1000.10,99);

二方包

<dependencies>
        <!-- shardingJDBC核心依赖 -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-jdbc-spring-boot-starter</artifactId>
            <version>4.1.1</version>
        </dependency>
        <!--XA 分布式事务 -->
        <dependency>
            <groupId>org.apache.shardingsphere</groupId>
            <artifactId>sharding-transaction-xa-core</artifactId>
            <version>4.1.1</version>
        </dependency>

        <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>
        <!-- 数据源连接池 -->
        <!--注意不要用这个依赖，他会创建数据源，跟上面ShardingJDBC的SpringBoot集成依赖有冲突 -->
        <!--        <dependency>-->
        <!--            <groupId>com.alibaba</groupId>-->
        <!--            <artifactId>druid-spring-boot-starter</artifactId>-->
        <!--            <version>1.1.20</version>-->
        <!--        </dependency>-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.20</version>
        </dependency>
        <!-- mysql连接驱动 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- mybatisplus依赖 -->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
        </dependency>
    </dependencies>

实体

package com.wgp.oms.dal.entity;

import java.math.BigDecimal;
import java.util.Date;

import com.baomidou.mybatisplus.annotation.TableId;
import lombok.Data;

/**
 * @author gangpeng.wgp
 * @date 2023/6/27 下午9:58
 */
@Data
//特别注意，不能踩坑：表名不能叫order，是mysql关键字。否则shardingsphere会启动失败
public class Torder {
    @TableId
    private Long orderId;
    private String status;
    private Date gmtCreate;
    private String skuCode;
    private String skuName;
    private BigDecimal price;
    private Long buyerId;

}

 配置

spring:
  # ShardingSphere 配置项
  shardingsphere:
    # 数据源配置
    datasource:
      # 所有数据源的名字
      names: ds-master, ds-slave-1, ds-slave-2
      # 订单 db1 主库的数据源配置
      ds-master:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db1?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 12345678
      # 订单 db2 从库数据源配置
      ds-slave-1:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db2?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 12345678
      # 订单 db3 从库数据源配置
      ds-slave-2:
        type: com.zaxxer.hikari.HikariDataSource # 使用 Hikari 数据库连接池
        driver-class-name: com.mysql.jdbc.Driver
        jdbc-url: jdbc:mysql://127.0.0.1:3306/db3?useSSL=false&useUnicode=true&characterEncoding=UTF-8
        username: root
        password: 12345678
    #打印sql，方便查看sql在哪个库中执行
    props:
      sql:
        show : true

    masterslave:
      name: ms # 名字，任意，需要保证唯一
      master-data-source-name: ds-master # 主库数据源
      slave-data-source-names: ds-slave-1, ds-slave-2 # 从库数据源

单测

package com.wgp.oms.rw.separation;

import java.math.BigDecimal;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

import javax.annotation.Resource;

import com.wgp.oms.rw.separation.entity.Torder;
import com.wgp.oms.rw.separation.mapper.OrderMapper;
import org.apache.shardingsphere.api.hint.HintManager;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

import static org.junit.jupiter.api.Assertions.assertNotNull;

/**
 * @author gangpeng.wgp
 * @date 2023/6/27 下午10:40
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class OrderServiceTest {
    @Resource
    private OrderService orderService;

    @Resource
    private OrderMapper orderMapper;

    /**
     * 测试读从库，负载均衡
     */
    @Test
    public void queryOrderById() {

        for (int i = 0; i < 100; i++) {
            Torder order = orderService.queryOrderById(1L);
            assertNotNull(order);
            System.out.println(order);
        }
    }

    /**
     * 强制读主库
     */
    @Test
    public void queryOrderFromMaster() {

        //HintManager 实现了 AutoCloseable 接口，可以通过 Try-with-resources 机制，自动关闭
        try (HintManager hintManager = HintManager.getInstance()) {
            //强制读主库
            hintManager.setMasterRouteOnly();
            Torder order = orderService.queryOrderById(1L);
            assertNotNull(order);
            System.out.println(order);
        }

    }

    /**
     * 测试插入主库
     */
    @Test
    public void addOrder() {
        delete();

        for (int i = 1000; i < 1100; i++) {
            Torder c = new Torder();
            c.setOrderId((long)i);
            c.setBuyerId((long)i);
            c.setGmtCreate(new Date());
            c.setStatus("INIT");
            c.setPrice(BigDecimal.valueOf(1000.10));
            c.setSkuCode("sku_" + i);
            c.setSkuName("商品_" + i);
            c.setOrderId((long)i);
            orderMapper.insert(c);
        }
    }

    private void delete() {
        Map<String, Object> param = new HashMap<>();
        orderMapper.deleteByMap(param);
    }

}

代码地址

gangpwei/wgp-shardingsphere · GitHub

imwgp
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Docker搭建MySQLl基于ShardingSphere-Proxy读写分离(docker-compose)
12-22
docker_compose搭建shardingSphereProxyMysql主从读写分离
6、ShardingSphere 之 读写分离
kingchengwen的专栏
07-02 2237
文章目录1 读写分离原理2 Mysql 配置主从复制2.1 创建2个Mysql 数据库服务，并启动两个Mysql服务2.2 配置Master库的/etc/my.cnf2.3 配置Slave库的/etc/my.cnf2.4 Master上创建用于主从复置的账号2.5 Slave上设置从库向主库同步3 ShardingSphere实现读写分离3.1 配置properties3.2 编写po3.3 编写mapper3.4 编写Test3.5 TestRest 1 读写分离原理 为了确保数据库产品的稳定性，很多数据
【ShardingSphere-JDBC实现读写分离】
同心
02-22 515
是一个开源的分布式数据库中间件，提供了数据库的分库分表、读写分离、数据分片等功能。分库分表：可以将数据按照一定规则分散到不同的数据库或表中，实现数据的水平切分，提高数据库的扩展性和性能。读写分离：可以根据需求将读操作和写操作分发到不同的数据库节点，实现读写分离，提高数据库的负载能力。数据分片：可以按照某种特定的规则将数据分散到不同的数据库节点上，并通过统一的接口对外提供访问，实现数据的分布式存储。
ShardingSphere实现数据库读写分离，主从库分离，docker详细教程
wy971744839的博客
05-04 734
引用官方的话：Apache ShardingSphere 是一款分布式的数据库生态系统， 可以将任意数据库转换为分布式数据库，并通过数据分片、弹性伸缩、加密等能力对原有数据库进行增强。Apache ShardingSphere 设计哲学为 Database Plus，旨在构建异构数据库上层的标准和生态。它关注如何充分合理地利用数据库的计算和存储能力，而并非实现一个全新的数据库。它站在数据库的上层视角，关注它们之间的协作多于数据库自身。
ShardingSphere分库分表与读写分离实战
a141210104的专栏
12-10 380
inline: 直接在配置文件中通过 Groovy 表达式实现分片策略，如：user_$->{u_id%8}, 只支持精确查找 ( = in)，不支持范围查找standard: 标准分片策略，用户通过编写分片精确查找和范围查找算法，实现自定义的分片，可以支持精确查找和范围查找，但是分片键只能有一个，也就是只能根据一列来进行分片complex： 复合分片，和标准分片一样，但是可以支持多个列对数据进行分片hint: 强制路由策略，不再由 SQL 决定如何分片，直接由用户指定分片参数。
ShardingSphere实践（4）——读写分离
wzy0623的专栏
06-02 5021
ShardingSphere最重要的功能模块是数据分片，从规则到实现都比较复杂。其他功能相对来说比较简单，本篇介绍ShardingSphere的读写分离功能。 面对日益增加的系统访问量，数据库的吞吐量面临着巨大瓶颈。对于同一时刻有大量并发读操作和较少写操作类型的应用系统来说，将数据库拆分为主库和从库，主库负责处理事务性的增删改操作，从库负责处理查询操作，能够有效避免由数据更新导致的行锁，使得整个系统的查询性能得到极大的改善。 通过一主多从的配置方式，可以将查询请求均匀的分散到多个
ShardingSphere数据分片之读写分离
qq_45515182的博客
12-14 1546
读写分离是一种常见的数据库架构，它将数据库分为主从库，一个主库（Master）用于写数据，多个从库（Slave）进行轮询读取数据的过程。主从库之间通过某种通讯机制进行数据的同步。
聊一聊ShardingSphere的读写分离
m0_37561303的博客
10-06 1371
ShardingSphere的读写分离
基于ShardingSphere实现数据库读写分离
weixin_43994761的博客
04-19 996
第三步：在方法上贴注解即可。
mysql-读写分离.docx
08-10
mysql数据库主从复制读写分离步骤，有需要的朋友可以下载一下，资料哪里不好的地方也可以在下面评论，我尽力去改正
ShardingSphere:SpringBoot2+MybatisPlus读写分离+分表
06-17
快速的掌握读写分离+分表的实战，即插即用适用人群IT从业人员，开发人员，Java从业者，互联网从业者，性能调优人群课程简介 ShardingSphere是一套开源的分布式数据库中间件解决方案组成的生态圈。 它由Sharding-JDBC...
mysql-proxy读写分离.docx
10-08
公司运维手册，mysql-proxy读写分离，废话不多说，上干货！
spring-boot-mybatis-druid-读写分离-swagger
11-08
这几天因为工作需要，学习研究了一下spring-boot。spring-boot+mybatis+druid+读写分离+swagger进行一个整合，做了一个demo。自己已经充分测试，过程中也踩了不少的坑。
ShardingSphere读写分离
Charge8的博客
04-17 3445
读写分离是为了确保数据库产品的稳定性，很多数据库拥有双机热备功能。 原理：让主数据库（master）处理事务性增、改、删操作，而从数据库（slave）处理select查询操作。 注意： Sharding-JDBC 通过 sql 语句语义分析，实现读写分离过程，不会做数据同步。 数据同步需要数据库搭建主从集群架构，来做数据之间的主从同步。 关于数据库的主从集群架构自行搭建，下面从 Sharding-JDBC 的应用层来做数据的读写分离。 一、读写分离 1、application.properties 配置
ShardingSphere5.x.x(最新版)配置MySQL读写分离
凌咚的博客
05-18 4542
使用配置项目的读写分离。
shardingsphere-jdbc读写分离
freshbar的博客
08-12 872
一、读写分离 https://zhuanlan.zhihu.com/p/86108084 https://shardingsphere.apache.org/document/current/cn/features/readwrite-splitting/use-norms/ 支持项 1、提供一主多从的读写分离配置，可独立使用，也可配合分库分表使用； 2、独立使用读写分离支持SQL透传； 3、同一线程且同一数据库连接内，如有写入操作，以后的读操作均从主库读取，用于保证数据一致性； 4、基于Hint的强制
shardingsphere 实现读写分离
u012565281的博客
11-11 458
1、添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId&gt
使用shardingjdbc实现读写分离配置
woshihedayu的博客
08-03 471
基于MySQL主从复制实现，其中m0是mysql的主库数据源，s0是mysql的从库数据源，具体配置一定要根据shardingjdbc的版本来写，不同的版本差异很大，查看官方文档一旦选错了版本，运行出现问题，很难发现错在哪里，浪费了很多时间！...
shardingsphere-jdbc 读写分离
最新发布
03-15
ShardingSphere-JDBC是一个开源的分布式数据库中间件，它提供了一系列的数据库分片和读写分离的功能。其中，读写分离是ShardingSphere-JDBC的一个重要特性之一。 读写分离是指将数据库的读操作和写操作分别路由到不同的数据库节点上，以提高系统的性能和可扩展性。通过将读操作分发到多个只读节点上，可以有效地减轻主库的负载，提高系统的并发处理能力。 在ShardingSphere-JDBC中，读写分离的配置主要包括以下几个方面： 1. 数据源配置：需要配置主库和多个只读库的数据源信息，包括数据库连接信息、用户名、密码等。 2. 路由规则配置：需要配置读写分离的路由规则，指定哪些SQL语句需要路由到只读库执行，哪些需要路由到主库执行。 3. 数据源选择策略配置：需要配置数据源选择策略，用于决定在读操作时选择哪个只读库进行查询。 通过以上配置，ShardingSphere-JDBC可以根据SQL语句的类型和路由规则，自动将读操作路由到只读库执行，而将写操作路由到主库执行。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值