读写分离很难吗？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

參考：