Springboot Mybatis MySQL读写分离及事物配置

╰半橙微兮° 2022-05-31 00:11 189阅读 0赞

#### 为什么需要读写分离 ####

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

#### 实现方式 ####

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

##### 方式一 #####

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

##### 方式二 #####

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

#### 读写分离优劣 ####

##### 优点 #####

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

##### 缺点 #####

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

#### MySQL主从复制配置 ####

MySQL主从配置是实现读写分离的基本条件，具体实现MySQL主从复制可以参考我之前的文章[MySQL主从复制搭建，基于日志（binlog）][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][demo]

[MySQL_binlog]: http://raye.wang/2017/04/14/mysqlzhu-cong-fu-zhi-da-jian-ji-yu-ri-zhi-binlog/
[demo]: https://gitee.com/raywang2014/separate