Spring+MyBatis數據讀寫分離的實例詳解
本文介紹了Spring Boot + MyBatis讀寫分離，有需要了解Spring+MyBatis讀寫分離的朋友可參考。想了解更多相關信息請持續(xù)關注我們應屆畢業(yè)生考試網!
其最終實現功能：
1.默認更新操作都使用寫數據源
2.讀操作都使用slave數據源
3.特殊設置：可以指定要使用的數據源類型及名稱（如果有名稱，則會根據名稱使用相應的數據源）
其實現原理如下：
1.通過Spring AOP對dao層接口進行攔截，并對需要指定數據源的接口在ThradLocal中設置其數據源類型及名稱
2.通過MyBatsi的插件，對根據更新或者查詢操作在ThreadLocal中設置數據源（dao層沒有指定的'情況下）
3.繼承AbstractRoutingDataSource類。
在此直接寫死使用HikariCP作為數據源
其實現步驟如下：
1.定義其數據源配置文件并進行解析為數據源
2.定義AbstractRoutingDataSource類及其它注解
3.定義Aop攔截
4.定義MyBatis插件
5.整合在一起
1.配置及解析類
其配置參數直接使用HikariCP的配置，其具體參數可以參考HikariCP。
在此使用yaml格式，名稱為datasource.yaml,內容如下：
dds:
write:
jdbcUrl: jdbc:mysql://localhost:3306/order
password: liu123
username: root
maxPoolSize: 10
minIdle: 3
poolName: master
read:
- jdbcUrl: jdbc:mysql://localhost:3306/test
password: liu123
username: root
maxPoolSize: 10
minIdle: 3
poolName: slave1
- jdbcUrl: jdbc:mysql://localhost:3306/test2
password: liu123
username: root
maxPoolSize: 10
minIdle: 3
poolName: slave2
定義該配置所對應的Bean，名稱為DBConfig,內容如下：
@Component
@ConfigurationProperties(locations = "classpath:datasource.yaml", prefix = "dds")
public class DBConfig {
private List<HikariConfig> read;
private HikariConfig write;
public List<HikariConfig> getRead() {
return read;
}
public void setRead(List<HikariConfig> read) {
this.read = read;
}
public HikariConfig getWrite() {
return write;
}
public void setWrite(HikariConfig write) {
this.write = write;
}
}
把配置轉換為DataSource的工具類，名稱：DataSourceUtil，內容如下：
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import javax.sql.DataSource;
import java.util.ArrayList;
import java.util.List;
public class DataSourceUtil {
public static DataSource getDataSource(HikariConfig config) {
return new HikariDataSource(config);
}
public static List<DataSource> getDataSource(List<HikariConfig> configs) {
List<DataSource> result = null;
if (configs != null && configs.size() > 0) {
result = new ArrayList<>(configs.size());
for (HikariConfig config : configs) {
result.add(getDataSource(config));
}
} else {
result = new ArrayList<>(0);
}
return result;
}
}
2.注解及動態(tài)數據源
定義注解@DataSource，其用于需要對個別方法指定其要使用的數據源（如某個讀操作需要在master上執(zhí)行，但另一讀方法b需要在讀數據源的具體一臺上面執(zhí)行）
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface DataSource {
/**
* 類型，代表是使用讀還是寫
* @return
*/
DataSourceType type() default DataSourceType.WRITE;
/**
* 指定要使用的DataSource的名稱
* @return
*/
String name() default "";
}
定義數據源類型，分為兩種：READ,WRITE，內容如下：
public enum DataSourceType {
READ, WRITE;
}
定義保存這此共享信息的類DynamicDataSourceHolder，在其中定義了兩個ThreadLocal和一個map，holder用于保存當前線程的數據源類型（讀或者寫），pool用于保存數據源名稱（如果指定），其內容如下：
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class DynamicDataSourceHolder {
private static final Map<String, DataSourceType> cache = new ConcurrentHashMap<>();
private static final ThreadLocal<DataSourceType> holder = new ThreadLocal<>();
private static final ThreadLocal<String> pool = new ThreadLocal<>();
public static void putToCache(String key, DataSourceType dataSourceType) {
cache.put(key,dataSourceType);
}
public static DataSourceType getFromCach(String key) {
return cache.get(key);
}
public static void putDataSource(DataSourceType dataSourceType) {
holder.set(dataSourceType);
}
public static DataSourceType getDataSource() {
return holder.get();
}
public static void putPoolName(String name) {
if (name != null && name.length() > 0) {
pool.set(name);
}
}
public static String getPoolName() {
return pool.get();
}
public static void clearDataSource() {
holder.remove();
pool.remove();
}
}
動態(tài)數據源類為DynamicDataSoruce,其繼承自AbstractRoutingDataSource，可以根據返回的key切換到相應的數據源，其內容如下：
import com.zaxxer.hikari.HikariDataSource;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;
import javax.sql.DataSource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ThreadLocalRandom;
public class DynamicDataSource extends AbstractRoutingDataSource {
private DataSource writeDataSource;
private List<DataSource> readDataSource;
private int readDataSourceSize;
private Map<String, String> dataSourceMapping = new ConcurrentHashMap<>();
@Override
public void afterPropertiesSet() {
if (this.writeDataSource == null) {
throw new IllegalArgumentException("Property 'writeDataSource' is required");
}
setDefaultTargetDataSource(writeDataSource);
Map<Object, Object> targetDataSource = new HashMap<>();
targetDataSource.put(DataSourceType.WRITE.name(), writeDataSource);
String poolName = ((HikariDataSource)writeDataSource).getPoolName();
if (poolName != null && poolName.length() > 0) {
dataSourceMapping.put(poolName,DataSourceType.WRITE.name());
}
if (this.readDataSource == null) {
readDataSourceSize = 0;
} else {
for (int i = 0; i < readDataSource.size(); i++) {
targetDataSource.put(DataSourceType.READ.name() + i, readDataSource.get(i));
poolName = ((HikariDataSource)readDataSource.get(i)).getPoolName();
if (poolName != null && poolName.length() > 0) {
dataSourceMapping.put(poolName,DataSourceType.READ.name() + i);
}
}
readDataSourceSize = readDataSource.size();
}
setTargetDataSources(targetDataSource);
super.afterPropertiesSet();
}
@Override
protected Object determineCurrentLookupKey() {
DataSourceType dataSourceType = DynamicDataSourceHolder.getDataSource();
String dataSourceName = null;
if (dataSourceType == null ||dataSourceType == DataSourceType.WRITE || readDataSourceSize == 0) {
dataSourceName = DataSourceType.WRITE.name();
} else {
String poolName = DynamicDataSourceHolder.getPoolName();
if (poolName == null) {
int idx = ThreadLocalRandom.current().nextInt(0, readDataSourceSize);
dataSourceName = DataSourceType.READ.name() + idx;
} else {
dataSourceName = dataSourceMapping.get(poolName);
}
}
DynamicDataSourceHolder.clearDataSource();
return dataSourceName;
}
public void setWriteDataSource(DataSource writeDataSource) {
this.writeDataSource = writeDataSource;
}
public void setReadDataSource(List<DataSource> readDataSource) {
this.readDataSource = readDataSource;
}
}