Fork me on GitHub

SpringBoot Mybatis 读写分离配置(山东数漫江湖)

为什么需要读写分离

当项目越来越大和并发越来大的情况下,单个数据库服务器的压力肯定也是越来越大,最终演变成数据库成为性能的瓶颈,而且当数据越来越多时,查询也更加耗费时间,当然数据库数据过大时,可以采用数据库分库分表,同时数据库压力过大时,也可以采用Redis等缓存技术来降低压力,但是任何一种技术都不是万金油,很多时候都是通过多种技术搭配使用,而本文主要就是介绍通过读写分离来加快数据库读取速度

实现方式

读写分离实现的方式有多种,但是多种都需要配置数据库的主从复制,当然也许是有不需要配置的,只是我不知道而已

方式一

数据库中间件实现,如Mycat等数据库中间件,对于项目本身来说,只有一个数据源,就是链接到Mycat,再由mycat根据规则去选择从哪个库获取数据

方式二

代码中配置多数据源,通过代码控制使用哪个数据源,本文也是主要介绍这种方式

读写分离优劣

优点

1.降低数据库读取压力,尤其是有些需要大量计算的实时报表类应用 
2.增强数据安全性,读写分离有个好处就是数据近乎实时备份,一旦某台服务器硬盘发生了损坏,从库的数据可以无限接近主库 
3.可以实现高可用,当然只是配置了读写分离并不能实现搞可用,最多就是在Master(主库)宕机了还能进行查询操作,具体高可用还需要其他操作

缺点

1.增大成本,一台数据库服务器和多台数据库的成本肯定是不一样的 
2.增大代码复杂度,不过这点还比较轻微吧,但是也的确会一定程度上加重 
3.增大写入成本,虽然降低了读取成本,但是写入成本却是一点也没有降低,毕竟还有从库一直在向主库请求数据

MySQL主从复制配置

MySQL主从配置是实现读写分离的基本条件,具体实现MySQL主从复制可以参考我之前的文章MySQL主从复制搭建,基于日志(binlog)

数据源配置

spring:  
  application:
    name: separate
  master:
    url: jdbc:mysql://192.168.1.126:3307/test?useUnicode=true&characterEncoding=utf8&emptyStringsConvertToZero=true
    username: root
    password: 123456
    driver_class_namel: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    max-active: 20
    initial-size: 1
    min-idle: 3
    max-wait: 600
    time-between-eviction-runs-millis: 60000
    min-evictable-idle-time-millis: 300000
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    poolPreparedStatements: true
  slave:
    url: jdbc:mysql://192.168.1.126:3309/test?useUnicode=true&characterEncoding=utf8&emptyStringsConvertToZero=true
    username: test
    password: 123456
    driver_class_namel: com.mysql.jdbc.Driver
    type: com.alibaba.druid.pool.DruidDataSource

    max-active: 20
    initial-size: 1
    min-idle: 3
    max-wait: 600
    time-between-eviction-runs-millis: 60000
    min-evictable-idle-time-millis: 300000
    test-while-idle: true
    test-on-borrow: false
    test-on-return: false
    poolPreparedStatements: true

文件中配置了2个数据源,master是写库,slave是读库,为了防止向slave写入,slave的用户只有读取权限 因为代码中需要动态的设置数据源,所以数据源需要通过继承AbstractRoutingDataSource

/**
 * 动态数据源
 * @author Raye
 * @since 2016年10月25日15:20:40
 */
public class DynamicDataSource extends AbstractRoutingDataSource {  
    private static final ThreadLocal<DatabaseType> contextHolder = new ThreadLocal<DatabaseType>();

    @Override
    protected Object determineCurrentLookupKey() {
        return contextHolder.get();
    }

    public static enum DatabaseType {
        Master, Slave
    }

    public static void master(){
        contextHolder.set(DatabaseType.Master);
    }


    public static void slave(){
        contextHolder.set(DatabaseType.Slave);
    }

    public static void setDatabaseType(DatabaseType type) {
        contextHolder.set(type);
    }

    public static DatabaseType getType(){
        return contextHolder.get();
    }
}

contextHolder 是线程变量,因为每个请求是一个线程,所以通过这样来区分使用哪个库 
determineCurrentLookupKey是重写的AbstractRoutingDataSource的方法,主要是确定当前应该使用哪个数据源的key,因为AbstractRoutingDataSource 中保存的多个数据源是通过Map的方式保存的

实例化数据源
/**
 * Druid的DataResource配置类
 * @author Raye
 * @since 2016年10月7日14:14:18
 */
@Configuration
@EnableTransactionManagement
public class DataBaseConfiguration  implements EnvironmentAware {

    private RelaxedPropertyResolver propertyResolver1;
    private RelaxedPropertyResolver propertyResolver2;

    public DataBaseConfiguration(){
        System.out.println("####################  DataBaseConfiguration");
    }
    public void setEnvironment(Environment env) {
        this.propertyResolver1 = new RelaxedPropertyResolver(env, "spring.master.");
        this.propertyResolver2 = new RelaxedPropertyResolver(env, "spring.slave.");
    }

    public DataSource master() {
        System.out.println("注入Master druid!!!");
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(propertyResolver1.getProperty("url"));
        datasource.setDriverClassName(propertyResolver1.getProperty("driver-class-name"));
        datasource.setUsername(propertyResolver1.getProperty("username"));
        datasource.setPassword(propertyResolver1.getProperty("password"));
        datasource.setInitialSize(Integer.valueOf(propertyResolver1.getProperty("initial-size")));
        datasource.setMinIdle(Integer.valueOf(propertyResolver1.getProperty("min-idle")));
        datasource.setMaxWait(Long.valueOf(propertyResolver1.getProperty("max-wait")));
        datasource.setMaxActive(Integer.valueOf(propertyResolver1.getProperty("max-active")));
        datasource.setMinEvictableIdleTimeMillis(Long.valueOf(propertyResolver1.getProperty("min-evictable-idle-time-millis")));
        try {
            datasource.setFilters("stat,wall");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return datasource;
    }

    public DataSource slave() {
        System.out.println("Slave druid!!!");
        DruidDataSource datasource = new DruidDataSource();
        datasource.setUrl(propertyResolver2.getProperty("url"));
        datasource.setDriverClassName(propertyResolver2.getProperty("driver-class-name"));
        datasource.setUsername(propertyResolver2.getProperty("username"));
        datasource.setPassword(propertyResolver2.getProperty("password"));
        datasource.setInitialSize(Integer.valueOf(propertyResolver2.getProperty("initial-size")));
        datasource.setMinIdle(Integer.valueOf(propertyResolver2.getProperty("min-idle")));
        datasource.setMaxWait(Long.valueOf(propertyResolver2.getProperty("max-wait")));
        datasource.setMaxActive(Integer.valueOf(propertyResolver2.getProperty("max-active")));
        datasource.setMinEvictableIdleTimeMillis(Long.valueOf(propertyResolver2.getProperty("min-evictable-idle-time-millis")));
        try {
            datasource.setFilters("stat,wall");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return datasource;
    }

    @Bean
    public DynamicDataSource dynamicDataSource() {
        DataSource master = master();
        DataSource slave = slave();
        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
        targetDataSources.put(DynamicDataSource.DatabaseType.Master, master);
        targetDataSources.put(DynamicDataSource.DatabaseType.Slave, slave);

        DynamicDataSource dataSource = new DynamicDataSource();
        dataSource.setTargetDataSources(targetDataSources);// 该方法是AbstractRoutingDataSource的方法
        dataSource.setDefaultTargetDataSource(master);
        return dataSource;
    }


}

一共有3个数据源,一个master,一个slave,一个是动态数据源,保存在master和slave,为了防止spring注入异常,所以master和slave都是主动实例化的,并不是交给spring管理

dataSource.setDefaultTargetDataSource(master);  

是配置的如果没有配置当前使用哪个数据源的默认数据源,本来是打算配置slave,但是因为事物问题,所以配置的master

Mybatis配置
/**
 * MyBatis的配置类
 * 
 * @author Raye
 * @since 2016年10月7日14:13:39
 */
@Configuration
@AutoConfigureAfter({ DataBaseConfiguration.class })
@Slf4j
public class MybatisConfiguration {

    @Bean(name = "sqlSessionFactory")
    @Autowired
    public SqlSessionFactory sqlSessionFactory(DynamicDataSource dynamicDataSource) {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dynamicDataSource);
        try {

            SqlSessionFactory session = bean.getObject();
            MapperHelper mapperHelper = new MapperHelper();
            //特殊配置

            Config config = new Config();
            //具体支持的参数看后面的文档

            config.setNotEmpty(true);
            //设置配置

            mapperHelper.setConfig(config);
            // 注册自己项目中使用的通用Mapper接口,这里没有默认值,必须手动注册

            mapperHelper.registerMapper(Mapper.class);
            //配置完成后,执行下面的操作

            mapperHelper.processConfiguration(session.getConfiguration());
            return session;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    @Bean(name = "sqlSessionTemplate")
    @Autowired
    public SqlSessionTemplate sqlSessionTemplate(SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

    @Bean
    public MapperScannerConfigurer scannerConfigurer(){
        MapperScannerConfigurer configurer = new MapperScannerConfigurer();
        configurer.setSqlSessionFactoryBeanName("sqlSessionFactory");
        configurer.setSqlSessionTemplateBeanName("sqlSessionTemplate");
        configurer.setBasePackage("wang.raye.**.mapper");
        configurer.setMarkerInterface(Mapper.class);
        return configurer;
    }
}

MybatisConfiguration 主要是配置的sqlSessionFactory和sqlSessionTemplate,以及Mybatis的扩展框架Mapper的配置,如果不需要Mapper,可以不用配置scannerConfigurer

事物配置
@Configuration
@EnableTransactionManagement
@Slf4j
@AutoConfigureAfter({ MybatisConfiguration.class })
public class TransactionConfiguration extends DataSourceTransactionManagerAutoConfiguration {

    @Bean
    @Autowired
    public DataSourceTransactionManager transactionManager(DynamicDataSource dynamicDataSource) {
        log.info("事物配置");
        return new DataSourceTransactionManager(dynamicDataSource);
    }
}

事物配置这里有一个坑就是,一旦开启了事物,好像就会切换线程执行,所以并不会使用当前配置的数据源,而会取到默认的数据源,所以只能通过将默认数据源设置为master

AOP切入设置数据源

/**
 * 数据源的切入面
 *
 */
@Aspect
@Component
@Slf4j
public class DataSourceAOP {

    @Before("execution(* wang.raye.separate.service..*.select*(..)) || execution(* wang.raye.separate.service..*.get*(..))")
    public void setReadDataSourceType() {
        DynamicDataSource.slave();
        log.info("dataSource切换到:slave");
    }

    @Before("execution(* wang.raye.separate.service..*.insert*(..)) || execution(* wang.raye.separate.service..*.update*(..)) || execution(* wang.raye.separate.service..*.delete*(..)) || execution(* wang.raye.separate.service..*.add*(..))")
    public void setWriteDataSourceType() {
        DynamicDataSource.master();
        log.info("dataSource切换到:master");
    }

}

这样的配置是根据方法名来的,可以根据自己的情况配置

也可以使用注解来主动切换,创建两个注解类,一个Master,一个Slave Master.class

/**
 * 使用主库的注解
 */
public @interface Master {  
}

Slave.class

/**
 * 使用读库的注解
 */
public @interface Slave {  
}

AOP切入修改

/**
 * 数据源的切入面
 *
 */
@Aspect
@Component
@Slf4j
public class DataSourceAOP {

    @Before("(@annotation(wang.raye.separate.annotation.Master) || execution(* wang.raye.separate.service..*.insert*(..)) || " +
            "execution(* wang.raye.separate.service..*.update*(..)) || execution(* wang.raye.separate.service..*.delete*(..)) || " +
            "execution(* wang.raye.separate.service..*.add*(..))) && !@annotation(wang.raye.separate.annotation.Slave) -")
    public void setWriteDataSourceType() {
        DynamicDataSource.master();
        log.info("dataSource切换到:master");
    }

    @Before("(@annotation(wang.raye.separate.annotation.Slave) || execution(* wang.raye.separate.service..*.select*(..)) || execution(* wang.raye.separate.service..*.get*(..))) && !@annotation(wang.raye.separate.annotation.Master)")
    public void setReadDataSourceType() {
        DynamicDataSource.slave();
        log.info("dataSource切换到:slave");
    }


}

注:这个AOP切入规则只是包含基本的规格,如果要正常使用,需要扩展规则 简单的service层代码

/**
 * 用户相关业务接口实现类
 */
@Service
@Slf4j
public class UserServiceImpl implements UserService {  
    @Autowired
    private UserMapper mapper;

    @Master
    @Override
    public List<User> selectAll() {
        return mapper.selectAll();
    }

    @Override
    public boolean addUser(User user) {
        return mapper.insertSelective(user) > 0;
    }

    @Override
    public boolean updateUser(User user) {
        return mapper.updateByPrimaryKey(user) > 0;
    }

    @Override
    public boolean deleteByid(int id) {
        return mapper.deleteByPrimaryKey(id) > 0;
    }

    @Transactional(rollbackFor = Exception.class )
    @Override
    public boolean insertAndUpdate(User user){
        log.info("当前key:"+ DynamicDataSource.getType().name());
        int count = 0;
        count += mapper.insertSelective(user);
        user = null;
        user.getId();
        count += mapper.updateByPrimaryKey(user);
        return count > 1;
    }
}

这里所有方法会使用master源,如果去掉selectAll的Master注解,那么selectAll就会使用slave数据源,insertAndUpdate方法主要是测试使用事物的情况下是否是向Master数据源写入以及是否正常回滚

源码

具体代码可以直接看我的demo项目读写分离demo

posted @ 2018-04-25 11:04  梳碧湖砍柴的人  阅读(198)  评论(0编辑  收藏  举报