欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2022-06-05 19:04:26
[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>

目录结构

引入基本的依赖后,整理一下目录结构,完成后的项目骨架大致如下:
读写分离很难吗?springboot结合aop简单就实现了

建表

创建一张表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、读取方法
读写分离很难吗?springboot结合aop简单就实现了
2、更新方法
读写分离很难吗?springboot结合aop简单就实现了
执行之后,比对数据库就可以发现主从库都修改了数据,说明我们的读写分离是成功的。当然,更新方法可以指向从库,这样一来就只会修改到从库的数据,而不会涉及到主库。

注意

上面测试的例子虽然比较简单,但也符合常规的读写分离配置。值得说明的是,读写分离的作用是为了缓解写库,也就是主库的压力,但一定要基于数据一致性的原则,就是保证主从库之间的数据一定要一致。如果一个方法涉及到写的逻辑,那么该方法里所有的数据库操作都要走主库

假设写的操作执行完后数据有可能还没同步到从库,然后读的操作也开始执行了,如果这个读取的程序走的依然是从库的话,那么就会出现数据不一致的现象了,这是我们不允许的。

最后发一下项目的github地址,有兴趣的同学可以看下,记得给个star哦

地址:https://github.com/taoxj/mysql-proxy

參考: