当前位置: 萬仟网 > IT编程>开发语言>Java > 读写分离很难吗?springboot结合aop简单就实现了

读写分离很难吗?springboot结合aop简单就实现了

2019年11月27日 Java 我要评论
[toc] 前言 入职新公司到现在也有一个月了,完成了手头的工作,前几天终于有时间研究下公司旧项目的代码。在研究代码的过程中,发现项目里用到了Spring Aop来实现数据库的读写分离,本着自己爱学习(我自己都不信...)的性格,决定写个实例工程来实现spring 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

參考:

(0)
打赏 微信扫一扫 微信扫一扫

相关文章:

版权声明:本文内容由互联网用户贡献,该文观点仅代表作者本人。本站仅提供信息存储服务,不拥有所有权,不承担相关法律责任。

发表评论

验证码:
Copyright © 2017-2022  萬仟网 保留所有权利. 琼ICP备2022007597号