This article explains MySQL master‑slave replication, covering its purpose, common topology patterns, the data flow from binlog to relay log, and a detailed step‑by‑step process for configuring asynchronous replication in production environments.
This guide breaks down a real‑world interview scenario where a backend engineer must design a scalable database solution for a billing‑log or feed system handling 100 million daily inserts and 100 k QPS reads, covering partitioning vs sharding, sharding key selection, shard count, read‑write separation, multi‑level caching, consistency patterns, hot‑key mitigation, and online schema changes.
This article explains MySQL master‑slave replication, covering asynchronous, semi‑synchronous, and full synchronous modes, their mechanisms, advantages, disadvantages, and ideal use cases for high availability, read/write separation, and strong consistency in large‑scale systems.
This article explains how MySQL master‑slave replication works, covering the binlog mechanism, the three replication steps, and the three reliability modes—asynchronous, semi‑synchronous, and fully synchronous—while highlighting its impact on read throughput, backup, and disaster recovery.
The article explains why employing write‑oriented models for data retrieval in PHP leads to security leaks, unnecessary validation, and performance issues, and proposes dedicated read models, static constructors, and specialized repositories to cleanly separate read and write concerns.
This article explains the concept of high concurrency, its key metrics, and presents four practical backend solutions—static/dynamic separation with CDN, read‑write separation using NoSQL and CQRS, various caching techniques, and lightweight read‑optimisation—to improve performance and scalability of distributed systems.
This article explains how internet‑scale services can progressively upgrade their data architecture—from a single read/write instance to read‑write separation, multi‑region “two‑site three‑center” designs, cache fallback, and local decentralised caching—to achieve high availability and scalability.
This article introduces database middleware, explains why it’s needed for scaling and performance, and provides a detailed overview of six popular middleware solutions—including ShardingSphere, MyCat, MySQL‑Proxy, DRDS, Atlas, and Zebra—highlighting their core features and use cases.
This article explains the concept of database read‑write separation, why it improves performance in high‑concurrency scenarios, when to apply it, the underlying master‑slave replication mechanism, and provides a MySQL example illustrating the steps of replication and its benefits for scalability and availability.
This guide explains how to implement read‑write separation in Spring Boot applications by configuring master and slave databases, creating dynamic routing data sources, using custom annotations and AOP, integrating HikariCP and MyBatis, and handling thread‑local context for optimal performance.
This article explains the principles and practical designs of high‑performance database clusters, covering read/write separation, master‑slave replication lag, distribution mechanisms, sharding (both vertical and horizontal), business‑level partitioning, and the role of NoSQL technologies such as key‑value stores, document databases, columnar databases, and full‑text search engines.
This article details eBay's event monitoring platform architecture, explains the challenges of high‑load OLAP workloads on ClickHouse clusters, describes the design and implementation of read/write separation and multi‑shard Keeper coordination, and shares concrete configuration snippets, performance observations, and production lessons learned.
The article details how eBay’s Sherlock.io event monitoring platform, built on ClickHouse, faced scaling and performance challenges due to ZooKeeper bottlenecks, and explains the design and implementation of read/write separation, shard‑level Keeper coordination, and related operational fixes to improve reliability and latency.
This article explains MySQL master‑slave replication, covering its basic concepts, the advantages of read‑write separation, data backup and high availability, the underlying binlog‑based mechanism, the four replication modes (full, asynchronous, semi‑synchronous, enhanced semi‑synchronous), common consistency challenges, and practical ways to mitigate them.
This article explains why modern internet products need caching to handle massive real‑time data, introduces Redis as an in‑memory database with persistence, master‑slave replication, and clustering, and demonstrates how these techniques dramatically improve performance, scalability, and reliability of web services.
Managing 20,000+ concurrent SQL queries requires moving beyond a single‑instance design; this guide explains why simple architectures fail, how to shard databases into multiple instances, route traffic using geographic hashing, and implement read‑write separation to sustain high read loads while keeping latency low.
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 walks through the progressive evolution of a software system—from a traditional monolithic architecture to a task‑oriented monolith, then to Command‑Query Separation (CQS) and finally to a full CQRS solution—explaining the motivations, trade‑offs, and techniques such as eventual consistency, event sourcing, and read‑model generation.
This article walks through the evolution from a traditional monolithic architecture to a CQRS‑based design, explaining the motivations, trade‑offs, and concrete techniques such as read‑write separation, message‑driven commands, eventual consistency, and event sourcing for building more scalable and maintainable systems.
This article walks through the evolution of software design from a traditional monolithic API server to a CQRS-based architecture, highlighting the drawbacks of the anemic CRUD model, the benefits of read/write separation, domain messaging, eventual consistency, and practical implementation considerations.
This article details the end‑to‑end design of Baidu App’s personal wallet, covering background requirements, business integration, system architecture, data‑sync mechanisms, multi‑level caching, read‑write separation, data consistency, configuration management, and database sharding to achieve high availability and scalability.
This article details the design and implementation of Baidu App’s “My Wallet” feature, covering its background, business goals, system architecture, data synchronization, multi‑level caching, read‑write separation, data consistency, configurability, and database sharding to achieve high availability and performance for billions of users.
The DBLE 3.22.01.0 release introduces seven new or refactored features—including enhanced read/write separation, ClickHouse support, and hint‑based query planning—while fixing over a hundred bugs, addressing critical community issues, and providing a complete list of changes and incompatibilities.
This article explains MySQL master‑slave read/write separation, the binlog and relay log mechanisms, master‑slave delay, and how different transaction isolation levels affect whether the master or slave may return stale data, illustrated with practical examples and SQL snippets.
The article explains how Redis read/write separation works, compares star and chain replication architectures, and highlights the benefits of transparent compatibility, high availability, and improved performance for read‑heavy, write‑light workloads.
This article introduces three widely used system architecture designs—single‑database single‑application, content distribution with CDN/OSS, and read‑write separation with master‑slave databases and Elasticsearch—detailing their structures, advantages, disadvantages, and typical usage scenarios.
This article explains six typical system architecture designs, focusing on the first three—single‑database single‑app, content‑delivery, and read‑write separation—detailing their structures, advantages, disadvantages, and practical implementation steps for modern backend development.
This article explains why and how to apply vertical (business‑oriented) and horizontal (data‑oriented) sharding, covering single‑database, table splitting, database splitting, combined sharding, read‑write separation, routing algorithms, and real‑world case studies to improve scalability and performance.
This article explains why and how to split databases and tables in high‑concurrency systems, covering vertical (business‑domain) and horizontal (data‑volume) sharding, practical architectures, read‑write separation, routing algorithms, and real‑world case studies from gaming, membership points, and restaurant ordering platforms.
The article explains how to transition from client‑side sharding with Sharding‑JDBC to proxy‑side sharding using Rainbow Bridge DAL by adding new, switchable data sources, employing AbstractRoutingDataSource and configuration flags for gradual migration, while addressing read‑write separation, unsupported SQL functions, and ensuring backward compatibility.
This article outlines the major new features of Redis 6.0 and 5.0, compares various deployment architectures—including master‑replica, cluster, and read‑write separation—explains proxy versus direct connection modes, and provides a Java Jedis connection‑pool code sample.
This article explains Redis read‑write separation architecture, comparing star and chain replication, and highlights its transparent compatibility, high availability, and performance benefits for read‑heavy, write‑light workloads in cloud database deployments.
This article explains Alibaba Cloud's Redis read‑write separation architecture, comparing star and chain replication models, their performance and scalability trade‑offs, and how transparent compatibility, high availability, and high performance are achieved through redis‑proxy, HA monitoring, and optimized binlog replication.
This article explains the background, architecture, and replication models of Redis read‑write separation, compares star and chain replication, and outlines its transparent compatibility, high availability, and performance benefits while noting consistency trade‑offs for read‑heavy workloads.
This article explains how Redis read/write separation introduces a read‑only replica role, compares star and chain replication architectures, and outlines the transparent compatibility, high availability, and performance benefits that help users reduce costs while handling read‑heavy workloads.
This article explains how Redis read‑write separation works, compares star and chain replication architectures, and highlights the benefits of transparent compatibility, high availability, and high performance for read‑heavy, write‑light workloads.
Redis read/write separation introduces read‑only replicas to offload read traffic, offering two replication models—star replication with direct master‑replica sync and chain replication forming a replication chain—each with distinct performance, scalability, and latency trade‑offs, while maintaining high availability and transparent compatibility.
This article explains how service routing selects the most suitable service node for a consumer, covering scenarios such as grouped calls, gray releases, traffic switching, read/write separation, and provides concrete condition, whitelist, blacklist, and script‑based routing rules with implementation details.
This article examines core MySQL architecture principles—high availability, performance, consistency, and scalability—then compares four common deployment patterns, analyzes their trade‑offs, and presents practical consistency solutions for both master‑slave replication and cache synchronization, ending with personal insights on evolution and sharding.
This article details how Kuaishou tackled performance, scalability, and stability challenges of Hive MetaStore by introducing a BeaconServer hook architecture, read‑write separation, API refinements, traffic control, and federation designs, resulting in significant query efficiency and service reliability improvements.
The article explains the causes and impacts of hotspot key problems in high‑traffic systems, reviews traditional mitigation methods and their drawbacks, and details Alibaba Cloud's read‑write separation and proxy‑based hotspot data solutions that improve scalability, transparency, and performance.
This article outlines core database architecture principles—high availability, performance, consistency, and scalability—and evaluates four common schemes (primary‑backup, dual‑master, master‑slave with read/write separation, and hybrid), followed by detailed consistency‑resolution strategies and personal insights.
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 explains a real‑world case where a newly added mapping rule didn't appear immediately due to master‑slave replication lag, walks through the evolution of database architectures from single‑node to read‑write separation, and presents several practical strategies to mitigate consistency issues caused by replication delay.
This article explains the Command‑Query Separation principle, introduces the CQRS architectural pattern, and compares three implementations—single‑database, dual‑database, and event‑sourced—detailing their workflows, benefits, and trade‑offs for optimizing read and write operations in backend systems.
This article recounts the 2007 challenges faced by Taobao's monolithic MySQL setup and explains how the TDDL middleware introduced SQL optimization, sharding, read‑write separation, caching, and dynamic scaling to transform the system into a distributed, high‑performance database solution.
Database read/write separation, alongside sharding and master‑slave architectures, mitigates high‑concurrency bottlenecks by distributing reads to replicas and writes to a primary, offering scalability and performance benefits while introducing challenges such as replication lag, routing complexity, and resource utilization trade‑offs.
This article outlines core database architecture principles—high availability, performance, scalability, and consistency—examines four common deployment patterns (primary‑standby, dual‑primary, primary‑replica with read/write separation, and hybrid), and presents practical consistency solutions and personal insights for selecting and evolving database designs.
The article recaps the final DBLE open class session on May 12, presenting DBLE 3.0 roadmap, sharing PPT and video resources, and providing detailed Q&A covering features such as connection pooling, read‑write separation, distributed transactions, sharding, high‑availability, and future development plans.
This article outlines core database architecture principles—high availability, high performance, consistency, and scalability—examines four common deployment schemes (primary‑standby, dual‑primary, primary‑replica with read/write separation, and a combined dual‑primary/replica model), and presents multiple consistency and cache‑integration solutions.
This article explains why and when to split databases, compares vertical and horizontal sharding methods, outlines practical steps for determining split mode, fields, rules and quantity, and discusses scaling, read/write separation, and common challenges with solutions.
This article outlines fundamental database architecture principles such as high availability, performance, consistency, and scalability, compares four common deployment schemes (master‑slave, dual‑master, master‑slave with read‑write separation, and hybrid master‑master‑slave), and presents various consistency solutions including caching, semi‑sync replication, and middleware.
This article introduces cloud database services, compares relational and non‑relational options, outlines traditional database challenges, highlights the key benefits of cloud databases, explains high‑availability MySQL and read‑write separation architectures, and lists common industry use cases.
This article outlines core database architecture principles—high availability, performance, consistency, and scalability—then compares four common setups (primary‑backup, dual‑master, primary‑replica, and hybrid), analyzes their trade‑offs, and presents practical consistency and cache‑sync solutions along with personal insights.
This article explains why hotspot keys occur in large‑scale services, outlines the performance risks they create, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read/write separation, and proactive hotspot detection—to keep systems stable under heavy load.
This article examines core database architecture principles—high availability, performance, consistency, and scalability—and compares four common deployment patterns (primary‑standby, dual‑primary, primary‑replica with read/write separation, and a hybrid dual‑primary/replica design), followed by detailed consistency solutions and practical insights for real‑world implementation.
This article explains how to design a database architecture that can handle millions of daily active users and tens of thousands of concurrent requests by using multi‑server sharding, extensive table partitioning, read‑write separation, and distributed unique‑ID generation techniques such as Snowflake.
This article provides a step‑by‑step tutorial for preparing the environment, installing DBLE, configuring its sharding and read‑write‑separation features, and verifying the setup with command‑line examples and configuration file snippets, enabling developers to quickly get started with the DBLE middleware.
Hotspot keys, caused by massive read‑heavy traffic or server limits, can overload network cards, crash cache shards, and trigger DB bottlenecks, but by employing server‑side caching, Memcache/Redis, local caches, read‑write separation, and proactive hotspot detection, systems can mitigate these issues and scale efficiently.
This article explains the causes of hot key problems in high‑traffic scenarios, outlines their potential impact on system performance, and presents multiple mitigation strategies—including server‑side caching, Memcache/Redis, local caches, read‑write separation, and proactive hot‑data detection—while comparing their advantages and trade‑offs.
This article details Alibaba Cloud's evolution of SQL Server RDS, covering product growth, the challenges of read/write separation, technical evaluations of AlwaysOn versus Transactional Replication, cloud architecture iterations, and the final productized solution for high‑availability database services.
This article explains the architecture and key features of CDB for MySQL read-only instances and RO groups, including read-write separation, horizontal scaling, automatic load balancing, health checks, and dynamic instance removal for high-delay instances.
An order system retrieved incorrect product size data due to master‑slave database lag causing stale Redis cache, and the article explains the original flawed flow, the revised solution that writes to cache during sync, and best practices for cache updates, read‑through, and QA testing.
This article explains the fundamentals of database sharding, including horizontal partitioning concepts, routing rules, and various sharding strategies such as range, hash, and mapping tables, and how clustering, load balancing, and read/write separation improve scalability, availability, and performance for large‑scale internet applications.
This article explains core database concepts such as sharding, replication, routing strategies, and high‑availability designs, detailing how to achieve read/write separation, cache integration, and consistency handling in a master‑slave architecture for large‑scale systems.
This article uses the Golden Circle framework to explore MySQL replication, detailing its definition, benefits such as scaling and fault tolerance, the underlying mechanisms involving binary logs and IO/SQL threads, and addressing common practical questions through a self‑Q&A format.
The article reviews the evolution of large‑scale website architecture, explaining how business complexity, multi‑server deployment, session handling, load balancing, database read/write separation, caching, and search indexing together address availability, concurrency, and performance challenges in modern web systems.
This article compiles expert insights from a high‑efficiency operations forum, covering MySQL performance optimization techniques such as read‑write separation, sharding, schema and parameter tuning, hardware and SSD enhancements, as well as a detailed FAQ addressing replication lag, Aurora challenges, and backup tools.
The article explains how the lack of Command‑Query Responsibility Segregation (CQRS) leads to unnecessary complexity, outlines the benefits of read‑write separation, presents a simple e‑commerce example, and summarizes Vladimir Khorikov’s three CQRS types and when to apply them.
The article explains that database read/write separation offers limited performance gains and mainly serves data safety, while true scalability for read operations comes from caching and server clusters, and that write operations require a single dedicated server and actor‑model programming for safe concurrency.
