SpringBoot讀寫分離組件開發詳解
作者：Springboot實戰案例錦集
一寫多讀，讀可以任意配置多個，默認都是從寫庫中進行操作，只有符合條件的方法（指定的目標方法或者標有指定注解的方法才會從讀庫中操作）。獨立打成一個jar包放入本地倉庫。
實現目標：一寫多讀，讀可以任意配置多個，默認都是從寫庫中進行操作，只有符合條件的方法（指定的目標方法或者標有指定注解的方法才會從讀庫中操作）。獨立打成一個jar包放入本地倉庫。
實現原理：通過aop。
pom.xml配置文件
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>application.yml配置文件
pack:
datasource:
pointcut: execution(public * net.greatsoft.service.base.*.*(..)) || execution(public * net.greatsoft.service.xxx.*.*(..))
master:
driverClassName: oracle.jdbc.driver.OracleDriver
jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl
username: test
password: test
minimumIdle: 10
maximumPoolSize: 200
autoCommit: true
idleTimeout: 30000
poolName: MbookHikariCP
maxLifetime: 1800000
connectionTimeout: 30000
connectionTestQuery: SELECT 1 FROM DUAL
slaves:
- driverClassName: oracle.jdbc.driver.OracleDriver
jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl
username: dc
password: dc
minimumIdle: 10
maximumPoolSize: 200
autoCommit: true
idleTimeout: 30000
poolName: MbookHikariCP
maxLifetime: 1800000
connectionTimeout: 30000
connectionTestQuery: SELECT 1 FROM DUAL
- driverClassName: oracle.jdbc.driver.OracleDriver
jdbcUrl: jdbc:oracle:thin:@10.100.102.113:1521/orcl
username: empi
password: empi
minimumIdle: 10
maximumPoolSize: 200
autoCommit: true
idleTimeout: 30000
poolName: MbookHikariCP
maxLifetime: 1800000
connectionTimeout: 30000
connectionTestQuery: SELECT 1 FROM DUALpointcut：定義切點，那些方法是需要攔截（從讀庫中操作）。
master：寫庫配置。
slaves：讀庫配置（List集合）。
屬性配置類
@Component
@ConfigurationProperties(prefix = "pack.datasource")
public class RWDataSourceProperties {
private String pointcut ;
private HikariConfig master ;
private List<HikariConfig> slaves = new ArrayList<>();
}讀寫配置類
public class RWConfig {
private static Logger logger = LoggerFactory.getLogger(RWConfig.class) ;
@Bean
public HikariDataSource masterDataSource(RWDataSourceProperties rwDataSourceProperties) {
return new HikariDataSource(rwDataSourceProperties.getMaster()) ;
}
@Bean
public List<HikariDataSource> slaveDataSources(RWDataSourceProperties rwDataSourceProperties) {
List<HikariDataSource> lists = new ArrayList<>() ;
for(HikariConfig config : rwDataSourceProperties.getSlaves()) {
lists.add(new HikariDataSource(config)) ;
}
return lists ;
}
@Bean
@Primary
@DependsOn({"masterDataSource", "slaveDataSources"})
public AbstractRoutingDataSource routingDataSource(@Qualifier("masterDataSource")DataSource masterDataSource,
@Qualifier("slaveDataSources")List<HikariDataSource> slaveDataSources) {
BaseRoutingDataSource ds = new BaseRoutingDataSource() ;
Map<Object, Object> targetDataSources = new HashMap<>(2) ;
targetDataSources.put("master", masterDataSource) ;
for (int i = 0; i < slaveDataSources.size(); i++) {
targetDataSources.put("slave-" + i, slaveDataSources.get(i)) ;
}
ds.setDefaultTargetDataSource(masterDataSource) ;
ds.setTargetDataSources(targetDataSources) ;
return ds ;
}
}數據源路由
public class BaseRoutingDataSource extends AbstractRoutingDataSource {
@Resource
private DataSourceHolder holder;
@Override
protected Object determineCurrentLookupKey() {
return holder.get() ;
}
}public class DataSourceHolder {
private ThreadLocal<Integer> context = new ThreadLocal<Integer>() {
@Override
protected Integer initialValue() {
return 0 ;
}
};
@Resource
private BaseSlaveLoad slaveLoad ;
public String get() {
Integer type = context.get() ;
return type == null || type == 0 ? "master" : "slave-" + slaveLoad.load() ;
}
public void set(Integer type) {
context.set(type) ;
}
}通過aop動態設置context的內容值，0為從寫庫中操作，其它的都在讀庫中操作。
BaseSlaveLoad類為到底從那個讀庫中選取的一個算法類，默認實現使用的是輪詢算法。
public interface BaseSlaveLoad {
int load() ;
}
public abstract class AbstractSlaveLoad implements BaseSlaveLoad {
@Resource
protected List<HikariDataSource> slaveDataSources ;
}這里定義一個抽象類注入了讀庫列表，所有的實現類從該類中繼承即可。
public class PollingLoad extends AbstractSlaveLoad {
private int index = 0 ;
private int size = 1 ;
@PostConstruct
public void init() {
size = slaveDataSources.size() ;
}
@Override
public int load() {
int n = index ;
synchronized (this) {
index = (++index) % size ;
}
return n ;
}
}配置成Bean
@Bean
@ConditionalOnMissingBean
public BaseSlaveLoad slaveLoad() {
return new PollingLoad() ;
}
@Bean
public DataSourceHolder dataSourceHolder() {
return new DataSourceHolder() ;
}數據源AOP
public class DataSourceAspect implements MethodInterceptor {
private DataSourceHolder holder ;
public DataSourceAspect(DataSourceHolder holder) {
this.holder = holder ;
}
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
Method method = invocation.getMethod() ;
String methodName = method.getName() ;
SlaveDB slaveDB = method.getAnnotation(SlaveDB.class) ;
if (slaveDB == null) {
slaveDB = method.getDeclaringClass().getAnnotation(SlaveDB.class) ;
}
if (methodName.startsWith("find")
|| methodName.startsWith("get")
|| methodName.startsWith("query")
|| methodName.startsWith("select")
|| methodName.startsWith("list")
|| slaveDB != null) {
holder.set(1) ;
} else {
holder.set(0) ;
}
return invocation.proceed();
}
}應該切點需要動態配置，所以這里采用spring aop的方式來配置
@Bean
public AspectJExpressionPointcutAdvisor logAdvisor(RWDataSourceProperties props, DataSourceHolder holder) {
AspectJExpressionPointcutAdvisor advisor = new AspectJExpressionPointcutAdvisor() ;
logger.info("執行表達式：{}", props.getPointcut()) ;
advisor.setExpression(props.getPointcut()) ;
advisor.setAdvice(new DataSourceAspect(holder)) ;
return advisor ;
}Enable開啟功能
public class RWImportSelector implements ImportSelector {
@Override
public String[] selectImports(AnnotationMetadata importingClassMetadata) {
return new String[] {RWConfig.class.getName()} ;
}
}這里的RWConfig為我們上面的配置類
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Documented
@Import({RWImportSelector.class})
public @interface EnableRW {
}
@Documented
@Retention(RUNTIME)
@Target({ TYPE, METHOD })
public @interface SlaveDB {
}有@SlaveDB的注解方法或類都會從讀庫中操作。
到此讀寫分離組件開發完成。
- 打包安裝到本地倉庫
mvn install -Dmaven.test.skip=true新建base-web項目
引入依賴
<dependency>
<groupId>com.pack</groupId>
<artifactId>xg-component-rw</artifactId>
<version>1.0.0</version>
</dependency>啟動類添加注解開啟讀寫分離功能
@SpringBootApplication
@EnableRW
public class BaseWebApplication {
public static void main(String[] args) {
SpringApplication.run(BaseWebApplication.class, args);
}
}測試：
第一次查詢：
圖片
第二次查詢：
圖片
為了區別兩個從庫設置不同的數據
這里是寫庫
責任編輯：武曉燕
來源：
實戰案例錦集
