02-下篇-SpringBoot下MySQL的讀寫分離

前言：關於MySQL讀寫主從實現，分兩步：第一步，需要現有主從的環境，利用docker快速實現; -----上篇第二步，利用已有的環境進行JavaEE的Web專案配置。 -----下篇，基於SpringBoot的SpringDataJpa的實現！即本文環境：SpringBoot：2.0.3 DB:MySQL5.7.20 主從模式持久化框架：SpringDataJpa1.多資料來源的配置application.yml:#####MySQL資料庫的主從配置開始#####mysql: datasource: readSize: 1 #讀庫個數,可以有多個type: com.alibaba.druid.pool.DruidDataSourcewrite: url: jdbc:mysql://192.168.1.121:3306/db_frms?useUnicode=true&characterEncoding=utf-8username: rootpassword: 123456driver-class-name: com.mysql.jdbc.DriverminIdle:

5maxActive: 100initialSize: 10maxWait: 60000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: select 'x'testWhileIdle: truetestOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: truemaxPoolPreparedStatementPerConnectionSize: 50removeAbandoned: truefilters: statread01: url:

jdbc:mysql://192.168.1.121:3307/db_frms?useUnicode=true&characterEncoding=utf-8username: rootpassword: 123456driver-class-name: com.mysql.jdbc.DriverminIdle: 5maxActive: 100initialSize: 10maxWait: 60000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: select 'x'testWhileIdle: true

testOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: truemaxPoolPreparedStatementPerConnectionSize: 50removeAbandoned: truefilters: stat# read02: #因為我只用docker配置了一個slave，所以沒有第二個slave，故這段配置註釋掉！# url: jdbc:mysql://192.168.1.121:3308/test_02?useUnicode=true&characterEncoding=utf-8# username: root# password: root# driver-class-name: com.mysql.jdbc.Driver# minIdle: 5# maxActive: 100# initialSize: 10# maxWait: 60000# timeBetweenEvictionRunsMillis: 60000# minEvictableIdleTimeMillis: 300000# validationQuery: select 'x'# testWhileIdle: true# testOnBorrow: false# testOnReturn: false# poolPreparedStatements: true# maxPoolPreparedStatementPerConnectionSize: 50# removeAbandoned: true# filters: stat#####MySQL資料庫的主從配置結束#####
2.定義資料庫的型別列舉類DataSourceType：

package com.ddbin.frms.config.datasource;
import lombok.AllArgsConstructor;
import lombok.Getter;
/**
 * Description:資料來源型別的列舉類
*
 * @param
* @author dbdu
 * @date 18-7-14 上午8:05
 */
@Getter
@AllArgsConstructor
public enum DataSourceType {

    read("read", "從庫"), write("write", "主庫");
/**
     * Description:型別，是讀還是寫
*
     * @author dbdu
     * @date 18-7-14 上午8:14
     */
private String type;
/**
     * Description:資料來源的名稱
*
     * @author dbdu
     * @date 18-7-14 上午8:15
     */
private String name;
}

要注意的是：列舉例項小寫，大寫會報錯！！read("read", "從庫"), write("write", "主庫");3.多個數據源的例項化配置類DataSourceConfiguration：有多少個數據源，就配置多少個對應的Bean。

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Value;
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 org.springframework.context.annotation.Primary;
import javax.sql.DataSource;
/**
 * Description:MySQL讀寫主從資料庫源配置
*
 * @param
* @author dbdu
 * @date 18-7-14 上午7:51
 * @return
*/
@Configuration
@Slf4j
public class DataSourceConfiguration {

    @Value("${mysql.datasource.type}")
    private Class<? extends DataSource> dataSourceType;
/**
     * 寫庫 資料來源配置
*
     * @return
*/
@Bean(name = "writeDataSource")
    @Primary
    @ConfigurationProperties(prefix = "mysql.datasource.write")
    public DataSource writeDataSource() {
        log.info("writeDataSource init ...");
        return DataSourceBuilder.create().type(dataSourceType).build();
}

    /**
     * 有多少個從庫就要配置多少個
*
     * @return
*/
@Bean(name = "readDataSource01")
    @ConfigurationProperties(prefix = "mysql.datasource.read01")
    public DataSource readDataSourceOne() {
        log.info("read01 DataSourceOne init ...");
        return DataSourceBuilder.create().type(dataSourceType).build();
}

//    @Bean(name = "readDataSource02")
//    @ConfigurationProperties(prefix = "mysql.datasource.read02")
//    public DataSource readDataSourceTwo() {
//        log.info("read02 DataSourceTwo init ...");
//        return DataSourceBuilder.create().type(dataSourceType).build();
//    }
}

4.配置資料來源的切換類DataSourceContextHolder設定這個類的對應的read和write，就被內部用來讀取不同的資料來源

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
/**
 * Description:本地執行緒，資料來源上下文切換
*
 * @author dbdu
 * @date 18-7-14 上午8:17
 */
@Slf4j
public class DataSourceContextHolder {
    //線程本地環境
private static final ThreadLocal<String> local = new ThreadLocal<String>();
    public static ThreadLocal<String> getLocal() {
        return local;
}

    /**
     * 讀庫
*/
public static void setRead() {
        local.set(DataSourceType.read.getType());
//log.info("數據庫切換到READ庫...");
}

    /**
     * 寫庫
*/
public static void setWrite() {
        local.set(DataSourceType.write.getType());
// log.info("數據庫切換到WRITE庫...");
}

    public static String getReadOrWrite() {
        return local.get();
}

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

5.資料來源的代理路由配置DatasourceAgentConfig---請讀者特別注意這個類，網上很多說的都是mybatis框架的，這裡是SpringDataJpa框架對應的關聯代理資料來源路由的配置，此處配置出錯就會失敗！

package com.ddbin.frms.config.datasource;
import com.ddbin.frms.FrmsApplication;
import com.ddbin.frms.util.SpringContextsUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.Database;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;
@Configuration
@AutoConfigureAfter(DataSourceConfiguration.class)
@EnableTransactionManagement(order = 10)
@Slf4j
public class DatasourceAgentConfig {

    @Value("${mysql.datasource.readSize}")
    private String readDataSourceSize;
    private AbstractRoutingDataSource proxy;
@Autowired
    @Qualifier("writeDataSource")
    private DataSource writeDataSource;
@Autowired
    @Qualifier("readDataSource01")
    private DataSource readDataSource01;
//    @Autowired
//    @Qualifier("readDataSource02")
//    private DataSource readDataSource02;
/**
     * 把所有資料庫都放在路由中
* 重點是roundRobinDataSouceProxy()方法，它把所有的資料庫源交給AbstractRoutingDataSource類，
* 並由它的determineCurrentLookupKey()進行決定資料來源的選擇，其中讀庫進行了簡單的負載均衡（輪詢）。
*
     * @return
*/
@Bean(name = "roundRobinDataSouceProxy")
    public AbstractRoutingDataSource roundRobinDataSouceProxy() {

        /**
         * Description:把所有資料庫都放在targetDataSources中,注意key值要和determineCurrentLookupKey()中程式碼寫的一至，
*     否則切換資料來源時找不到正確的資料來源
*/
Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
targetDataSources.put(DataSourceType.write.getType(), writeDataSource);
targetDataSources.put(DataSourceType.read.getType() + "1", readDataSource01);
//targetDataSources.put(DataSourceType.read.getType() + "2", readDataSource02);
        //路由類，尋找對應的數據源
final int readSize = Integer.parseInt(readDataSourceSize);
MyAbstractRoutingDataSource proxy = new MyAbstractRoutingDataSource(readSize);
proxy.setTargetDataSources(targetDataSources);
//默認庫
proxy.setDefaultTargetDataSource(writeDataSource);
        this.proxy = proxy;
        return proxy;
}

    /**
     * Description:要特別注意，這個Bean是配置讀寫分離成敗的關鍵，
*
     * @param []
* @return org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean
     * @author dbdu
     * @date 18-7-15 下午5:08
     */
@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
vendorAdapter.setDatabase(Database.MYSQL);
//是否生成表
vendorAdapter.setGenerateDdl(true);
//是否顯示sql語句
vendorAdapter.setShowSql(true);
LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
factory.setJpaVendorAdapter(vendorAdapter);
//配置掃描的位置
factory.setPackagesToScan(FrmsApplication.class.getPackage().getName());
// 這個數據源設置為代理的數據源，----這是關鍵性配置！！！
factory.setDataSource(proxy);
        return factory;
}


    @Bean(name = "transactionManager")
    public MyJpaTransactionManager transactionManager() {

        MyJpaTransactionManager transactionManager = new MyJpaTransactionManager();
transactionManager.setDataSource(proxy);
transactionManager.setEntityManagerFactory((EntityManagerFactory) SpringContextsUtil.getBean("entityManagerFactory"));
        return transactionManager;
}
}

說明：entityManagerFactory是關鍵配置，網上很多說的都是mybatis的方式sqlSessionFactory的Bean會關聯代理資料來源，SpringDataJpa的方式使用entityManagerFactory來關聯代理資料來源，否則讀寫分離是假的，這個可以通過主從庫資料不同查詢可以知道！/** * Description:要特別注意，這個Bean是配置讀寫分離成敗的關鍵， * * @param []* @return org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean * @author dbdu * @date 18-7-15 下午5:08 */@Beanpublic LocalContainerEntityManagerFactoryBean entityManagerFactory() { HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();vendorAdapter.setDatabase(Database.MYSQL);//是否生成表vendorAdapter.setGenerateDdl(true);//是否顯示sql語句vendorAdapter.setShowSql(true);LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();factory.setJpaVendorAdapter(vendorAdapter);//配置掃描的位置factory.setPackagesToScan(FrmsApplication.class.getPackage().getName());// 這個資料來源設定為代理的資料來源，----這是關鍵性配置！！！factory.setDataSource(proxy); return factory;}6.自定義的路由資料來源及事務管理器的子類：

package com.ddbin.frms.config.datasource;
import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
 * Description: 抽象資料來源的路由的子類
* Created at:2018-07-15 13:37,
 * by dbdu
 */
@Getter
@Setter
@AllArgsConstructor
public class MyAbstractRoutingDataSource extends AbstractRoutingDataSource {

    /**
     * Description:讀庫的數量，可以用來實現負載均衡
*/
private int readSize;
//private AtomicLong count = new AtomicLong(0);
/**
     * 這是AbstractRoutingDataSource類中的一個抽象方法，
* 而它的返回值是你所要用的資料來源dataSource的key值，有了這個key值，
* targetDataSources就從中取出對應的DataSource，如果找不到，就用配置預設的資料來源。
*/
@Override
protected Object determineCurrentLookupKey() {
        String typeKey = DataSourceContextHolder.getReadOrWrite();
        if (typeKey == null || typeKey.equals(DataSourceType.write.getType())) {
            System.err.println("使用數據庫write.............");
            return DataSourceType.write.getType();
} else {
            //讀庫， 簡單負載均衡
//                    int number = count.getAndAdd(1);
//                    int lookupKey = number % readSize;
//                    System.err.println("使用數據庫read-" + (lookupKey + 1));
//                    return DataSourceType.read.getType() + (lookupKey + 1);
return DataSourceType.read.getType() + "1";
}
    }
}

package com.ddbin.frms.config.datasource;
import lombok.extern.slf4j.Slf4j;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.support.DefaultTransactionStatus;
@SuppressWarnings("serial")
@Slf4j
public class MyJpaTransactionManager extends JpaTransactionManager {

    @Override
protected void doBegin(Object transaction, TransactionDefinition definition) {
        if (definition.isReadOnly()) {
            DataSourceContextHolder.setRead();
} else {
            DataSourceContextHolder.setWrite();
}
        log.info("jpa-transaction:begin-----now dataSource is [" + DataSourceContextHolder.getReadOrWrite() + "]");
        super.doBegin(transaction, definition);
}

    @Override
protected void doCommit(DefaultTransactionStatus status) {
        log.info("jpa-transaction:commit-----now dataSource is [" + DataSourceContextHolder.getReadOrWrite() + "]");
        super.doCommit(status);
}
}

說明：如果方法命名不符合規則，也沒有加註解，則typeKey會有可能為null，下面的邏輯是typeKey為空使用寫庫！---也就是主庫。/** * 這是AbstractRoutingDataSource類中的一個抽象方法， * 而它的返回值是你所要用的資料來源dataSource的key值，有了這個key值， * targetDataSources就從中取出對應的DataSource，如果找不到，就用配置預設的資料來源。 */@Overrideprotected Object determineCurrentLookupKey() { String typeKey = DataSourceContextHolder.getReadOrWrite(); if (typeKey == null || typeKey.equals(DataSourceType.write.getType())) { System.err

02-下篇-SpringBoot下MySQL的讀寫分離

02-下篇-SpringBoot下MySQL的讀寫分離

springboot+ssm+mysql 讀寫分離+動態修改資料來源

SpringBoot+MyBatis+MySQL讀寫分離

windows 下 MySQL讀寫分離、主從複製、通過amoeba代理實現讀寫分離配置全過程

Linux環境下mysql讀寫分離以及主從配置（不錯可以的）

mysql讀寫分離之springboot整合

二. Mysql讀寫分離：springboot服務端AbstractRoutingDataSource整合

springboot環境下實現讀寫分離

Mysql讀寫分離方案－MySQL Proxy環境部署記錄

amoeba實現mysql讀寫分離+主從復制架構

mysql中間件amoeba實現mysql讀寫分離

mysql讀寫分離的三種實現方式

mysql讀寫分離

mycat實現MySQL讀寫分離

Linux的企業-Mysql讀寫分離，組的復制Group-based Replication（2）

使用Spring AOP實現MySQL讀寫分離

實現MySQL讀寫分離，MySQL性能調優

6MySQL 主從同步、 MySQL 讀寫分離、 MySQL 性能調優

Mysql讀寫分離-Mysql router

Mysql讀寫分離-amoeba

02-下篇-SpringBoot下MySQL的讀寫分離

相關推薦