2. 程式人生 > >SpringBoot進行MySql動態資料來源配置實現讀寫分離（連線池Druid）

SpringBoot進行MySql動態資料來源配置實現讀寫分離（連線池Druid）

阿新 • • 發佈：2019-01-18

1.簡介

前面使用C3P0連線池進行過資料庫的讀寫分離的實驗，今天換一下資料庫連線池改造一下，原理還是和原來的一樣。
Druid是阿里出品，淘寶和支付寶專用資料庫連線池，但它不僅僅是一個數據庫連線池，它還包含一個ProxyDriver，一系列內建的JDBC元件庫，一個 SQL Parser。支援所有JDBC相容的資料庫，包括Oracle、MySql、Derby、Postgresql、SQL Server、H2等等。Druid針對Oracle和MySql做了特別優化，比如Oracle的PS Cache記憶體佔用優化，MySql的ping檢測優化。Druid提供了MySql、Oracle、Postgresql、SQL-92的SQL的完整支援，這是一個手寫的高效能SQL Parser，支援Visitor模式，使得分析SQL的抽象語法樹很方便。簡單SQL語句用時10微秒以內，複雜SQL用時30微秒。通過Druid提供的SQL Parser可以在JDBC層攔截SQL做相應處理，比如說分庫分表、審計等。Druid防禦SQL注入攻擊的WallFilter就是通過Druid的SQL Parser分析語義實現的。（本小段摘抄自

https://blog.csdn.net/qq_34359363/article/details/72763491）

2.引入依賴

        <!-- mysql連線的jar包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- druid資料庫連線池 -->
 

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.28</version>
        </dependency>

3.配置主從資料庫


#資料庫連線池型別
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

# 主資料庫連線
spring
 
.datasource.master.driverClassName=com.mysql.jdbc.Driver
#spring.datasource.master.url=jdbc:mysql:///mychat?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
spring.datasource.master.url=jdbc:mysql://***.***.***.***:3306/mychat?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
spring.datasource.master.username=****
spring.datasource.master.password=******
# 初始化大小
spring.datasource.master.initialSize=3
# 最小
spring.datasource.master.minIdle=3
# 最大
spring.datasource.master.maxActive=20
# 配置獲取連線等待超時的時間
spring.datasource.master.maxWait=60000
# 配置間隔多久才進行一次檢測，檢測需要關閉的空閒連線，單位是毫秒 
spring.datasource.master.timeBetweenEvictionRunsMillis=600000
# 配置一個連線在池中最小生存的時間，單位是毫秒 
spring.datasource.master.minEvictableIdleTimeMillis=300000
spring.datasource.master.validationQuery=SELECT 1 FROM DUAL
spring.datasource.master.testWhileIdle=true
spring.datasource.master.testOnBorrow=true
spring.datasource.master.testOnReturn=false
# 開啟PSCache，並且指定每個連線上PSCache的大小 
spring.datasource.master.poolPreparedStatements=true
spring.datasource.master.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.master.filters=stat,wall,log4j
spring.datasource.master.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
spring.datasource.master.useGlobalDataSourceStat=true

# 從資料庫連線
spring.datasource.slave.driverClassName=com.mysql.jdbc.Driver
#spring.datasource.slave.url=jdbc:mysql:///mychat?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
spring.datasource.slave.url=jdbc:mysql://***.***.***.***:3306/mychat?useUnicode=true&characterEncoding=utf8&autoReconnect=true&failOverReadOnly=false&useSSL=false
spring.datasource.slave.username=*****
spring.datasource.slave.password=*******
spring.datasource.slave.initialSize=3
spring.datasource.slave.minIdle=3
spring.datasource.slave.maxActive=20
spring.datasource.slave.maxWait=60000
spring.datasource.slave.timeBetweenEvictionRunsMillis=600000
spring.datasource.slave.minEvictableIdleTimeMillis=300000
spring.datasource.slave.validationQuery=SELECT 1 FROM DUAL
spring.datasource.slave.testWhileIdle=true
spring.datasource.slave.testOnBorrow=true
spring.datasource.slave.testOnReturn=false
spring.datasource.slave.poolPreparedStatements=true
spring.datasource.slave.maxPoolPreparedStatementPerConnectionSize=20
spring.datasource.slave.filters=stat,wall,log4j
spring.datasource.slave.connectionProperties=druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000
spring.datasource.slave.useGlobalDataSourceStat=true

4.配置資料來源


import com.alibaba.druid.support.http.StatViewServlet;
import com.alibaba.druid.support.http.WebStatFilter;
import com.center.constant.ConstantPool;
import com.center.support.database.ReadOnlyConnectionAspect;
import com.center.support.database.ReadWriteSplitRoutingDataSource;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.DependsOn;
import org.springframework.context.annotation.Primary;

/**
 * Druid監控
 * 
 * @Title: DruidDBConfig.java
 * @Package com.center.config
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月19日
 */
@Configuration
public class DruidDBConfig {

    /**
     * 資料庫連線池型別
     */
    @Value("${spring.datasource.type}")
    private Class<? extends DataSource> dataSourceType;

    /**
     * 動態資料來源
     * 
     * @return 動態資料庫連線池 DataSource
     */
    @Bean(name = "dataSource")
    @Qualifier(value = "dataSource")
    @Primary
    @DependsOn({ "masterDataSource", "slaveDataSource" })
    public DataSource dataSource(@Qualifier("masterDataSource") DataSource masterDataSource,
            @Qualifier("slaveDataSource") DataSource slaveDataSource) {
        System.out.println(masterDataSource.toString());
        System.out.println(slaveDataSource.toString());
        ReadWriteSplitRoutingDataSource writeSplitRoutingDataSource = new ReadWriteSplitRoutingDataSource();
        Map<Object, Object> targetDataSources = new HashMap<Object, Object>();
        List<String> slaveDataSourceNames = new ArrayList<String>();
        targetDataSources.put(ConstantPool.DATASOURCE_MASTER, masterDataSource);
        targetDataSources.put(ConstantPool.DATASOURCER_SLAVE, slaveDataSource);
        slaveDataSourceNames.add(ConstantPool.DATASOURCER_SLAVE);
        writeSplitRoutingDataSource.setTargetDataSources(targetDataSources);
        writeSplitRoutingDataSource.setDefaultTargetDataSource(masterDataSource);
        ReadOnlyConnectionAspect.setSlaveDataSourceNames(slaveDataSourceNames);
        return writeSplitRoutingDataSource;
    }

    /**
     * 主資料庫（寫資料庫）
     * @return
     */
    @Bean(name = "masterDataSource", destroyMethod = "close", initMethod = "init")
    @ConfigurationProperties(prefix = "spring.datasource.master")
    public DataSource masterDataSource() {
        System.out.println("主庫");
        return DataSourceBuilder.create().type(dataSourceType).build();
    }

    /** 
     * 從資料庫1（只讀資料庫）
     * @return 
     */  
    @Bean(name = "slaveDataSource")  
    @ConfigurationProperties(prefix = "spring.datasource.slave")  
    public DataSource slaveDataSource(){  
        System.out.println("從庫");
        return DataSourceBuilder.create().type(dataSourceType).build();  
    }  

    /**
     * 註冊ServletRegistrationBean
     * 
     * @return
     */
    @Bean
    public ServletRegistrationBean druidServlet() {
        ServletRegistrationBean reg = new ServletRegistrationBean();
        reg.setServlet(new StatViewServlet());
        reg.addUrlMappings("/druid/*");
        reg.addInitParameter("allow", ""); // 白名單
        return reg;
    }

    /**
     * 註冊FilterRegistrationBean
     * 
     * @return
     */
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        filterRegistrationBean.setFilter(new WebStatFilter());
        filterRegistrationBean.addUrlPatterns("/*");
        filterRegistrationBean.addInitParameter("exclusions", "*.js,*.gif,*.jpg,*.png,*.css,*.ico,/druid/*");
        filterRegistrationBean.addInitParameter("profileEnable", "true");
        filterRegistrationBean.addInitParameter("principalCookieName", "USER_COOKIE");
        filterRegistrationBean.addInitParameter("principalSessionName", "USER_SESSION");
        filterRegistrationBean.addInitParameter("DruidWebStatFilter", "/*");
        return filterRegistrationBean;
    }
}

這裡我們忽略了對資料庫連線池監控的使用者名稱密碼等配置，我們可以在專案中的許可權控制中配置，達到特定賬號許可權可以監控的效果。

5.路由


import com.center.constant.ConstantPool;

/**
 * 執行緒私有路由配置，用於ReadWriteSplitRoutingDataSource動態讀取配置
 * 
 * @Title: DbContextHolder.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
public class DbContextHolder {

    /**
     * 當前資料庫型別
     */
    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    /**
     * 設定資料庫型別
     * 
     * @param dbType
     */
    public static void setDbType(String dbType) {
        if (dbType == null)
            throw new NullPointerException();
        contextHolder.set(dbType);
    }

    /**
     * 獲取資料庫型別
     * 
     * @return
     */
    public static String getDbType() {
        return contextHolder.get() == null ? ConstantPool.DATASOURCE_MASTER : contextHolder.get();
    }

    /**
     * 清除資料庫型別
     */
    public static void clearDbType() {
        contextHolder.remove();
    }

}

6.動態資料來源

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
/**
 * 實現可動態路由的資料來源，在每次資料庫查詢操作前執行
 * @Title: ReadWriteSplitRoutingDataSource.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
public class ReadWriteSplitRoutingDataSource extends AbstractRoutingDataSource {

    @Override
    protected Object determineCurrentLookupKey() {
        return DbContextHolder.getDbType();
    }

}

7.只讀註解

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 只讀註解,用於標註方法的資料庫操作只走從庫
 * 
 * @Title: ReadOnlyConnection.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface ReadOnlyConnection {
}

8.只讀註解切面

package com.center.support.database;

import java.util.List;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import com.center.constant.ConstantPool;

/**
 * 動態資料來源繫結，指定只讀資料來源（從庫）
 * 
 * @Title: ReadOnlyConnectionAspect.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
@Aspect
@Component
@Order(5)
public class ReadOnlyConnectionAspect {

    /**
     * 從庫列表
     */
    private static List<String> slaveDataSourceNames = null;
    /**
     * 資料庫讀取次數
     */
    private static Integer count = 0;

    /**
     * @return the slaveDataSourceNames
     */
    public static List<String> getSlaveDataSourceNames() {
        return slaveDataSourceNames;
    }

    /**
     * @param slaveDataSourceNames
     *            the slaveDataSourceNames to set
     */
    public static void setSlaveDataSourceNames(List<String> slaveDataSourceNames) {
        ReadOnlyConnectionAspect.slaveDataSourceNames = slaveDataSourceNames;
    }

    /**
     * 切換到從庫
     *
     * @param proceedingJoinPoint
     * @param readOnlyConnection
     * @return
     * @throws Throwable
     */
    @Around("@annotation(readOnlyConnection)")
    public Object proceed(ProceedingJoinPoint proceedingJoinPoint, ReadOnlyConnection readOnlyConnection)
            throws Throwable {
        try {
            if (slaveDataSourceNames != null && slaveDataSourceNames.size() > 0) {
                DbContextHolder.setDbType(slaveDataSourceNames.get(count % slaveDataSourceNames.size()));
                count++;
            } else {
                DbContextHolder.setDbType(ConstantPool.DATASOURCER_SLAVE);
            }
            Object result = proceedingJoinPoint.proceed();
            return result;
        } finally {
            DbContextHolder.clearDbType();
        }
    }
}

9.測試，使用Spring Data JPA，其他同理

package com.test.service;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.backstage.domain.User;
import com.backstage.repository.UserRepository;
import com.template.db.ReadOnlyConnection;

/**
 * @Title: RWTest1.java
 * @Package com.test.service
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
@Service
public class RWTest1 {

    @Autowired
    private UserRepository userRepository;

    public List<User> findUser1() {
        return userRepository.findAll();
    }

    @ReadOnlyConnection
    public List<User> findUser2() {
        return userRepository.findAll();
    }

    /**
     * @return the userRepository
     */
    public UserRepository getUserRepository() {
        return userRepository;
    }

    /**
     * @param userRepository
     *            the userRepository to set
     */
    public void setUserRepository(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

}

從庫資料庫連線池

10.補充1（利用AOP和自定義註解指定特定的資料來源操作）

package com.center.support.database;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 指定使用的資料庫連線
 * @Title: AssignConnection.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
@Target({ ElementType.METHOD })
@Retention(RetentionPolicy.RUNTIME)
public @interface AssignConnection {

    /**
     * 指定使用的資料來源的key
     * 在config中dataSource需要配置該連線池名稱
     * targetDataSources.put(TemplateConstantPool.DATASOURCE_MASTER, dataSourceMaster);
     * @return 資料來源key
     */
    String value();

}

package com.center.support.database;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

/**
 * 動態資料來源繫結，切換至指定資料來源
 * 
 * @Title: AssignConnectionAspect.java
 * @Package com.template.db
 * @Description: TODO
 * @author Autumn、
 * @date 2018年8月5日
 */
@Aspect
@Component
@Order(10)
public class AssignConnectionAspect {

    /**
     * 切換到從庫
     *
     * @param proceedingJoinPoint
     * @param readOnlyConnection
     * @return
     * @throws Throwable
     */
    @Around("@annotation(assignConnection)")
    public Object proceed(ProceedingJoinPoint proceedingJoinPoint, AssignConnection assignConnection) throws Throwable {
        try {
            DbContextHolder.setDbType(assignConnection.value());
            Object result = proceedingJoinPoint.proceed();
            return result;
        } finally {
            DbContextHolder.clearDbType();
        }
    }

}

11.補充2（Druid與Spring關聯，配置Spring監控）

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">

    <!-- 配置_Druid和Spring關聯監控配置 -->
    <bean id="druid-stat-interceptor"
        class="com.alibaba.druid.support.spring.stat.DruidStatInterceptor"></bean>

    <!-- 方法名正則匹配攔截配置 -->
    <bean id="druid-stat-pointcut" class="org.springframework.aop.support.JdkRegexpMethodPointcut"
        scope="prototype">
        <property name="patterns">
            <list>
                <value>com.center.*</value>
            </list>
        </property>
    </bean>

    <aop:config proxy-target-class="true">
        <aop:advisor advice-ref="druid-stat-interceptor"
            pointcut-ref="druid-stat-pointcut" />
    </aop:config>

</beans>

12.補充3（參考資料）

相關推薦

SpringBoot進行MySql動態資料來源配置實現讀寫分離（連線池Druid）

1.簡介 前面使用C3P0連線池進行過資料庫的讀寫分離的實驗，今天換一下資料庫連線池改造一下，原理還是和原來的一樣。 Druid是阿里出品，淘寶和支付寶專用資料庫連線池，但它不僅僅是一個數據庫連線池，它還包含一個ProxyDriver，一系列內建的JDBC元

Spring Boot + Mybatis 多資料來源配置實現讀寫分離

本文來自網易雲社群作者：王超應用場景：專案中有一些報表統計與查詢功能，對資料實時性要求不高，因此考慮對報表的統計與查詢去操作slave db，減少對master的壓力。根據網上多份資料測試發現總是使用master資料來源，無法切換到slave，經過多次除錯修改現已完美通過，現

mysql主從復制及讀寫分離（附安裝包）

download inux libaio script 關閉防火墻 安裝包 useradd tor 數據 實驗目的：在實際生產環境中，如果對數據庫的讀和寫都在同一個數據庫服務器中操作，無論在安全性、高可用性，還是高並發等各個方面都是完全不能滿足實際需求的，因此，一般需要通過

SSM整合系列之 配置多資料來源並實現手動切換資料來源可實現讀寫分離

摘要：在之前的開發中有很多場景用到了多資料來源的情況，如在做資料冷熱遷移的時候，將冷資料遷移到另一個庫，查詢冷資料時需要切換資料庫；在和天貓京東等電商對接時，因為有多套系統在同時使用，在客戶授權時，需要根據客戶使用的版本，儲存到對應的資料庫中。基於此，在這裡呢簡單實現一個SSM系統的多資

docker配置mysql主從與django實現讀寫分離

一、搭建主從mysql環境 1 下載mysql映象 docker pull mysql:5.7 2 執行剛下載的mysql映象檔案 # 執行該命令之前可以使用`docker images`是否下載成功 docker run -p 3307:3306 --name mysql-master -v /mysql

使用Spring實現讀寫分離（ MySQL實現主從復制）

sign eve replicat win [] 做了 用戶名 指定 ati 1. 背景 我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大，有一個思路就是說采用數據庫集群的方案， 其中一個是主庫，負責寫入數據，我們稱之為：寫庫； 其它都是從庫，

使用Spring+MySql實現讀寫分離（二）spring整合多數據庫

ont 依據 xml配置 實現 整合 配置 item 匹配 mic 緊接著上一章，因為現在做的項目還是以spring為主要的容器管理框架，所以寫以下spring如何整合多個數據源。 1. 背景 我們一般應用對數據庫而言都是“讀多寫少”，也就說對數據庫讀取數據的壓力比較大

kylin跨集群配置實現讀寫分離

KYLIN HBASE HIVE 讀寫分離 跨集群 社區提供的讀寫分離架構圖如下：通過架構圖可以看到Kylin會訪問兩個集群的HDFS，建議兩個集群的NameService務必不能相同，尤其是集群啟用NameNode HA時，相同的NameService會導致組件在跨集群訪問HDFS時因無

Linux 使用Mycat實現讀寫分離（基於Mysql的讀寫分離）

各位同學大家好，今天給大家分享一下用Mycat進行資料庫的讀寫分離，本篇文章是基於上一篇的mysql主從複製。Linux上實現Mysql的主從複製(為Mycat讀寫分離作準備) 在上一篇文章中，我們在兩個伺服器使用同版本的作業系統和mysql： 伺服器1：centos7.3，mysql5.6 伺服器

MySQL中介軟體proxysql實現讀寫分離

環境說明: IP 角色 應用 平臺 192.168.161.96 讀寫分離解析主機 proxysql rhel7.4 19

MySQL主從複製 + Mycat實現讀寫分離

說明：兩臺MySQL伺服器都是使用CentOS6.5系統，MySQL版本為mysql-5.7.17 MySQL一主一被實現主從複製 注意：寫包括insert，delete，update 操作；讀只有select其他操作由主master的二進位制檔案決定。 一．在19

CentOS7，MySQL主從配置和讀寫分離（MySQL主從、讀寫分離、分散式、資料庫讀寫分離、主從配置）

一、實驗目標搭建兩臺MySQL伺服器，一臺作為主伺服器，一臺作為從伺服器，主伺服器進行寫操作，從伺服器進行讀操作。二、測試環境主資料庫： CentOS7， MySQL15.1 ， 192.168.1.233從資料庫： CentOS7， MySQL15.1 ， 192.168.

使用Spring實現讀寫分離（ MySQL實現主從複製）

1.  背景 我們一般應用對資料庫而言都是“讀多寫少”，也就說對資料庫讀取資料的壓力比較大，有一個思路就是說採用資料庫叢集的方案， 其中一個是主庫，負責寫入資料，我們稱之為：寫庫； 其它都是從庫，負責讀取資料，我們稱之為：讀庫； 那麼，對我們的要求是： 1、讀庫和寫庫的資

使用Yii2實現讀寫分離（MySQL主從資料庫）

讀寫分離（Read/Write Splitting）。 簡介 資料庫讀寫分離是在網站遇到效能瓶頸的時候最先考慮優化的步驟，那麼yii2是如何做資料庫讀寫分離的呢？本節教程來給大家普及一下yii2的資料庫讀寫分離配置。 兩個伺服器的資料同步是讀

使用spring實現讀寫分離（mysql主從複製）五：一主多從的實現

很多實際使用場景下都是採用“一主多從”的架構的，使用輪詢演算法實現，目前只需要修改DynamicDataSource即可。   1.1. 實現 import java.lang.reflect.Field; import java.util.ArrayList; impo

MySQL之——基於Amoeba實現讀寫分離

今天，我們繼續MySQL的話題，今天為大家帶來一篇基於Amoeba實現MySQL讀寫分離的方案文章，好我們直接進入今天的正題吧。 一、伺服器規劃 主機名 IP地址 節點 liuyazhuang152 192.168.0.152 amoeba liuyazhuang153

Spring AOP 實現讀寫分離（MySQL實現主從複製）

1、Mysql的主從複製      1.1 mysql主(稱master)從(稱slave)複製的原理 1、master將資料改變記錄到二進位制日誌(binarylog)中,也即是配置檔案log-bin指定的檔案(這些記錄叫做二進位制日誌事件，binary log eve

Mycat實現讀寫分離（一）

mycatMycat介紹Mycat是一個國產中間件產品，作用在應用層和數據庫之間架橋，使應用通過MyCat來對後端數據庫進行管理，是一款國人自主的開源的中間件產品。算是比較優秀的一款，前身是阿裏公司在維護，很多公司也慢慢的在嘗試接入這個產品，但不得不說官方文檔似乎做的不太友好。至於為什麽選擇MyCat可能只有

springboot mysql 多資料來源配置，可實現讀寫分離

1、程式碼實現 import com.zaxxer.hikari.HikariDataSource; import javas

SSM整合系列之 配置多資料來源 利用AOP動態切換資料來源 實現讀寫分離

摘要：在開發的專案中大都都會使用讀寫分離的技術，本人目前開發的專案接觸到的都是主從複製(一主一從)，就是一個Master資料庫，一個Slave資料庫。主庫負責資料插入、更新和實時資料查詢，從庫庫負責非實時資料查詢。在實際專案應用中，都是讀多寫少，而讀取資料通常比較複雜而且耗時，SQL語句