微服务-springboot-读写分离（多数据源切换）
为什么需要读写分离
当项目越来越大和并发越来大的情况下，单个数据库服务器的压力肯定也是越来越大，最终演变成数据库成为性能的瓶颈，而且当数据越来越多时，查询也更加耗费时间，当然数据库数据过大时，可以采用数据库分库分表，同时数据库压力过大时，也可以采用Redis等缓存技术来降低压力，但是任何一种技术都不是万金油，很多时候都是通过多种技术搭配使用，而本文主要就是介绍通过读写分离来加快数据库读取速度
实现方式
读写分离实现的方式有多种，但是多种都需要配置数据库的主从复制
方式一
数据库中间件实现，如Mycat等数据库中间件，对于项目本身来说，只有一个数据源，就是链接到Mycat，再由mycat根据规则去选择从哪个库获取数据
方式二
代码中配置多数据源，通过代码控制使用哪个数据源，本文也是主要介绍这种方式
优点
1.降低数据库读取压力，尤其是有些需要大量计算的实时报表类应用
2.增强数据安全性，读写分离有个好处就是数据近乎实时备份，一旦某台服务器硬盘发生了损坏，从库的数据可以无限接近主库
3.可以实现高可用，当然只是配置了读写分离并不能实现搞可用，最多就是在Master（主库）宕机了还能进行查询操作，具体高可用还需要其他操作
缺点
1.增大成本，一台数据库服务器和多台数据库的成本肯定是不一样的
2.增大代码复杂度，不过这点还比较轻微吧，但是也的确会一定程度上加重
3.增大写入成本，虽然降低了读取成本，但是写入成本却是一点也没有降低，毕竟还有从库一直在向主库请求数据
实践：
项目结构：
application.yml
spring: datasource: master: # 写账户 jdbc-url: jdbc:mysql://localhost:3306/otadb?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false username: root password: 123456 slave1: # 只读账户 jdbc-url: jdbc:mysql://localhost:3306/otadb1?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false username: root password: 123456 slave2: # 只读账户 jdbc-url: jdbc:mysql://localhost:3306/otadb2?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8&useSSL=false username: root password: 123456
多数据源配置
import com.microservice.readwriteseparat.bean.MyRoutingDataSource; import com.microservice.readwriteseparat.enums.DBTypeEnum; import org.springframework.beans.factory.annotation.Qualifier; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.boot.jdbc.DataSourceBuilder; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import javax.sql.DataSource; import java.util.HashMap; import java.util.Map; @Configuration public class DataSourceConfig { /** * 写库 * @return */ @Bean @ConfigurationProperties("spring.datasource.master") public DataSource masterDataSource() { return DataSourceBuilder.create().build(); } /** * 读库 * @return */ @Bean @ConfigurationProperties("spring.datasource.slave1") public DataSource slave1DataSource() { return DataSourceBuilder.create().build(); } /** * 读库 * @return */ @Bean @ConfigurationProperties("spring.datasource.slave2") public DataSource slave2DataSource() { return DataSourceBuilder.create().build(); } @Bean public DataSource myRoutingDataSource(@Qualifier("masterDataSource") DataSource masterDataSource, @Qualifier("slave1DataSource") DataSource slave1DataSource, @Qualifier("slave2DataSource") DataSource slave2DataSource) { Map<Object, Object> targetDataSources = new HashMap<>(); targetDataSources.put(DBTypeEnum.MASTER, masterDataSource); targetDataSources.put(DBTypeEnum.SLAVE1, slave1DataSource); targetDataSources.put(DBTypeEnum.SLAVE2, slave2DataSource); MyRoutingDataSource myRoutingDataSource = new MyRoutingDataSource(); myRoutingDataSource.setDefaultTargetDataSource(masterDataSource); myRoutingDataSource.setTargetDataSources(targetDataSources); return myRoutingDataSource; } }
这里，我们配置了4个数据源，1个master，2两个slave，1个路由数据源。前3个数据源都是为了生成第4个数据源，而且后续我们只用这最后一个路由数据源myRoutingDataSource。
MyBatis配置
import org.apache.ibatis.session.SqlSessionFactory; import org.mybatis.spring.SqlSessionFactoryBean; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.core.io.support.PathMatchingResourcePatternResolver; import org.springframework.jdbc.datasource.DataSourceTransactionManager; import org.springframework.transaction.PlatformTransactionManager; import org.springframework.transaction.annotation.EnableTransactionManagement; import javax.annotation.Resource; import javax.sql.DataSource; @EnableTransactionManagement @Configuration public class MyBatisConfig { @Resource(name = "myRoutingDataSource") private DataSource myRoutingDataSource; /** * 扫描mybatis下的xml文件 * @return * @throws Exception */ @Bean public SqlSessionFactory sqlSessionFactory() throws Exception { SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean(); sqlSessionFactoryBean.setDataSource(myRoutingDataSource); sqlSessionFactoryBean.setMapperLocations(new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/*.xml")); return sqlSessionFactoryBean.getObject(); } @Bean public PlatformTransactionManager platformTransactionManager() { return new DataSourceTransactionManager(myRoutingDataSource);//由于Spring容器中现在有4个数据源，所以我们需要为事务管理器和MyBatis手动指定一个明确的数据源。 } }
定义一个枚举来代表这三个数据源
public enum DBTypeEnum { MASTER,SLAVE1,SLAVE2 }
通过ThreadLocal将数据源设置到每个线程上下文中
import com.microservice.readwriteseparat.enums.DBTypeEnum; import java.util.concurrent.atomic.AtomicInteger; public class DBContextHolder { private static final ThreadLocal<DBTypeEnum> contextHolder = new ThreadLocal<>(); private static final AtomicInteger counter = new AtomicInteger(-1); public static void set(DBTypeEnum dbType) { contextHolder.set(dbType); } public static DBTypeEnum get() { return contextHolder.get(); } public static void master() { set(DBTypeEnum.MASTER); System.out.println("切换到master"); } public static void slave() { // 轮询 int index = counter.getAndIncrement() % 2; if (counter.get() > 9999) { counter.set(-1); } if (index == 0) { set(DBTypeEnum.SLAVE1); System.out.println("切换到slave1"); }else { set(DBTypeEnum.SLAVE2); System.out.println("切换到slave2"); } } }
获取路由key
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource; import org.springframework.lang.Nullable; public class MyRoutingDataSource extends AbstractRoutingDataSource { @Nullable @Override protected Object determineCurrentLookupKey() { return DBContextHolder.get(); } }
默认情况下，所有的查询都走从库，插入/修改/删除走主库。我们通过方法名来区分操作类型（CRUD）
import com.microservice.readwriteseparat.bean.DBContextHolder; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Before; import org.aspectj.lang.annotation.Pointcut; import org.springframework.stereotype.Component; @Aspect @Component public class DataSourceAop { /** * 只读： * 不是Master注解的对象或方法 && select开头的方法 || get开头的方法 */ @Pointcut("!@annotation(com.microservice.readwriteseparat.annotation.Master) " + "&& (execution(* com.microservice.readwriteseparat.service..*.select*(..)) " + "|| execution(* com.microservice.readwriteseparat.service..*.get*(..)))") public void readPointcut() { } /** * 写： * Master注解的对象或方法 || insert开头的方法 || add开头的方法 || update开头的方法 * || edlt开头的方法 || delete开头的方法 || remove开头的方法 */ @Pointcut("@annotation(com.microservice.readwriteseparat.annotation.Master) " + "|| execution(* com.microservice.readwriteseparat.service..*.insert*(..)) " + "|| execution(* com.microservice.readwriteseparat.service..*.add*(..)) " + "|| execution(* com.microservice.readwriteseparat.service..*.update*(..)) " + "|| execution(* com.microservice.readwriteseparat.service..*.edit*(..)) " + "|| execution(* com.microservice.readwriteseparat.service..*.delete*(..)) " + "|| execution(* com.microservice.readwriteseparat..*.remove*(..))") public void writePointcut() { } @Before("readPointcut()") public void read() { DBContextHolder.slave(); } @Before("writePointcut()") public void write() { DBContextHolder.master(); } }
有一般情况就有特殊情况，特殊情况是某些情况下我们需要强制读主库，针对这种情况，我们定义一个主键，用该注解标注的就读主库
public @interface Master { }
mapper:
import com.microservice.readwriteseparat.po.TestPO; import org.apache.ibatis.annotations.Mapper; @Mapper public interface TestPOMapper { int deleteByPrimaryKey(Long id); int insert(TestPO record); int insertSelective(TestPO record); TestPO selectByPrimaryKey(Long id); int updateByPrimaryKeySelective(TestPO record); int updateByPrimaryKey(TestPO record); }
po:
public class TestPO { private Long id; private String name; public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name == null ? null : name.trim(); } }
service:
import com.microservice.readwriteseparat.annotation.Master; import com.microservice.readwriteseparat.mapper.TestPOMapper; import com.microservice.readwriteseparat.po.TestPO; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class TestService{ @Autowired private TestPOMapper testPOMapper; public int insert(TestPO aaa) { return testPOMapper.insert(aaa); } @Master public int save(TestPO aaa) { return testPOMapper.insert(aaa); } public TestPO selectByPrimaryKey(Long id) { return testPOMapper.selectByPrimaryKey(id); } @Master public TestPO getById(Long id) { // 有些读操作必须读主数据库 // 比如，获取微信access_token，因为高峰时期主从同步可能延迟 // 这种情况下就必须强制从主数据读 return testPOMapper.selectByPrimaryKey(id); } }
测试：
import com.microservice.readwriteseparat.po.TestPO; import com.microservice.readwriteseparat.service.TestService; import org.junit.Test; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; @RunWith(SpringRunner.class) @SpringBootTest public class ReadwriteseparatApplicationTests { private static final Logger logger = LoggerFactory.getLogger(ReadwriteseparatApplicationTests.class); @Autowired private TestService aaaService; /** * 写库进行写入 */ @Test public void testWrite() { TestPO aaa = new TestPO(); aaaService.insert(aaa); } /** * 读库（otadb1和otadb2随机）进行读取 */ @Test public void testRead() { TestPO aaa = aaaService.selectByPrimaryKey(1l); logger.info("aaa="+aaa.toString()); } /** * 写库进行写入 */ @Test public void testSave() { TestPO aaa = new TestPO(); aaaService.save(aaa); } /** * 写库进行读取 */ @Test public void testReadFromMaster() { aaaService.getById(10001l); } }
查看控制台：
源码地址：https://github.com/qjm201000/micro_service_readwriteseparat.git
参考资料：https://www.cnblogs.com/cjsblog/p/9712457.html
