如何實現讀寫分離，Spring Boot項目，數據庫是MySQL，持久層用的是MyBatis。

其實，實現這個很簡單的，首先思考一個問題:

在高并發(fā)的場景中，關于數據庫都有哪些優(yōu)化的手段？

常用的有以下的實現方法：讀寫分離、加緩存、主從架構集群、分庫分表等。

在互聯網應用中，大部分都是讀多寫少 的場景，設置兩個庫，主庫和讀庫。

主庫的職能是負責寫，從庫主要是負責讀,可以建立讀庫集群,通過讀寫職能在數據源上的隔離達到減少讀寫沖突、釋壓數據庫負載 、保護數據庫的目的 。在實際的使用中,凡是涉及到寫的部分直接切換到主庫，讀的部分直接切換到讀庫，這就是典型的讀寫分離技術。

本文將聚焦讀寫分離，探討如何實現它。

主從同步的局限性 ：這里分為主數據庫和從數據庫，主數據庫和從數據庫保持數據庫結構的一致，主庫負責寫，當寫入數據的時候，會自動同步數據到從數據庫。從數據庫負責讀，當讀請求來的時候，直接從讀庫讀取數據，主數據庫會自動進行數據復制到從數據庫中。不過本篇博客不介紹這部分配置的知識，因為它更偏運維工作一點。

這里涉及到一個問題:

主從復制的延遲問題，當寫入到主數據庫的過程中，突然來了一個讀請求，而此時數據還沒有完全同步,就會出現讀請求的數據讀不到或者讀出的數據比原始值少的情況。具體的解決方法最簡單的就是將讀請求暫時指向主庫,但是同時也失去了主從分離的部分意義。也就是說在嚴格意義上的數據一致性場景中,讀寫分離并非是完全適合的,注意更新的時效性是讀寫分離使用的缺點。

好了，這部分只是了解，接下來我們看下具體如何通過 Java 代碼來實現讀寫分離：

注意：該項目需要引入如下依賴：Spring Boot、spring-aop、spring-jdbc、aspectjweaver 等

程序媛：僅有30天，該怎么準備？

一: 主從數據源的配置

我們需要配置主從數據庫，主從數據庫的配置一般都是寫在配置文件里面。通過@ConfigurationProperties 注解，可以將配置文件(一般命名為：application.Properties)里的屬性映射到具體的類屬性上，從而讀取到寫入的值注入到具體的代碼配置中，按照習慣大于約定的原則，主庫我們都是注為 master，從庫注為 slave。application.Properties)里的屬性映射到具體的類屬性上，從而讀取到寫入的值注入到具體的代碼配置中，按照習慣大于約定的原則，主庫我們都是注為 master，從庫注為 slave。

本項目采用了阿里的 druid 數據庫連接池，使用 build 建造者模式創(chuàng)建 DataSource 對象，DataSource 就是代碼層面抽象出來的數據源，接著需要配置 sessionFactory、sqlTemplate、事務管理器等。

/**
 * 主從配置 
 */
@Configuration
@MapperScan(basePackages = "com.wyq.mysqlreadwriteseparate.mapper", sqlSessionTemplateRef = "sqlTemplate")
public class DataSourceConfig {

    /**
     * 主庫
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource master() {
        return DruidDataSourceBuilder.create().build();
    }

    /**
     * 從庫
     */
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.slave")
    public DataSource slaver() {
        return DruidDataSourceBuilder.create().build();
    }


    /**
     * 實例化數據源路由
     */
    @Bean
    public DataSourceRouter dynamicDB(@Qualifier("master") DataSource masterDataSource,
                                      @Autowired(required = false) @Qualifier("slaver") DataSource slaveDataSource) {
        DataSourceRouter dynamicDataSource = new DataSourceRouter();
        Map<Object, Object> targetDataSources = new HashMap<>();
        targetDataSources.put(DataSourceEnum.MASTER.getDataSourceName(), masterDataSource);
        if (slaveDataSource != null) {
            targetDataSources.put(DataSourceEnum.SLAVE.getDataSourceName(), slaveDataSource);
        }
        dynamicDataSource.setTargetDataSources(targetDataSources);
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource);
        return dynamicDataSource;
    }


    /**
     * 配置sessionFactory
     * @param dynamicDataSource
     * @return
     * @throws Exception
     */
    @Bean
    public SqlSessionFactory sessionFactory(@Qualifier("dynamicDB") DataSource dynamicDataSource) throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*Mapper.xml"));
        bean.setDataSource(dynamicDataSource);
        return bean.getObject();
    }


    /**
     * 創(chuàng)建sqlTemplate
     * @param sqlSessionFactory
     * @return
     */
    @Bean
    public SqlSessionTemplate sqlTemplate(@Qualifier("sessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }


    /**
     * 事務配置
     *
     * @param dynamicDataSource
     * @return
     */
    @Bean(name = "dataSourceTx")
    public DataSourceTransactionManager dataSourceTransactionManager(@Qualifier("dynamicDB") DataSource dynamicDataSource) {
        DataSourceTransactionManager dataSourceTransactionManager = new DataSourceTransactionManager();
        dataSourceTransactionManager.setDataSource(dynamicDataSource);
        return dataSourceTransactionManager;
    }
}

二: 數據源路由的配置

路由在主從分離是非常重要的，基本是讀寫切換的核心。Spring 提供了 AbstractRoutingDataSource 根據用戶定義的規(guī)則選擇當前的數據源，作用就是在執(zhí)行查詢之前，設置使用的數據源,實現動態(tài)路由的數據源，在每次數據庫查詢操作前執(zhí)行它的抽象方法 determineCurrentLookupKey()

public class DataSourceRouter extends AbstractRoutingDataSource {

    /**
     * 最終的determineCurrentLookupKey返回的是從DataSourceContextHolder中拿到的,因此在動態(tài)切換數據源的時候注解
     * 應該給DataSourceContextHolder設值
     *
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.get();

    }
}

public class DataSourceRouter extends AbstractRoutingDataSource {

    /**
     * 最終的determineCurrentLookupKey返回的是從DataSourceContextHolder中拿到的,因此在動態(tài)切換數據源的時候注解
     * 應該給DataSourceContextHolder設值
     *
     * @return
     */
    @Override
    protected Object determineCurrentLookupKey() {
        return DataSourceContextHolder.get();

    }
}

三：數據源上下文環(huán)境

數據源上下文保存器,便于程序中可以隨時取到當前的數據源，它主要利用 ThreadLocal 封裝，因為 ThreadLocal 是線程隔離的，天然具有線程安全的優(yōu)勢。這里暴露了 set 和 get、clear 方法，set 方法用于賦值當前的數據源名，get 方法用于獲取當前的數據源名稱，clear 方法用于清除 ThreadLocal 中的內容，因為 ThreadLocal 的 key 是 weakReference 是有內存泄漏風險的，通過 remove 方法防止內存泄漏。

/**
 * 利用ThreadLocal封裝的保存數據源上線的上下文context
 */
public class DataSourceContextHolder {

    private static final ThreadLocal<String> context = new ThreadLocal<>();

    /**
     * 賦值
     *
     * @param datasourceType
     */
    public static void set(String datasourceType) {
        context.set(datasourceType);
    }

    /**
     * 獲取值
     * @return
     */
    public static String get() {
        return context.get();
    }

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

四：切換注解和 Aop 配置

首先我們來定義一個@DataSourceSwitcher 注解,擁有兩個屬性

① 當前的數據源② 是否清除當前的數據源，并且只能放在方法上，(不可以放在類上，也沒必要放在類上，因為我們在進行數據源切換的時候肯定是方法操作)，該注解的主要作用就是進行數據源的切換，在 dao 層進行操作數據庫的時候，可以在方法上注明表示的是當前使用哪個數據源。

@DataSourceSwitcher 注解的定義:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
@Documented
public @interface DataSourceSwitcher {
    /**
     * 默認數據源
     * @return
     */
    DataSourceEnum value() default DataSourceEnum.MASTER;
    /**
     * 清除
     * @return
     */
    boolean clear() default true;

}

DataSourceAop配置：

為了賦予@DataSourceSwitcher 注解能夠切換數據源的能力，我們需要使用 AOP，然后使用@Aroud 注解找到方法上有@DataSourceSwitcher.class 的方法，然后取注解上配置的數據源的值，設置到 DataSourceContextHolder 中，就實現了將當前方法上配置的數據源注入到全局作用域當中。

@Slf4j
@Aspect
@Order(value = 1)
@Component
public class DataSourceContextAop {

    @Around("@annotation(com.wyq.mysqlreadwriteseparate.annotation.DataSourceSwitcher)")
    public Object setDynamicDataSource(ProceedingJoinPoint pjp) throws Throwable {
        boolean clear = false;
        try {
            Method method = this.getMethod(pjp);
            DataSourceSwitcher dataSourceSwitcher = method.getAnnotation(DataSourceSwitcher.class);
            clear = dataSourceSwitcher.clear();
            DataSourceContextHolder.set(dataSourceSwitcher.value().getDataSourceName());
            log.info("數據源切換至：{}", dataSourceSwitcher.value().getDataSourceName());
            return pjp.proceed();
        } finally {
            if (clear) {
                DataSourceContextHolder.clear();
            }

        }
    }

    private Method getMethod(JoinPoint pjp) {
        MethodSignature signature = (MethodSignature) pjp.getSignature();
        return signature.getMethod();
    }

}

五：用法以及測試

在配置好了讀寫分離之后,就可以在代碼中使用了，一般而言我們使用在 service 層或者 dao 層，在需要查詢的方法上添加@DataSourceSwitcher(DataSourceEnum.SLAVE)，它表示該方法下所有的操作都走的是讀庫。在需要 update 或者 insert 的時候使用@DataSourceSwitcher(DataSourceEnum.MASTER)表示接下來將會走寫庫。

其實還有一種更為自動的寫法,可以根據方法的前綴來配置 AOP 自動切換數據源，比如 update、insert、fresh 等前綴的方法名一律自動設置為寫庫。select、get、query 等前綴的方法名一律配置為讀庫，這是一種更為自動的配置寫法。缺點就是方法名需要按照 aop 配置的嚴格來定義，否則就會失效。

@Service
public class OrderService {

    @Resource
    private OrderMapper orderMapper;


    /**
     * 讀操作
     *
     * @param orderId
     * @return
     */
    @DataSourceSwitcher(DataSourceEnum.SLAVE)
    public List<Order> getOrder(String orderId) {
        return orderMapper.listOrders(orderId);

    }

    /**
     * 寫操作
     *
     * @param orderId
     * @return
     */
    @DataSourceSwitcher(DataSourceEnum.MASTER)
    public List<Order> insertOrder(Long orderId) {
        Order order = new Order();
        order.setOrderId(orderId);
        return orderMapper.saveOrder(order);
    }
}

六：總結

還是畫張圖來簡單總結一下：

本文介紹了如何實現數據庫讀寫分離，注意讀寫分離的核心點就是數據路由，需要繼承 AbstractRoutingDataSource，復寫它的 determineCurrentLookupKey ()方法。同時需要注意全局的上下文管理器 DataSourceContextHolder，它是保存數據源上下文的主要類，也是路由方法中尋找的數據源取值。相當于數據源的中轉站，再結合 jdbc-Template 的底層去創(chuàng)建和管理數據源、事務等，我們的數據庫讀寫分離就完美實現了。