SpringBoot+mybatis一写多读数据分离实现

项目源码地址 https://github.com/HuangPugang/Java-lean

• multidata 读写分离实现部分
• multidata-test 测试项目

导读

本文就springboot+mybatis实现数据库一写多读方案的一些探讨。实现数据库的方案有很多，可以从代码层实现，也可以使用中间件进行实现。
常见的中间件有Mycat、Atlas等，
而我们今天讨论的是简易的代码层通过多数据源实现。

思路

我们在使用springboot+mybatis的时候，会再application.yml中配置一个数据源，配置完之后我们就知道操作mapper的时候就会连接配置好的数据库地址。
现在通过配置多个数据源+重写AbstractRoutingDataSource数据源路由+注解 来实现一写多读的实现

代码实现

DSProperties.java

配置文件，用于读取配置文件的属性

DSType.java

数据源类型，区分读or写

public enum DSType {
    read("read", "从库"),
    write("write", "主库");
}

DSTypeThreadLocal.java

数据源类型本地变量，使用ThreadLocal保存读库还是写库的类型，保证同一线程下访问同一张表

public class DSTypeThreadLocal {

    private static Logger log = LoggerFactory.getLogger(DSTypeThreadLocal.class);

    //线程本地环境
    private static final ThreadLocal<String> dsType = new ThreadLocal<String>();

    public static ThreadLocal<String> getLocal() {
        return dsType;
    }
    
    public static void setRead() {
        dsType.set(DSType.read.getType());
    }

    public static void setWrite() {
        dsType.set(DSType.write.getType());
    }

    public static String getCurrentType() {
        if (StringUtils.isEmpty(dsType.get())) {
            return DSType.read.getType();
        }
        return dsType.get();
    }

    public static void clear() {
        dsType.remove();
    }
}

DBHelper.java

DB属性封装工具类

RoutingDS.java

数据源路由，在这个类中决定我们所要访问的数据源

public class RoutingDS extends AbstractRoutingDataSource {
    AtomicInteger count = new AtomicInteger(0);

    private Integer readSize;

    public RoutingDS(Integer readSize) {
        this.readSize = readSize;
    }

    @Override
    protected Object determineCurrentLookupKey() {

        String typeKey = DSTypeThreadLocal.getCurrentType();

        if (typeKey == null) {
            return DSType.write.getType();
        }

        if (typeKey.equals(DSType.write.getType())) {
            return DSType.write.getType();
        }

        //读库， 简单负载均衡
        int number = count.getAndAdd(1);
        int lookupKey = number % readSize;

        return DSType.read.getType() + lookupKey;
    }
}

MybatisConfig.java

配置mybatis一些配置文件

@Configuration
@AutoConfigureAfter(DSProperties.class)
public class MybatisConfig {

    private static Logger log = LoggerFactory.getLogger(MybatisConfig.class);
    @Autowired
    DSProperties dp;

    private DataSource writeSource;

    private List<DataSource> readSourceList;


    @Bean(name = "sqlSessionFactory")
    public SqlSessionFactory sqlSessionFactory() throws Exception {
        try {
            SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
            sessionFactoryBean.setDataSource(roundRobinDataSourceProxy());

            //设置mapper.xml文件所在位置
            Resource[] resources = new PathMatchingResourcePatternResolver().getResources(dp.getMapperLocations());
            sessionFactoryBean.setMapperLocations(resources);
            return sessionFactoryBean.getObject();
        } catch (IOException e) {
            return null;
        } catch (Exception e) {
            return null;
        }
    }

    private void initWriteDataSource() {
        if (dp.getWrite() == null) {
            throw new RuntimeException("请先配置写数据库");
        }
        System.err.println("初始化写数据源");
        PoolProperties p = DBHelper.buildPoolProperties(dp.getWrite());
        p.setLogAbandoned(true);
        p.setDefaultAutoCommit(true);
        writeSource = new org.apache.tomcat.jdbc.pool.DataSource(p) {
            @PreDestroy
            public void close() {
                super.close(true);
            }
        };
    }

    private void initReadDataSource() {
        readSourceList = new ArrayList<>();
        if (dp.getReads() == null || dp.getReads().size() == 0) {
            throw new RuntimeException("请先配置读数据库");
        }
        System.err.println("初始化读数据源");
        for (int i = 0; i < dp.getReads().size(); i++) {
            PoolProperties p = DBHelper.buildPoolProperties(dp.getReads().get(i));
            p.setLogAbandoned(true);
            p.setDefaultAutoCommit(true);
            readSourceList.add(new org.apache.tomcat.jdbc.pool.DataSource(p) {
                @PreDestroy
                public void close() {
                    super.close(true);
                }
            });
        }
    }


    @Bean(name = "roundRobinDataSourceProxy")
    public AbstractRoutingDataSource roundRobinDataSourceProxy() {

        System.err.println("roundRobinDataSourceProxy");

        //初始化读数据源
        initReadDataSource();

        //初始化写数据源
        initWriteDataSource();

        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();

        targetDataSources.put(DSType.write.getType(), writeSource);

        if (readSourceList == null && readSourceList.size() == 0) {
            throw new RuntimeException("请配置读数据库");
        }
        for (int i = 0; i < readSourceList.size(); i++) {
            System.err.println("targetDataSources=" + DSType.read.getType() + i);
            targetDataSources.put(DSType.read.getType() + i, readSourceList.get(i));
        }
        final int readSize = readSourceList.size();

        //路由类，寻找对应的数据源
        AbstractRoutingDataSource proxy = new RoutingDS(readSize);

        proxy.setDefaultTargetDataSource(writeSource);//默认库
        proxy.setTargetDataSources(targetDataSources);
        return proxy;
    }


    @Bean
    @DependsOn("sqlSessionFactory")
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    //事务管理
    @Bean
    public PlatformTransactionManager annotationDriveTransactionManager() {
        System.out.println("事务管理");
        return new DataSourceTransactionManager((DataSource) SpringContext.getBean("roundRobinDataSourceProxy"));
    }

}

注解类

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface DSRead {

}

@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface DSWrite {

}

切面实现

对于数据源选择我们通过三种方式来决定读还是写

• 拦截service方法
  拦截service方法只是简单通过方法名来确定是否是读写，通常读数据库为list select 开头，而写通常为add、insert、update、delete开头，优先级最低
• 拦截自定义注解
  通过自定义注解来显示指定读库还是写库
• 拦截事务注解
  如果有有事务，那必定是访问写库，优先级最高

具体代码可参考项目源码。通过写此项目，可以加深对springboot、mybatis数据访问的理解。