The article breaks down Redis‑Cluster failover into detection, election, failover, and client perception stages, explains the timing bottlenecks of each, and provides concrete server‑side and Lettuce client configurations that shrink end‑to‑end recovery to under ten seconds.
The article explains how to replace per‑message read flags with a single lastReadSeq column and an unreadCount cache, enabling efficient unread‑message tracking for large group chats and multi‑device synchronization in a Spring Boot chat system.
This guide walks through configuring Spring AI Alibaba 1.1.2.0 to persist an agent's short‑term memory in Redis, covering environment setup, core concepts like Checkpointer and StateSerializer, step‑by‑step Maven project creation, code snippets, common pitfalls, and verification of multi‑turn conversation state across sessions.
The article walks through a real production incident where a Redis‑based distributed lock silently failed, causing duplicate point awards, and details the step‑by‑step investigation, root‑cause analysis of transaction‑lock ordering, and three concrete remediation strategies.
The article explains how flash‑sale systems differ from regular e‑commerce, outlines characteristic traffic spikes, and defines TPS ranges—100‑1,000, 1,000‑5,000, 5,000‑10,000, and 10,000‑50,000—that indicate low, medium, mature, and ultra‑high concurrency, while noting the architectural techniques needed to sustain tens of thousands of requests.
This article walks through a comprehensive case study of a provincial medical appointment platform, diagnosing slow‑query bottlenecks, proposing patient‑id + create_time composite indexes, designing read‑write separation with replication, selecting patient_id for horizontal sharding, and implementing cache‑aside strategies to ensure consistency while handling cache avalanche, penetration and thundering‑herd scenarios.
This article explains the concept of cache preheating, provides an abstract cache class, a Spring context utility, and a CommandLineRunner implementation that automatically loads hot data into Redis at startup, demonstrating the approach with a news‑cache example and related controller code.
This guide walks through why traditional polling or WebSocket solutions quickly break at scale, explains the Server‑Sent Events protocol, and presents a production‑grade architecture that combines Spring Boot 3, WebFlux, Kafka, Redis, and Kubernetes to deliver reliable, ordered, and observable one‑way push notifications for millions of concurrent users.
The article presents a four‑layer method for diagnosing sudden Redis memory growth, covering recent releases or configuration changes, key monitoring metrics, sampled key analysis, and emergency mitigation steps, with concrete metric definitions and practical examples.
The article walks through building a secure QR‑code login flow with Spring Boot, explaining why the QR should contain only a short‑lived random identifier, how to model four login states in Redis, avoid embedding JWTs, use WebSocket for instant updates, and enforce strict one‑time exchange checks.
The article walks through the evolution of a flash‑sale inventory‑deduction system, starting with simple database row‑locking SQL, exposing its scalability limits, and progressively adding transaction trimming, Redis pre‑deduction, Lua atomic scripts, async pipelines, idempotency, reconciliation and robust engineering practices to handle extreme concurrency.
The article dissects a common interview question about automatically canceling unpaid orders, explains why a simple cron job fails at massive scale, and presents three robust designs—Redis expiration, Redis ZSet polling, and MQ/time‑wheel approaches—plus pitfalls and a ready‑to‑use answer template.
This article analyzes why cache and database can become inconsistent, compares four basic cache‑update patterns, explains the delayed double‑delete technique, shows how to use MQ for retrying cache deletions, and evaluates Canal binlog subscription as a zero‑intrusion solution for strong eventual consistency.
This article provides a production‑grade, step‑by‑step engineering guide for designing a high‑concurrency seckill (flash‑sale) system that can sustain 100,000 QPS using Spring Boot, Redis with Lua scripts, asynchronous messaging, and comprehensive fault‑tolerance, monitoring, and scalability techniques.
The article explains why traditional session mechanisms break in clustered and multi‑service environments, compares session replication and centralized storage, introduces CAS‑based single sign‑on with ticket flow, contrasts it with OAuth2, and provides a complete Spring‑Boot demo with Redis‑backed session handling.
This guide walks through installing Redis MCP and the official Agent Skills, then demonstrates how Claude Code can store, query, and cache data in Redis using natural language, while the Skill package supplies best‑practice recommendations such as vector search and sorted‑set selection.
Redis Cluster enforces a single database (DB 0) because its slot‑based sharding model relies on a global 16,384‑slot map, and supporting multiple databases would break slot consistency, migration, and scalability, so developers must use key prefixes, separate instances, or multiple clusters to achieve logical isolation.
The article explains that a shopping cart can tolerate loss of recent writes but not accumulated items, outlines the data model with seven fields and a unique key, compares client‑side storage options, details merge strategies for guest and logged‑in carts, and evaluates Redis, MySQL, and hybrid solutions with concrete trade‑offs.
When a single Redis instance can no longer hold the data volume or write load of e‑commerce workloads, the traditional master‑slave with Sentinel model reaches its limits, and Redis Cluster—by sharding data across 16,384 slots, using gossip‑based topology, and removing a central control plane—delivers horizontal scaling and fault‑tolerance for billions of requests, provided key design, hash tags, hot‑key mitigation, and client routing are applied.
This article introduces RedisInsight, the official visual management tool for Redis, outlines its key features, provides step‑by‑step installation on Linux and Kubernetes, and demonstrates basic usage for monitoring, querying, and memory analysis through the GUI.
This article presents a detailed technical blueprint for building an enterprise‑grade single sign‑on system that combines Apereo CAS, OAuth2, and JWT across four microservices, covering service responsibilities, data models, API contracts, deployment trade‑offs, and operational safeguards.
This article dissects Redis Sentinel’s high‑availability workflow—from failure detection, SDOWN/ODOWN states, and quorum logic to leader election, replica promotion, and configuration propagation—while illustrating each step with a real‑world e‑commerce cache case, detailed configuration snippets, Kubernetes deployment patterns, Spring Boot integration, and operational playbooks for observability and fault‑injection testing.
The article explains what JWT is, why its stateless design can cause problems, compares pure JWT, JWT with a blacklist, and storing tokens in Redis (whitelist), and provides a step‑by‑step guide on how to discuss these options convincingly in a Java interview.
This article provides a comprehensive, production‑focused analysis of Redis master‑slave replication, covering its internal state machine, full and partial sync processes, configuration pitfalls, performance bottlenecks, consistency trade‑offs, and practical deployment patterns with Docker, Kubernetes, and Spring Boot.
With modern high‑concurrency, low‑latency systems relying on multi‑layer caches like Redis, CDN, and Guava, this article presents a risk‑based, cost‑effective testing framework that quantifies hidden testing costs, prioritizes cache types by impact, and recommends high‑leverage techniques such as protocol validation, expiration edge testing, and production traffic replay.
This article walks through RedisInsight’s newly released web version, showing how to deploy it with Docker, highlighting its intuitive UI for browsing and editing various Redis data types, built‑in workbench, slow‑log and memory analysis, multi‑model support, theme switching, and built‑in tutorials.
This article explains why frontend debouncing cannot fully prevent duplicate form submissions, compares common backend anti‑duplicate strategies, and provides a step‑by‑step guide to implementing a robust, annotation‑driven solution in SpringBoot using Redis distributed locks, AOP, and custom exception handling.
The article examines how to implement read/unread status for single and group chats at scale, comparing a simple last‑read‑ID approach for one‑on‑one conversations with database, Redis hash, and bitmap‑watermark solutions for groups, and discusses their performance and memory trade‑offs.
The article analyses a real‑world P0 outage caused by treating Redis as a simple cache, explains why persistence is the decisive factor when Redis stores session, inventory or lock data, and provides a step‑by‑step guide to RDB, AOF and hybrid persistence, configuration, monitoring, recovery and best‑practice recommendations.
An online education platform experienced a cascade failure when Redis reached its maxclients limit, causing authentication, session, and cache services to become unavailable; the article details the connection mechanism, root‑cause analysis, rapid mitigation steps, and long‑term best practices for preventing similar outages.
The article breaks down a large‑scale interview question, showing why storing each sign‑in as a database row is infeasible, how a bitmap compresses a year of data to 46 bytes per user, the pitfalls of BITCOUNT, the importance of key dimension design, and the exact Redis commands and local‑scan algorithms—including a five‑step bit‑wise trick—to reliably determine a 30‑day continuous sign‑in.
The article dissects a high‑concurrency “cut‑the‑price” giveaway system, detailing a user‑value‑based pricing algorithm, micro‑unit Redis storage, anti‑fraud device fingerprinting, extreme convergence logic, and unit‑switching tricks, and provides a concise interview answer template.
This article walks through a complete user login flow—including client verification, token generation, expiration policies, gateway validation, logout handling, anonymous access, rate‑limiting via authorized tokens, regex path checks, and blacklist management—illustrated with diagrams and Spring‑Redis code examples.
By embedding a shard identifier (“gene”) into the low bits of a business ID generated via Redis INCR or similar sequencers, the article shows how to achieve direct table routing without broadcast queries or extra mapping tables, detailing the algorithm, implementation, integration with Snowflake and Leaf, and common pitfalls.
This article dissects why a simple Redis upgrade is insufficient for large‑scale live streaming, then walks through how Redis 7’s Sharded Pub/Sub, Function, and ACL v2 features together eliminate broadcast storms, streamline script governance, and enforce fine‑grained multi‑tenant control, backed by concrete architecture diagrams, production‑grade Java code, capacity planning, monitoring, rollout procedures, and real‑world benchmark results.
This article introduces RedisInsight, the official Redis visualization tool, walks through its Docker-based installation, showcases its graphical interface for data types, built-in workbench, slow‑log and memory analysis, JSON editing, theme switching, and provides a quick hands‑on experience for beginners.
The article breaks down a real‑world architecture for a short‑URL service that must handle 12 billion entries and 40 k QPS, showing how to calculate capacity, compare generation algorithms, use Bloom filters for offline de‑duplication, and employ a three‑layer cache‑plus‑storage design to meet performance goals.
This article walks through the redesign of a high‑traffic, multi‑dimensional DAU counting system that grew from 8 GB of Redis Set memory to a 24 MB HyperLogLog‑based solution supporting 200 million daily active users, 40 k QPS, and flexible time‑window queries while keeping latency under 20 ms.
The article explains why Redis must be highly available and walks through three progressive architectures—master‑slave replication, Sentinel automatic failover, and Redis Cluster—detailing their mechanisms, advantages, drawbacks, and when to choose each for small, medium, or large‑scale production systems.
This article explains how to implement pagination using Redis Sorted Sets, achieve multi‑condition fuzzy queries with Hashes and HSCAN, and then combine both techniques into a single solution while discussing performance trade‑offs and optimization strategies such as key expiration and data‑sync methods.
When an education company faced 50,000 concurrent re‑registration requests, its monolithic internal‑external architecture collapsed, but by physically separating networks, enforcing gateway rate‑limiting and circuit‑breaking, pre‑loading data into Redis, and using one‑way Kafka streams, the system remained stable.
RedisInsight is a visual GUI for Redis that uniquely supports Redis Cluster, offers SSL/TLS connections, memory analysis and an integrated CLI; the article walks through downloading the package, configuring environment variables, starting the service on Linux, deploying it on Kubernetes with a YAML manifest, and using the UI to monitor and operate Redis instances.
The article examines why the common update‑database, delete‑cache, add‑TTL workflow can still produce permanent stale data under high concurrency, explains the underlying race conditions, and compares several alternative strategies—including delete‑first, binlog‑driven invalidation, and lease‑based approaches—to help engineers choose the most reliable and low‑complexity solution for cache consistency.
To address MySQL master‑slave replication lag, the article explains enabling parallel replication (setting slave_parallel_workers), routing reads to the master for latency‑sensitive operations, and using a Redis short‑term marker to direct recent writes to the master, while outlining configuration steps and trade‑offs.
Most online Redis tutorials compile and run as root, creating serious security risks, so this guide walks through a complete, non‑root deployment and upgrade process—including backup, source compilation with a private prefix, configuration reuse, environment setup, post‑upgrade hardening, and a one‑click rollback—to safely patch high‑severity vulnerabilities on common Linux distributions.
This article breaks down the end‑to‑end design of a high‑traffic red‑envelope service, covering its three‑stage lifecycle, a fair double‑mean allocation algorithm, the need to separate grabbing from settlement, and how Redis, Lua scripts, and message queues handle massive concurrent requests.
This article presents a comprehensive, step‑by‑step analysis of building a flash‑sale (seckill) system that can survive instant traffic spikes, detailing seven essential design ideas such as static page delivery, token gating, Redis atomic decrement, asynchronous queuing, multi‑layer rate limiting, service isolation, idempotent processing, and end‑to‑end monitoring and recovery.
The article analyzes why MySQL and Redis cannot guarantee strong consistency with simple cache‑aside patterns, explains the pitfalls of delayed double delete, and presents a tiered Java design—including transaction‑after‑commit deletion, retryable invalidation, CDC/Outbox pipelines, TTL safeguards, and multi‑level cache considerations—to achieve reliable cache consistency.
This white‑paper dissects why a monolithic MySQL‑based order service collapses under peak traffic and presents a layered, asynchronous architecture—using Redis for stock pre‑allocation, RocketMQ for transactional messaging, sharding, idempotency, and comprehensive observability—to reliably handle tens of millions of queries per second.
The article analyzes the requirements of a massive‑scale like feature, compares small‑scale MySQL implementations with the graph‑plus‑KV architectures used by ByteDance, Kuaishou and Xiaohongshu, and presents a practical hybrid solution based on Redis, MySQL and batch processing to handle hot content and super‑node challenges.
This article dissects the architecture of a massive flash‑sale service like 12306, covering multi‑layer load balancing, Nginx weighted round‑robin, stock‑deduction strategies, a Go‑based implementation with Redis and Lua, and performance results that demonstrate handling millions of concurrent ticket requests.
The article explains the fundamental purpose of caching—placing frequently accessed data in faster storage—to dramatically reduce database load, compares local memory caches with distributed solutions like Redis, outlines their pros, cons, suitable scenarios, and presents a two‑level cache pattern plus common pitfalls such as cache penetration, breakdown, and avalanche.
In July 2026, the AI model Kimi K3 from Moonshot AI discovered and generated working remote‑code‑execution exploits for four Redis versions within 27 minutes, detailing a double‑free Stream NACK flaw and a TDigest heap overflow, and providing open‑source PoC scripts and defense guidance.
To survive a million concurrent flash‑sale clicks, the article breaks down a production‑grade, five‑layer architecture—CDN, load balancer, API gateway, Redis/Lua stock control, message‑queue order processing, and a state‑machine fallback—that filters traffic early, uses atomic operations, and decouples writes to keep database load to just a few QPS.
The article argues that local caches add significant consistency and management complexity, so they should be avoided unless a genuine performance bottleneck exists, illustrating the point with real‑world promotion spikes, GC concerns, and careful off‑heap testing.
This article walks through 14 real‑world failure scenarios of Spring Boot distributed caching, explains why high cache hit rates are misleading, and provides concrete analysis, code samples, and step‑by‑step recommendations for designing a resilient cache layer that isolates faults, handles hot keys, and ensures data consistency across Redis, local caches, and databases.
The article analyzes Redis distributed locks—its three‑step verification, the limited guarantees it provides, and why small‑to‑medium projects should often prefer database constraints, idempotency keys, or state machines over adding a lock that introduces extra complexity and maintenance overhead.
The article argues that seasoned developers improve system architecture by removing unnecessary components—such as redundant Redis caches or message queues—rather than continuously adding new ones, because each addition raises complexity and maintenance overhead, while simpler designs are easier to manage and evolve.
This guide explains how to build a dynamic IP blacklist for Nginx by comparing OS‑level iptables, Nginx deny rules, and application‑level checks, then detailing the chosen Nginx‑OpenResty, Lua, and Redis architecture, configuration snippets, and Lua script logic for automated blocking and rate limiting.
The article outlines three core architectural choices—channel isolation, a dedicated payment gateway, and robust callback handling with Redis and distributed locks—that together prevent a single payment channel failure from collapsing the entire payment platform.
This article details how a photo‑contest backend migrated from MySQL to Elasticsearch and, through three rounds of optimization—including multi‑level Redis anchor caching, recent‑anchor positioning, and a large‑interval‑plus‑small‑page‑anchor strategy—reduced arbitrary deep‑page response time from ten minutes to about one second, achieving a 600‑fold speedup while exposing remaining data‑drift challenges.
The article explains that although Spring Cloud Gateway offers token‑bucket rate limiting via Redis, adding a coarse‑grained Nginx limit protects the gateway from traffic spikes, reduces JVM pressure, and ensures continuous flow control even during restarts or GC pauses.
The article walks through the evolution of Redis leaderboard architectures, covering why ZSets are used, handling same‑score ordering, seasonal resets, access patterns, synchronous vs asynchronous updates, big‑key and hot‑key issues, sharding with buckets, and data durability strategies.
The article explains that while many teams focus on model accuracy, the real challenges of an AI‑powered tagging system are write spikes, timeouts, duplicate tagging, cost overruns and state inconsistency, and it proposes a five‑layer architecture, async fallback, governance and validation practices to reliably achieve a 100 k QPS target.
The article presents a comprehensive five‑layer risk‑control architecture—covering front‑end behavior verification, device fingerprinting, account profiling, IP network analysis, and backend request sequencing—designed to separate genuine shoppers from scalper scripts during high‑traffic flash‑sale events, using Redis‑based storage and dynamic thresholds to minimize false positives.
This article presents a production‑grade design for a social private‑messaging system that handles billions of messages with millisecond latency, detailing how MySQL serves as the message fact store, RabbitMQ provides low‑latency distribution, Redis manages online state and indexes, and Outbox plus idempotent consumption ensure reliability and ordering.
This article walks through ten advanced Redis features—including Bloom filters, Redisson distributed locks, delayed queues, token‑bucket rate limiting, bitmaps, HyperLogLog, GEO, Streams, Lua scripts, and RedisJSON—explaining their principles, pros and cons, typical scenarios, and providing complete Spring Boot code examples.
An intermittent Redis timeout in a Kubernetes pod was traced not to Redis or the network but to uneven soft‑interrupt handling on a single CPU core, caused by irqbalance moving interrupts across NUMA nodes, and resolved by aligning NIC queues, adjusting irqbalance, and reserving CPUs.
Redis achieves its high speed not only because it is an in‑memory, single‑threaded database with efficient data structures, but primarily thanks to I/O multiplexing, which lets a single thread manage tens of thousands of client connections, dramatically cutting thread‑switch overhead and boosting throughput up to tenfold.
This guide walks through integrating Spring AI 2.0 into a Spring Boot application, covering Maven dependency setup, model configuration, ChatClient usage for synchronous and streaming calls, Redis‑backed chat memory for multi‑turn conversations, and testing with Postman and a UI component.
The article walks through constructing a full‑stack real‑time recommendation system—from user‑behavior collection via Kafka, through Flink streaming jobs for hot‑list, user and item profiling, to storage in Redis, HBase and Elasticsearch, and finally a React/Ant Design console that visualizes the pipeline and enables debugging.
This article walks Java developers through turning Spring AI into an enterprise‑grade AI agent that can query internal databases, access a vector‑based knowledge base, enforce role‑based permissions, persist chat sessions in Redis, add full observability, and be container‑deployed with Docker and Kubernetes.
This article introduces a runnable microservices learning project built with three independent Spring Boot applications (gateway, order, stock) and middleware such as Nacos, MySQL, Redis, RocketMQ, and Seata, guiding readers through cloning the repository, starting the environment with Docker Compose, and verifying the end‑to‑end product‑order‑stock flow.
This article examines the challenges of managing user authentication across many corporate systems, explains traditional session mechanisms, explores session sharing solutions for clustered environments, and provides a detailed walkthrough of implementing single sign‑on using CAS with Java and Redis, including code samples and a comparison with OAuth2.
The article demonstrates how to create a custom @BatchProcess annotation combined with AOP to aggregate high‑frequency requests into batches, persist metadata in Redis, and process them efficiently, thereby reducing connection, I/O, and CPU overhead in distributed, high‑concurrency Spring Boot 3.5.0 applications.
Spring AI 2.0 lets Java developers integrate large‑language‑model capabilities with minimal code by adding a starter, configuring model parameters, injecting a ChatClient bean, and optionally enabling Redis‑backed chat memory for multi‑turn conversations, all demonstrated with runnable examples and screenshots.
This article walks through a production‑grade architecture that uses Spring Boot, Kafka, Redis, and MongoDB to ingest, buffer, order, and store high‑frequency vehicle GPS data from hundreds of thousands of devices while guaranteeing low latency, scalability, fault‑tolerance, and accurate replay capabilities.
After Redis switched from a BSD to a closed‑source license in March 2024, the community quickly forked Valkey, which within a year surpassed Redis in throughput, latency, and memory usage, gained support from major cloud providers and Linux distributions, and continues to accelerate while Redis struggles to regain its position.
This article provides an in‑depth guide to Redis’s advanced capabilities, covering how to use pipeline for batch commands, transactions for ordered execution, Lua scripts for atomic logic, distributed locks with proper token handling, reliable messaging with streams, and specialized data structures such as BitMap, HyperLogLog, Bloom Filter and GEO for efficient large‑scale scenarios.
This article explains WebSocket fundamentals, compares it with HTTP polling, details the handshake and frame format, and provides complete server‑side examples in Python, FastAPI, Go, and Java Spring, followed by a full real‑time chat system with private messaging, database schema, heartbeat handling, and Redis‑based online presence management.
This article explains how to implement an online user counting feature by using Redis sorted sets, covering user identification (token or browser fingerprint), adding users with ZADD, querying current online users with ZRANGEBYSCORE, and cleaning up expired entries via ZREMRANGEBYSCORE and ZREM.
The article explains how combining a local Caffeine cache with a Redis cluster in a three‑tier architecture can protect high‑traffic distributed systems from cache avalanche, detailing expiration strategies, hot‑cold data separation, fault‑tolerant fallback, consistency handling, performance benchmarks, and practical pitfalls.
This article presents a production‑grade, high‑concurrency order system design that separates responsibilities among Redis for traffic control, MySQL as the single source of truth, Kafka for event propagation, and Elasticsearch for search, while detailing state‑machine modeling, outbox patterns, seckill flow, and comprehensive observability and deployment practices.
This article walks through integrating Spring AI 2.0 into a Spring Boot project, configuring model access, implementing synchronous and streaming chat endpoints, and adding Redis‑backed conversation memory to enable true multi‑turn interactions with large language models.
The article explains how caching, especially with Redis, reduces database load in high‑traffic scenarios, but also details three cache failure modes—avalanche, penetration, and breakdown—and provides concrete mitigation techniques to keep systems stable.
This article explains why a single‑node Redis deployment is a single‑point‑of‑failure and walks through building a highly available Redis cluster using master‑slave replication, Sentinel monitoring and automatic failover, split‑brain prevention, production deployment guidelines, common pitfalls, and client‑side connection strategies.
A power outage once erased all cached sessions, counters and leaderboards in Redis, exposing the inherent risk of in‑memory data loss and prompting a deep dive into Redis persistence mechanisms—RDB snapshots, AOF command logging, their trade‑offs, hybrid persistence, and the new Redis 7 Multi‑Part AOF design—so you can choose the right strategy for your workload.
This article explains why Redis can store one million items with ten‑fold memory savings by examining each of the five core data types, their underlying encodings such as SDS, listpack, quicklist, hashtable and skiplist, and shows how automatic encoding switches affect memory usage, performance, and common pitfalls.
This tutorial walks a complete beginner through launching a Redis server with Docker, managing it with Docker Compose, adding master‑slave replication, configuring Sentinel for automatic failover, building a 3‑master‑3‑replica Redis Cluster, and provides production‑grade configuration templates and an online‑deployment checklist.
An in‑depth analysis of a custom SIP‑WebRTC video gateway built on Kubernetes, detailing dual load‑balancing via K8s and Redis RPC, a seven‑layer architecture, media mixing and aggregation pipelines, and graceful shutdown mechanisms that enable reliable SIP call integration with modern WebRTC conferences.
The article explains how a Redis‑backed Bloom filter can deduplicate activity pop‑ups for 30 million users using only 35 MB of memory, compares alternative approaches, and details the underlying bit‑array and hash‑function mechanics, false‑positive rate, parameter sizing, expiration, and practical library choices.
This article walks through Redis fundamentals, explaining its definition, internal modules, the full processing path of a SET command, essential commands, and how Redis differs from Memcached and MySQL, while also covering common connection and performance pitfalls.
The article analyzes the delayed double‑delete cache‑consistency pattern, exposing how its fixed sleep interval, thread blocking, unreliable second delete, and inability to handle concurrent writes make it unsuitable for high‑traffic systems, and it proposes safer cache‑aside alternatives.
A production incident showed Redis keys disappearing at 2 AM without any memory alarms; deep analysis revealed a short‑term memory spike caused by a surge in GET requests, client‑output‑buffer‑limit growth, and LRU eviction, leading to practical mitigation steps.
This article presents a comprehensive guide to building a production-grade SMS verification login system, covering threat modeling, multi-layer rate limiting, state management with Redis, asynchronous message handling, multi‑provider routing, token issuance and operational monitoring to ensure security, cost control, and high availability.
The article introduces Redis's official search module RediSearch, compares its memory usage and query performance against Elasticsearch, presents benchmark results showing faster indexing and four‑times higher throughput, and provides step‑by‑step installation, index commands, and Java integration examples.
This article compares leading open‑source vector databases—including Redis, Milvus, Weaviate, Qdrant, Chroma, pgvector, and Faiss—by examining their architectures, performance benchmarks, deployment models, and suitability for production AI workloads, helping readers choose the right solution for their needs.
This article introduces Redisson, a Redis‑based Java client that wraps Redis commands into familiar Java concurrency primitives, compares it with Jedis and Lettuce, explains why custom distributed locks are error‑prone, and provides step‑by‑step code for configuring, using, and integrating its core features such as locks, maps, queues, and rate limiters in Spring Boot.
The article outlines five common cache design problems—penetration, concurrency, avalanche, hot‑data management, and business‑cache coupling—illustrates each with a diagram, and provides concrete Redis‑based solutions such as placeholder values, setNX locks, random TTLs, sorted‑set queues, and a Binlog‑Canal‑MQ pipeline.
The article details DeWu's three‑year evolution of its self‑built Redis platform—covering architecture, access method changes, version upgrades, proxy rate limiting, and automated operations—that together reduced request latency by over 90% while supporting more than 1,000 clusters, 160 TB of memory and near‑10‑million QPS.
