springboot实现读写分离(基于Mybatis，mysql)

时间  2019-11-16
标签 springboot 实现 读写 分离 基于 mybatis mysql 栏目 Spring 繁體版
原文   原文链接

近日工做任务较轻，有空学习学习技术，遂来研究若是实现读写分离。这里用博客记录下过程，一方面可备往后查看，同时也能分享给你们（网上的资料真的大都是抄来抄去，，还不带格式的，看的真心难受）。java

完整代码：github.com/FleyX/demo-…mysql

一、背景

  一个项目中数据库最基础同时也是最主流的是单机数据库，读写都在一个库中。当用户逐渐增多，单机数据库没法知足性能要求时，就会进行读写分离改造（适用于读多写少），写操做一个库，读操做多个库，一般会作一个数据库集群，开启主从备份，一主多从，以提升读取性能。当用户更多读写分离也没法知足时，就须要分布式数据库了（可能之后会学习怎么弄）。git

  正常状况下读写分离的实现，首先要作一个一主多从的数据库集群，同时还须要进行数据同步。这一篇记录如何用 mysql 搭建一个一主屡次的配置，下一篇记录代码层面如何实现读写分离。github

二、搭建一主多从数据库集群

  主从备份须要多台虚拟机，我是用 wmware 完整克隆多个实例，注意直接克隆的虚拟机会致使每一个数据库的 uuid 相同，须要修改成不一样的 uuid。修改方法参考这个：点击跳转。spring

  • 主库配置sql

    主数据库（master）中新建一个用户用于从数据库（slave）读取主数据库二进制日志，sql 语句以下：数据库

    mysql> CREATE USER 'repl'@'%' IDENTIFIED BY '123456';#建立用户
mysql> GRANT REPLICATION SLAVE ON *.* TO 'repl'@'%';#分配权限
mysql>flush privileges;   #刷新权限
复制代码

    同时修改 mysql 配置文件开启二进制日志，新增部分以下：springboot

    [mysqld]
server-id=1
log-bin=master-bin
log-bin-index=master-bin.index
复制代码

    而后重启数据库，使用show master status;语句查看主库状态，以下所示：mybatis

主库状态

  • 从库配置架构

    一样先新增几行配置：

    [mysqld]
server-id=2
relay-log-index=slave-relay-bin.index
relay-log=slave-relay-bin
复制代码

    而后重启数据库，使用以下语句链接主库：

    CHANGE MASTER TO
         MASTER_HOST='192.168.226.5',
         MASTER_USER='root',
         MASTER_PASSWORD='123456',
         MASTER_LOG_FILE='master-bin.000003',
         MASTER_LOG_POS=154;
复制代码

    接着运行start slave;开启备份,正常状况以下图所示：Slave_IO_Running 和 Slave_SQL_Running 都为 yes。

    状态

能够用这个步骤开启多个从库。

  默认状况下备份是主库的所有操做都会备份到从库，实际可能须要忽略某些库，能够在主库中增长以下配置：

# 不一样步哪些数据库
binlog-ignore-db = mysql
binlog-ignore-db = test
binlog-ignore-db = information_schema

# 只同步哪些数据库，除此以外，其余不一样步
binlog-do-db = game
复制代码

三、代码层面进行读写分离

  代码环境是 springboot+mybatis+druib 链接池。想要读写分离就须要配置多个数据源，在进行写操做是选择写的数据源，读操做时选择读的数据源。其中有两个关键点：

  • 如何切换数据源
  • 如何根据不一样的方法选择正确的数据源

1)、如何切换数据源

  一般用 springboot 时都是使用它的默认配置，只须要在配置文件中定义好链接属性就好了，可是如今咱们须要本身来配置了，spring 是支持多数据源的，多个 datasource 放在一个 HashMapTargetDataSource中，经过dertermineCurrentLookupKey获取 key 来觉定要使用哪一个数据源。所以咱们的目标就很明确了，创建多个 datasource 放到 TargetDataSource 中，同时重写 dertermineCurrentLookupKey 方法来决定使用哪一个 key。

2)、如何选择数据源

  事务通常是注解在 Service 层的，所以在开始这个 service 方法调用时要肯定数据源，有什么通用方法可以在开始执行一个方法前作操做呢？相信你已经想到了那就是**切面 **。怎么切有两种办法：

  • 注解式，定义一个只读注解，被该数据标注的方法使用读库
  • 方法名，根据方法名写切点，好比 getXXX 用读库，setXXX 用写库

3)、代码编写

a、编写配置文件，配置两个数据源信息

  只有必填信息，其余都有默认设置

mysql:
 datasource:
    #读库数目
 num: 1
 type-aliases-package: com.example.dxfl.dao
 mapper-locations: classpath:/mapper/*.xml
 config-location: classpath:/mybatis-config.xml
 write:
 url: jdbc:mysql://192.168.226.5:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
 username: root
 password: 123456
 driver-class-name: com.mysql.jdbc.Driver
 read:
 url: jdbc:mysql://192.168.226.6:3306/test?useUnicode=true&characterEncoding=utf-8&useSSL=true
 username: root
 password: 123456
 driver-class-name: com.mysql.jdbc.Driver
复制代码

b、编写 DbContextHolder 类

  这个类用来设置数据库类别，其中有一个 ThreadLocal 用来保存每一个线程的是使用读库，仍是写库。代码以下：

/** * Description 这里切换读/写模式 * 原理是利用ThreadLocal保存当前线程是否处于读模式（经过开始READ_ONLY注解在开始操做前设置模式为读模式， * 操做结束后清除该数据，避免内存泄漏，同时也为了后续在该线程进行写操做时任然为读模式 * @author fxb * @date 2018-08-31 */
public class DbContextHolder {

    private static Logger log = LoggerFactory.getLogger(DbContextHolder.class);
    public static final String WRITE = "write";
    public static final String READ = "read";

    private static ThreadLocal<String> contextHolder= new ThreadLocal<>();

    public static void setDbType(String dbType) {
        if (dbType == null) {
            log.error("dbType为空");
            throw new NullPointerException();
        }
        log.info("设置dbType为：{}",dbType);
        contextHolder.set(dbType);
    }

    public static String getDbType() {
        return contextHolder.get() == null ? WRITE : contextHolder.get();
    }

    public static void clearDbType() {
        contextHolder.remove();
    }
}
复制代码

c、重写 determineCurrentLookupKey 方法

  spring 在开始进行数据库操做时会经过这个方法来决定使用哪一个数据库，所以咱们在这里调用上面 DbContextHolder 类的getDbType()方法获取当前操做类别,同时可进行读库的负载均衡，代码以下：

public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {

    @Value("${mysql.datasource.num}")
    private int num;

    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    protected Object determineCurrentLookupKey() {
        String typeKey = DbContextHolder.getDbType();
        if (typeKey == DbContextHolder.WRITE) {
            log.info("使用了写库");
            return typeKey;
        }
        //使用随机数决定使用哪一个读库
        int sum = NumberUtil.getRandom(1, num);
        log.info("使用了读库{}", sum);
        return DbContextHolder.READ + sum;
    }
}
复制代码

d、编写配置类

  因为要进行读写分离，不能再用 springboot 的默认配置，咱们须要手动来进行配置。首先生成数据源，使用@ConfigurProperties 自动生成数据源：

/** * 写数据源 * * @Primary 标志这个 Bean 若是在多个同类 Bean 候选时，该 Bean 优先被考虑。 * 多数据源配置的时候注意，必需要有一个主数据源，用 @Primary 标志该 Bean */
    @Primary
    @Bean
    @ConfigurationProperties(prefix = "mysql.datasource.write")
    public DataSource writeDataSource() {
        return new DruidDataSource();
    }
复制代码

读数据源相似，注意有多少个读库就要设置多少个读数据源，Bean 名为 read+序号。

  而后设置数据源，使用的是咱们以前写的 MyAbstractRoutingDataSource 类

/** * 设置数据源路由，经过该类中的determineCurrentLookupKey决定使用哪一个数据源 */
    @Bean
    public AbstractRoutingDataSource routingDataSource() {
        MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource();
        Map<Object, Object> targetDataSources = new HashMap<>(2);
        targetDataSources.put(DbContextHolder.WRITE, writeDataSource());
        targetDataSources.put(DbContextHolder.READ+"1", read1());
        proxy.setDefaultTargetDataSource(writeDataSource());
        proxy.setTargetDataSources(targetDataSources);
        return proxy;
    }
复制代码

  接着须要设置 sqlSessionFactory

/** * 多数据源须要本身设置sqlSessionFactory */
    @Bean
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(routingDataSource());
        ResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
        // 实体类对应的位置
        bean.setTypeAliasesPackage(typeAliasesPackage);
        // mybatis的XML的配置
        bean.setMapperLocations(resolver.getResources(mapperLocation));
        bean.setConfigLocation(resolver.getResource(configLocation));
        return bean.getObject();
    }
复制代码

  最后还得配置下事务，不然事务不生效

/** * 设置事务，事务须要知道当前使用的是哪一个数据源才能进行事务处理 */
    @Bean
    public DataSourceTransactionManager dataSourceTransactionManager() {
        return new DataSourceTransactionManager(routingDataSource());
    }
复制代码

4)、选择数据源

  多数据源配置好了，可是代码层面如何选择选择数据源呢？这里介绍两种办法：

a、注解式

  首先定义一个只读注解，被这个注解方法使用读库，其余使用写库，若是项目是中途改形成读写分离可以使用这个方法，无需修改业务代码，只要在只读的 service 方法上加一个注解便可。

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnly {
}
复制代码

  而后写一个切面来切换数据使用哪一种数据源，重写 getOrder 保证本切面优先级高于事务切面优先级，在启动类加上@EnableTransactionManagement(order = 10),为了代码以下：

@Aspect
@Component
public class ReadOnlyInterceptor implements Ordered {
    private static final Logger log= LoggerFactory.getLogger(ReadOnlyInterceptor.class);

    @Around("@annotation(readOnly)")
    public Object setRead(ProceedingJoinPoint joinPoint,ReadOnly readOnly) throws Throwable{
        try{
            DbContextHolder.setDbType(DbContextHolder.READ);
            return joinPoint.proceed();
        }finally {
            //清楚DbType一方面为了不内存泄漏，更重要的是避免对后续在本线程上执行的操做产生影响
            DbContextHolder.clearDbType();
            log.info("清除threadLocal");
        }
    }

    @Override
    public int getOrder() {
        return 0;
    }
}
复制代码

b、方法名式

  这种方法不准要注解，可是须要service中方法名称按必定规则编写，而后经过切面来设置数据库类别，好比setXXX设置为写、getXXX设置为读，代码我就不写了，应该都知道怎么写。

四、测试

  编写好代码来试试结果如何，下面是运行截图：

测试结果

读写分离只是数据库扩展的一个临时解决办法，并不能一劳永逸，随着负载进一步增大，只有一个库用于写入确定是不够的，并且单表的数据库是有上限的，mysql 最多千万级别的数据能保持较好的查询性能。最终仍是会变成--分库分表架构的。分库分表能够看看这一篇：www.tapme.top/blog/detail…

本文原创发布于：www.tapme.top/blog/detail…

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程