【Spring】Spring如何实现多数据源读写分离？这是我看过最详细的一篇！！(1)

最新推荐文章于 2024-05-17 14:51:39 发布

开摆

最新推荐文章于 2024-05-17 14:51:39 发布

阅读量403

点赞数 5

分类专栏：程序员文章标签： spring java 后端

本文链接：https://blog.csdn.net/2303_77877769/article/details/137910548

版权

程序员专栏收录该内容

746 篇文章 0 订阅

订阅专栏

定义动态数据源，实现通过集成Spring提供的AbstractRoutingDataSource，只需要实现determineCurrentLookupKey方法即可
由于DynamicDataSource是单例的，线程不安全的，所以采用ThreadLocal保证线程安全，由DynamicDataSourceHolder完成。
@author binghe

public class DynamicDataSource extends AbstractRoutingDataSource{

@Override

protected Object determineCurrentLookupKey() {

// 使用DynamicDataSourceHolder保证线程安全，并且得到当前线程中的数据源key

return DynamicDataSourceHolder.getDataSourceKey();

}

DynamicDataSourceHolder

/**

使用ThreadLocal技术来记录当前线程中的数据源的key
@author binghe

public class DynamicDataSourceHolder {

//写库对应的数据源key

private static final String MASTER = “master”;

//读库对应的数据源key

private static final String SLAVE = “slave”;

//使用ThreadLocal记录当前线程的数据源key

private static final ThreadLocal holder = new ThreadLocal();

/**

设置数据源key
@param key

public static void putDataSourceKey(String key) {

holder.set(key);

}

/**

获取数据源key
@return

public static String getDataSourceKey() {

return holder.get();

}

/**

标记写库

public static void markMaster(){

putDataSourceKey(MASTER);

}

/**

标记读库

public static void markSlave(){

putDataSourceKey(SLAVE);

}

DataSourceAspect

import org.apache.commons.lang3.StringUtils;

import org.aspectj.lang.JoinPoint;

/**

定义数据源的AOP切面，通过该Service的方法名判断是应该走读库还是写库
@author binghe

public class DataSourceAspect {

/**

在进入Service方法之前执行
@param point 切面对象

public void before(JoinPoint point) {

// 获取到当前执行的方法名

String methodName = point.getSignature().getName();

if (isSlave(methodName)) {

// 标记为读库

DynamicDataSourceHolder.markSlave();

} else {

// 标记为写库

DynamicDataSourceHolder.markMaster();

}

/**

判断是否为读库
@param methodName
@return

private Boolean isSlave(String methodName) {

// 方法名以query、find、get开头的方法名走从库

return StringUtils.startsWithAny(methodName, “query”, “find”, “get”);

}

配置2个数据源

jdbc.properties

jdbc.master.driver=com.mysql.jdbc.Driver

jdbc.master.url=jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true

jdbc.master.username=root

jdbc.master.password=123456

jdbc.slave01.driver=com.mysql.jdbc.Driver

jdbc.slave01.url=jdbc:mysql://127.0.0.1:3307/test?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true

jdbc.slave01.username=root

jdbc.slave01.password=123456

定义连接池

<bean id=“masterDataSource” class=“com.jolbox.bonecp.BoneCPDataSource”

destroy-method=“close”>

<bean id=“slave01DataSource” class=“com.jolbox.bonecp.BoneCPDataSource”

destroy-method=“close”>

定义DataSource

配置事务管理以及动态切换数据源切面

定义事务管理器

<bean id=“transactionManager”

class=“org.springframework.jdbc.datasource.DataSourceTransactionManager”>

定义事务策略

<tx:advice id=“txAdvice” transaction-manager=“transactionManager”>

tx:attributes

<tx:method name=“query*” read-only=“true” />

<tx:method name=“find*” read-only=“true” />

<tx:method name=“get*” read-only=“true” />

<tx:method name=“save*” propagation=“REQUIRED” />

<tx:method name=“update*” propagation=“REQUIRED” />

<tx:method name=“delete*” propagation=“REQUIRED” />

<tx:method name=“*” />

</tx:attributes>

</tx:advice>

定义切面

aop:config

<aop:pointcut id=“txPointcut” expression=“execution(* xx.xxx.xxxxxxx.service..(…))” />

<aop:advisor advice-ref=“txAdvice” pointcut-ref=“txPointcut”/>

<aop:aspect ref=“dataSourceAspect” order=“-9999”>

<aop:before method=“before” pointcut-ref=“txPointcut” />

</aop:aspect>

</aop:config>

改进切面实现，使用事务策略规则匹配

之前的实现我们是将通过方法名匹配，而不是使用事务策略中的定义，我们使用事务管理策略中的规则匹配。

改进后的配置

改进后的实现

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import org.aspectj.lang.JoinPoint;

import org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource;

import org.springframework.transaction.interceptor.TransactionAttribute;

import org.springframework.transaction.interceptor.TransactionAttributeSource;

import org.springframework.transaction.interceptor.TransactionInterceptor;

import org.springframework.util.PatternMatchUtils;

import org.springframework.util.ReflectionUtils;

/**

定义数据源的AOP切面，该类控制了使用Master还是Slave。
如果事务管理中配置了事务策略，则采用配置的事务策略中的标记了ReadOnly的方法是用Slave，其它使用Master。
如果没有配置事务管理的策略，则采用方法名匹配的原则，以query、find、get开头方法用Slave，其它用Master。
@author binghe

public class DataSourceAspect {

private List slaveMethodPattern = new ArrayList();

private static final String[] defaultSlaveMethodStart = new String[]{ “query”, “find”, “get” };

private String[] slaveMethodStart;

/**

读取事务管理中的策略
@param txAdvice
@throws Exception

@SuppressWarnings(“unchecked”)

public void setTxAdvice(TransactionInterceptor txAdvice) throws Exception {

if (txAdvice == null) {

// 没有配置事务管理策略

return;

}

//从txAdvice获取到策略配置信息

TransactionAttributeSource transactionAttributeSource = txAdvice.getTransactionAttributeSource();

if (!(transactionAttributeSource instanceof NameMatchTransactionAttributeSource)) {

return;

}

//使用反射技术获取到NameMatchTransactionAttributeSource对象中的nameMap属性值

NameMatchTransactionAttributeSource matchTransactionAttributeSource = (NameMatchTransactionAttributeSource) transactionAttributeSource;

Field nameMapField = ReflectionUtils.findField(NameMatchTransactionAttributeSource.class, “nameMap”);

nameMapField.setAccessible(true); //设置该字段可访问

//获取nameMap的值

Map<String, TransactionAttribute> map = (Map<String, TransactionAttribute>) nameMapField.get(matchTransactionAttributeSource);

//遍历nameMap

for (Map.Entry<String, TransactionAttribute> entry : map.entrySet()) {

if (!entry.getValue().isReadOnly()) {//判断之后定义了ReadOnly的策略才加入到slaveMethodPattern

continue;

}

slaveMethodPattern.add(entry.getKey());

}

/**

在进入Service方法之前执行
@param point 切面对象

public void before(JoinPoint point) {

// 获取到当前执行的方法名

String methodName = point.getSignature().getName();

boolean isSlave = false;

if (slaveMethodPattern.isEmpty()) {

// 当前Spring容器中没有配置事务策略，采用方法名匹配方式

isSlave = isSlave(methodName);

} else {

// 使用策略规则匹配

for (String mappedName : slaveMethodPattern) {

if (isMatch(methodName, mappedName)) {

isSlave = true;

break;

}

if (isSlave) {

// 标记为读库

DynamicDataSourceHolder.markSlave();

} else {

// 标记为写库

DynamicDataSourceHolder.markMaster();

}

/**

判断是否为读库
@param methodName
@return

private Boolean isSlave(String methodName) {

// 方法名以query、find、get开头的方法名走从库

return StringUtils.startsWithAny(methodName, getSlaveMethodStart());

}

/**

通配符匹配
Return if the given method name matches the mapped name.
The default implementation checks for “xxx*”, “*xxx” and “xxx” matches, as well as direct
equality. Can be overridden in subclasses.
@param methodName the method name of the class
@param mappedName the name in the descriptor
@return if the names match
@see org.springframework.util.PatternMatchUtils#simpleMatch(String, String)

protected boolean isMatch(String methodName, String mappedName) {

return PatternMatchUtils.simpleMatch(mappedName, methodName);

}

/**

用户指定slave的方法名前缀
@param slaveMethodStart

public void setSlaveMethodStart(String[] slaveMethodStart) {

this.slaveMethodStart = slaveMethodStart;

}

public String[] getSlaveMethodStart() {

if(this.slaveMethodStart == null){

// 没有指定，使用默认

return defaultSlaveMethodStart;

}

return slaveMethodStart;

}

一主多从的实现

很多实际使用场景下都是采用“一主多从”的架构的，所有我们现在对这种架构做支持，目前只需要修改DynamicDataSource即可。

实现

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.List;

import java.util.Map;

import java.util.concurrent.atomic.AtomicInteger;

import javax.sql.DataSource;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

import org.springframework.util.ReflectionUtils;

/**

定义动态数据源，实现通过集成Spring提供的AbstractRoutingDataSource，只需要实现determineCurrentLookupKey方法即可
由于DynamicDataSource是单例的，线程不安全的，所以采用ThreadLocal保证线程安全，由DynamicDataSourceHolder完成。
@author binghe

public class DynamicDataSource extends AbstractRoutingDataSource {

private static final Logger LOGGER = LoggerFactory.getLogger(DynamicDataSource.class);

private Integer slaveCount;

// 轮询计数,初始为-1,AtomicInteger是线程安全的

private AtomicInteger counter = new AtomicInteger(-1);

// 记录读库的key

private List slaveDataSources = new ArrayList(0);

@Override

protected Object determineCurrentLookupKey() {

// 使用DynamicDataSourceHolder保证线程安全，并且得到当前线程中的数据源key

if (DynamicDataSourceHolder.isMaster()) {

Object key = DynamicDataSourceHolder.getDataSourceKey();