0 views collected around this technical thread.
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.
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.
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.
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.
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.
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.
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.
This article explains how to achieve read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, routing with AbstractRoutingDataSource, managing context via ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to switch databases at runtime.
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.
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.
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.
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.