读写分离很难吗?springboot结合aop简单就实现了
目录
前言
入职新公司到现在也有一个月了,完成了手头的工作,前几天终于有时间研究下公司旧项目的代码。在研究代码的过程中,发现项目里用到了spring aop来实现数据库的读写分离,本着自己爱学习(我自己都不信...)的性格,决定写个实例工程来实现spring aop读写分离的效果。
环境部署
数据库:mysql
库数量:2个,一主一从
关于mysql的主从环境部署之前已经写过文章介绍过了,这里就不再赘述,参考
开始项目
首先,毫无疑问,先开始搭建一个springboot工程,然后在pom文件中引入如下依赖:
<dependencies> <dependency> <groupid>com.alibaba</groupid> <artifactid>druid-spring-boot-starter</artifactid> <version>1.1.10</version> </dependency> <dependency> <groupid>org.mybatis.spring.boot</groupid> <artifactid>mybatis-spring-boot-starter</artifactid> <version>1.3.2</version> </dependency> <dependency> <groupid>tk.mybatis</groupid> <artifactid>mapper-spring-boot-starter</artifactid> <version>2.1.5</version> </dependency> <dependency> <groupid>mysql</groupid> <artifactid>mysql-connector-java</artifactid> <version>8.0.16</version> </dependency> <!-- 动态数据源 所需依赖 ### start--> <dependency> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-jdbc</artifactid> <scope>provided</scope> </dependency> <dependency> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-aop</artifactid> <scope>provided</scope> </dependency> <!-- 动态数据源 所需依赖 ### end--> <dependency> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-web</artifactid> </dependency> <dependency> <groupid>org.projectlombok</groupid> <artifactid>lombok</artifactid> <optional>true</optional> </dependency> <dependency> <groupid>com.alibaba</groupid> <artifactid>fastjson</artifactid> <version>1.2.4</version> </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-data-jpa</artifactid> </dependency> </dependencies>
目录结构
引入基本的依赖后,整理一下目录结构,完成后的项目骨架大致如下:
建表
创建一张表user,在主库执行sql语句同时在从库生成对应的表数据
drop table if exists `user`; create table `user` ( `user_id` bigint(20) not null comment '用户id', `user_name` varchar(255) default '' comment '用户名称', `user_phone` varchar(50) default '' comment '用户手机', `address` varchar(255) default '' comment '住址', `weight` int(3) not null default '1' comment '权重,大者优先', `created_at` datetime not null default current_timestamp comment '创建时间', `updated_at` datetime default current_timestamp on update current_timestamp comment '更新时间', primary key (`user_id`) ) engine=innodb default charset=utf8; insert into `user` values ('1196978513958141952', '测试1', '18826334748', '广州市海珠区', '1', '2019-11-20 10:28:51', '2019-11-22 14:28:26'); insert into `user` values ('1196978513958141953', '测试2', '18826274230', '广州市天河区', '2', '2019-11-20 10:29:37', '2019-11-22 14:28:14'); insert into `user` values ('1196978513958141954', '测试3', '18826273900', '广州市天河区', '1', '2019-11-20 10:30:19', '2019-11-22 14:28:30');
主从数据源配置
application.yml,主要信息是主从库的数据源配置
server: port: 8001 spring: jackson: date-format: yyyy-mm-dd hh:mm:ss time-zone: gmt+8 datasource: type: com.alibaba.druid.pool.druiddatasource driver-class-name: com.mysql.cj.jdbc.driver master: url: jdbc:mysql://127.0.0.1:3307/user?servertimezone=asia/shanghai&useunicode=true&characterencoding=utf-8&autoreconnect=true&failoverreadonly=false&usessl=false&zerodatetimebehavior=converttonull&allowmultiqueries=true username: root password: slave: url: jdbc:mysql://127.0.0.1:3308/user?servertimezone=asia/shanghai&useunicode=true&characterencoding=utf-8&autoreconnect=true&failoverreadonly=false&usessl=false&zerodatetimebehavior=converttonull&allowmultiqueries=true username: root password:
因为有一主一从两个数据源,我们用枚举类来代替,方便我们使用时能对应
@getter public enum dynamicdatasourceenum { master("master"), slave("slave"); private string datasourcename; dynamicdatasourceenum(string datasourcename) { this.datasourcename = datasourcename; } }
数据源配置信息类 datasourceconfig,这里配置了两个数据源,masterdb和slavedb
@configuration @mapperscan(basepackages = "com.xjt.proxy.mapper", sqlsessiontemplateref = "sqltemplate") public class datasourceconfig { // 主库 @bean @configurationproperties(prefix = "spring.datasource.master") public datasource masterdb() { return druiddatasourcebuilder.create().build(); } /** * 从库 */ @bean @conditionalonproperty(prefix = "spring.datasource", name = "slave", matchifmissing = true) @configurationproperties(prefix = "spring.datasource.slave") public datasource slavedb() { return druiddatasourcebuilder.create().build(); } /** * 主从动态配置 */ @bean public dynamicdatasource dynamicdb(@qualifier("masterdb") datasource masterdatasource, @autowired(required = false) @qualifier("slavedb") datasource slavedatasource) { dynamicdatasource dynamicdatasource = new dynamicdatasource(); map<object, object> targetdatasources = new hashmap<>(); targetdatasources.put(dynamicdatasourceenum.master.getdatasourcename(), masterdatasource); if (slavedatasource != null) { targetdatasources.put(dynamicdatasourceenum.slave.getdatasourcename(), slavedatasource); } dynamicdatasource.settargetdatasources(targetdatasources); dynamicdatasource.setdefaulttargetdatasource(masterdatasource); return dynamicdatasource; } @bean public sqlsessionfactory sessionfactory(@qualifier("dynamicdb") datasource dynamicdatasource) throws exception { sqlsessionfactorybean bean = new sqlsessionfactorybean(); bean.setmapperlocations( new pathmatchingresourcepatternresolver().getresources("classpath*:mapper/*mapper.xml")); bean.setdatasource(dynamicdatasource); return bean.getobject(); } @bean public sqlsessiontemplate sqltemplate(@qualifier("sessionfactory") sqlsessionfactory sqlsessionfactory) { return new sqlsessiontemplate(sqlsessionfactory); } @bean(name = "datasourcetx") public datasourcetransactionmanager datasourcetx(@qualifier("dynamicdb") datasource dynamicdatasource) { datasourcetransactionmanager datasourcetransactionmanager = new datasourcetransactionmanager(); datasourcetransactionmanager.setdatasource(dynamicdatasource); return datasourcetransactionmanager; } }
设置路由
设置路由的目的为了方便查找对应的数据源,我们可以用threadlocal保存数据源的信息到每个线程中,方便我们需要时获取
public class datasourcecontextholder { private static final threadlocal<string> dynamic_datasource_context = new threadlocal<>(); public static void set(string datasourcetype) { dynamic_datasource_context.set(datasourcetype); } public static string get() { return dynamic_datasource_context.get(); } public static void clear() { dynamic_datasource_context.remove(); } }
获取路由
public class dynamicdatasource extends abstractroutingdatasource { @override protected object determinecurrentlookupkey() { return datasourcecontextholder.get(); } }
abstractroutingdatasource的作用是基于查找key路由到对应的数据源,它内部维护了一组目标数据源,并且做了路由key与目标数据源之间的映射,提供基于key查找数据源的方法。
数据源的注解
为了可以方便切换数据源,我们可以写一个注解,注解中包含数据源对应的枚举值,默认是主库,
@retention(retentionpolicy.runtime) @target(elementtype.method) @documented public @interface datasourceselector { dynamicdatasourceenum value() default dynamicdatasourceenum.master; boolean clear() default true; }
aop切换数据源
到这里,aop终于可以现身出场了,这里我们定义一个aop类,对有注解的方法做切换数据源的操作,具体代码如下:
@slf4j @aspect @order(value = 1) @component public class datasourcecontextaop { @around("@annotation(com.xjt.proxy.dynamicdatasource.datasourceselector)") public object setdynamicdatasource(proceedingjoinpoint pjp) throws throwable { boolean clear = true; try { method method = this.getmethod(pjp); datasourceselector datasourceimport = method.getannotation(datasourceselector.class); clear = datasourceimport.clear(); datasourcecontextholder.set(datasourceimport.value().getdatasourcename()); log.info("========数据源切换至:{}", datasourceimport.value().getdatasourcename()); return pjp.proceed(); } finally { if (clear) { datasourcecontextholder.clear(); } } } private method getmethod(joinpoint pjp) { methodsignature signature = (methodsignature)pjp.getsignature(); return signature.getmethod(); } }
到这一步,我们的准备配置工作就完成了,下面开始测试效果。
先写好service文件,包含读取和更新两个方法,
@service public class userservice { @autowired private usermapper usermapper; @datasourceselector(value = dynamicdatasourceenum.slave) public list<user> listuser() { list<user> users = usermapper.selectall(); return users; } @datasourceselector(value = dynamicdatasourceenum.master) public int update() { user user = new user(); user.setuserid(long.parselong("1196978513958141952")); user.setusername("修改后的名字2"); return usermapper.updatebyprimarykeyselective(user); } @datasourceselector(value = dynamicdatasourceenum.slave) public user find() { user user = new user(); user.setuserid(long.parselong("1196978513958141952")); return usermapper.selectbyprimarykey(user); } }
根据方法上的注解可以看出,读的方法走从库,更新的方法走主库,更新的对象是userid为1196978513958141953
的数据,
然后我们写个测试类测试下是否能达到效果,
@runwith(springrunner.class) @springboottest class userservicetest { @autowired userservice userservice; @test void listuser() { list<user> users = userservice.listuser(); for (user user : users) { system.out.println(user.getuserid()); system.out.println(user.getusername()); system.out.println(user.getuserphone()); } } @test void update() { userservice.update(); user user = userservice.find(); system.out.println(user.getusername()); } }
测试结果:
1、读取方法
2、更新方法
执行之后,比对数据库就可以发现主从库都修改了数据,说明我们的读写分离是成功的。当然,更新方法可以指向从库,这样一来就只会修改到从库的数据,而不会涉及到主库。
注意
上面测试的例子虽然比较简单,但也符合常规的读写分离配置。值得说明的是,读写分离的作用是为了缓解写库,也就是主库的压力,但一定要基于数据一致性的原则,就是保证主从库之间的数据一定要一致。如果一个方法涉及到写的逻辑,那么该方法里所有的数据库操作都要走主库。
假设写的操作执行完后数据有可能还没同步到从库,然后读的操作也开始执行了,如果这个读取的程序走的依然是从库的话,那么就会出现数据不一致的现象了,这是我们不允许的。
最后发一下项目的github地址,有兴趣的同学可以看下,记得给个star哦
地址:https://github.com/taoxj/mysql-proxy
參考:
上一篇: 墨鱼和鱿鱼的区别,让你从此分辨清楚
下一篇: 没有脂肪的肉类真的存在吗,来看看