Tagged articles
DataSource Routing
15 articles · Page 1 of 1
This tutorial demonstrates how to implement dynamic data source switching in Spring Boot using ThreadLocal and AbstractRoutingDataSource, covering configuration, annotation-based routing via AOP, and runtime data source registration from a database.
AOPAbstractRoutingDataSourceDataSource Routing
0 likes · 17 min read

This article explains why read‑write separation is essential for high‑concurrency applications, discusses its limitations, and provides a step‑by‑step Spring Boot implementation—including datasource configuration, routing logic, context management, custom annotations, AOP handling, and usage examples—complete with code snippets and diagrams.
AOPDataSource RoutingJava
0 likes · 11 min read

This article explains how to implement database read‑write separation in a Spring Boot application by configuring master and slave data sources, creating a routing datasource, managing thread‑local context, and using an AOP‑based annotation to switch between read and write operations.
AOPDataSource RoutingJava
0 likes · 10 min read

This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master and slave data sources, implementing a routing DataSource, managing context with ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to switch between read and write operations.
AOPDataSource RoutingJava
0 likes · 11 min read

This article explains the concept of database read‑write splitting, discusses its limitations, and provides a step‑by‑step guide with Spring Boot code to configure master‑slave data sources, implement dynamic routing, context handling, custom annotations, and AOP for seamless switching.
DataSource RoutingJavaMaster‑Slave
0 likes · 11 min read

This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing datasource, managing context with ThreadLocal, and using custom annotations with AOP to switch between read and write databases at runtime.
AOPDataSource RoutingJava
0 likes · 10 min read

This article explains how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, managing routing keys with ThreadLocal, and using AOP to automatically switch between master and slave databases for different CRUD operations.
AOPDataSource RoutingJava
0 likes · 12 min read

This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, covering the concepts of master‑slave architecture, configuration of multiple data sources, routing logic with AbstractRoutingDataSource, context management, custom annotations, AOP handling, and practical usage examples with code snippets.
AOPDataSource RoutingJava
0 likes · 11 min read

This article explains how to implement read‑write separation in Spring Boot by extending AbstractRoutingDataSource, using ThreadLocal for key storage, and creating AOP aspects that prioritize datasource switching over transaction management.
AOPAbstractRoutingDataSourceDataSource Routing
0 likes · 9 min read

This article explains how to implement database read‑write splitting in a Spring Boot application by configuring master and slave data sources, creating a dynamic routing datasource, using a ThreadLocal context holder, defining a custom annotation with AOP for automatic switching, and demonstrates usage with sample code.
AOPDataSource RoutingJava
0 likes · 11 min read

This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing data source, managing context with ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to dynamically switch between read and write databases.
AOPDataSource RoutingJava
0 likes · 10 min read

This article explains how to achieve database read‑write separation in high‑concurrency scenarios using Spring Boot, Druid connection pool, and MySQL, covering master‑slave data source configuration, routing via AbstractRoutingDataSource, context holder management, custom annotations, AOP switching, and usage examples with code snippets.
AOPDataSource RoutingJava
0 likes · 11 min read

This article explains how to implement database read‑write separation in a Spring Boot application using Druid connection pools, custom DataSource routing, a ThreadLocal context holder, and AOP‑based annotations, providing step‑by‑step configuration and usage examples with full Java code.
DataSource RoutingMyBatisRead-Write Separation
0 likes · 11 min read

This article demonstrates how to implement read/write splitting in a Spring Boot application by configuring multiple data sources, using AbstractRoutingDataSource for dynamic routing, and applying AOP and custom annotations to direct read operations to slave databases and write operations to the master, with full Maven and MyBatis setup.
AOPAbstractRoutingDataSourceDataSource Routing
0 likes · 17 min read

This article demonstrates how to achieve read‑write splitting in a Spring Boot application by configuring multiple data sources, creating a custom AbstractRoutingDataSource, using AOP to switch between master and slave databases, and integrating the routing data source with MyBatis for transparent database operations.
AOPAbstractRoutingDataSourceDataSource Routing
0 likes · 15 min read
