This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using custom annotations, Redis-based locks, and Redisson distributed locks, covering key generation, lock acquisition, configuration, and testing to ensure idempotent API calls.
This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.
This article explains the concept of interface debouncing, identifies which API endpoints need it, and provides detailed Java implementations using custom @RequestLock annotations, Redis caching, and Redisson distributed locks to prevent duplicate submissions in backend services.
This article explains the cache‑stampede problem when hot Redis keys expire under massive traffic, illustrates why simple caching fails, and presents a mutex‑lock solution with Go code to safely rebuild caches while protecting the database.
To maintain data consistency between Redis caches and MySQL databases, this article examines common pitfalls and presents three robust solutions—deleting cache before DB writes, updating the DB then removing cache, and implementing delete‑retry mechanisms—plus optional locking for strong consistency.
The article explains how Redis achieves high QPS by using an in‑memory, single‑threaded event loop for simple commands, leverages I/O multiplexing (epoll/select/kqueue) and optional multi‑threaded I/O for heavy operations, and outlines its evolution from a pure reactor model to a hybrid multi‑threaded architecture.
This article explains why cache‑DB consistency is a long‑standing challenge, compares naive full‑load and delete‑cache approaches, analyzes concurrency and failure scenarios, and presents reliable solutions such as updating the database first followed by cache deletion using message queues or binlog subscriptions.
This article describes how a unified membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic isolation, deep ES optimizations, Redis caching, dual‑center MySQL partitioning, seamless migration, and fine‑grained flow‑control and degradation strategies.
This article explains the relationship between MySQL and Redis, discusses why cache consistency is challenging, and details four cache update design patterns—delete‑then‑update, update‑then‑invalidate (Cache‑Aside), read/write‑through, and write‑behind—illustrating each with flow diagrams and practical considerations.
This article explains how Redis as a distributed cache can cause data inconsistency with relational databases during write operations, outlines read and update workflows, compares five cache‑update strategies, and presents a delayed double‑delete solution with sample code to maintain consistency.
This tutorial explains how PHP developers can install PECL, search for and install extensions such as Redis, and integrate them into PHP code, while highlighting configuration steps and best practices for reliable backend development.
This article walks through the problem of traditional session‑based captcha login, compares it with a modern front‑back‑separated architecture, and provides a step‑by‑step implementation using Spring Boot, Kaptcha, and Redis, including full code snippets, configuration classes, and flow diagrams.
This article introduces RedisInsight, outlines its key features, provides step‑by‑step instructions for installing it on Linux and via Kubernetes—including environment variable configuration and service deployment—and demonstrates basic usage through screenshots of its GUI.
This article explores fundamental PHP caching techniques—including OPcache, HTTP header client caching, Memcached/Redis object caching, reverse‑proxy page caching, dynamic content caching, and cache invalidation—providing code examples and practical guidance to help developers dramatically improve application performance and scalability.
This article explains how to track online users by storing their identifiers in a Redis sorted set, using zadd to add entries, zrangeByScore to query active users, and zremrangeByScore and zrem to clean up expired or logged‑out sessions, with code examples in Java and JavaScript.
This article explains how to prevent duplicate API calls in Java backend systems by using debounce techniques, shared Redis caches or Redisson distributed locks, and provides complete annotation‑based implementations with code examples, key generation strategies, and testing results to achieve idempotent interfaces.
This article explains Redis bitmap data structures, introduces common bitmap commands such as BITSET, BITGET, and BITCOUNT, and provides a complete PHP example that records user sign‑ins and calculates daily sign‑in counts using Redis bit operations.
This article explains the motivation, design principles, class diagram, and core Go code for a multi‑level cache library that supports in‑memory and distributed caches (Redis, Memcached) using adapter, builder, and responsibility‑chain patterns, and discusses cache‑database consistency strategies.
This article introduces Redisson as a Redis Java client and demonstrates how to use its distributed collection implementations—RMap, RSet, RList, RQueue, and various blocking queues—in Spring Boot 2.7, covering synchronous, fast, and asynchronous operations, lock binding, local caching, and event listeners.
Redis announces a dual‑license model (RSALv2 and SSPL) starting with version 7.4, sparking community backlash, prompting concerns about open‑source status, potential distro removals, and driving users toward alternative in‑memory databases and possible forks.
This article explains the concept, use cases, and common implementations of delay queues—including JDK's DelayQueue, RabbitMQ plugins, and Redis ZSet—followed by a detailed guide to installing, configuring, and using the open‑source lmstfy project, and concludes with promotional information for ChatGPT‑related services.
Ensuring API idempotency is crucial to avoid duplicate operations like double crediting points or double payments, and this article examines common causes of repeated calls—such as rapid user clicks, retries, and message queues—and presents practical backend solutions including frontend controls, Redis setnx, token validation, unique indexes, counting, and state machines.
This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, implementing token generation and validation services, configuring an interceptor, and providing test cases to demonstrate the workflow.
This article outlines seven typical cache problems—including cache penetration, breakdown, avalanche, large keys, hot keys, hit‑rate issues, and data inconsistency—and provides practical solutions such as parameter validation, Bloom filters, null‑value caching, locking, auto‑renewal, random expiration, high‑availability setups, compression, and cache warming to improve system reliability and performance.
This article explains how to design and implement a fast, shared‑memory cache for a PHP‑based strategy game backend using Webman, Redis, MySQL, and APCu, covering service architecture, Redis usage, atomic operations with APCu locks, channel and list mechanisms, and practical code examples for multi‑process communication.
The article explains why API debounce is essential, identifies the types of endpoints that need it, and walks through two SpringBoot solutions—Redis‑based shared cache and Redisson distributed lock—complete with custom annotations, key generation, code samples, test results, and practical limitations.
The article recounts a painful production incident caused by missing cache warm‑up, explains why pre‑loading caches is essential for performance and reliability, and presents practical strategies such as gray‑scale rollout, database scanning, and ETL‑driven cache filling.
The article analyzes common inventory‑deduction scenarios, compares three approaches—single‑row MySQL, multi‑row MySQL, and Redis INCRBY—highlights the limitations of database‑based methods under heavy load, and presents a robust Redis‑Lua solution with distributed locking and Java code examples for reliable stock management.
This guide explains how to download and install the Redis extension, add the Predis package to a Laravel project, configure single‑node and clustered Redis connections in config/database.php, and demonstrates basic Redis commands, transactions, and Lua scripting within Laravel controllers.
This article examines Pinterest's evolution through four development phases, the core technologies it adopted, and how it transitioned from complex clustering to a simpler sharding architecture to achieve scalable, high‑availability data storage.
This tutorial explains how Redis Cluster automatically shards data across multiple nodes, covering required TCP ports, hash‑slot sharding, master‑slave replication, consistency trade‑offs, essential configuration parameters, and step‑by‑step commands for creating, expanding, resharding, and managing a production‑grade Redis cluster.
This guide explains how to implement a Retrieval‑Augmented Generation (RAG) workflow by loading a beer‑info JSON dataset into a Redis vector store, wiring it with Spring Cloud Alibaba AI Starter, and exposing a web API that returns LLM‑generated answers.
This article explains the essential elements of high‑concurrency system design—performance, availability, scalability—introduces quantitative metrics, classifies read‑heavy and write‑heavy scenarios, and details practical solutions such as database read/write separation, local and distributed caching, cache‑penetration and avalanche mitigation, and CQRS implementation for billion‑user applications.
This course provides an in‑depth exploration of core backend concepts, covering process fundamentals, TCP/IP socket communication, Nginx integration with PHP‑FPM via FASTCGI, host‑to‑network byte order conversion, and Redis basics, aiming to equip developers, sysadmins, and network engineers with comprehensive backend development skills.
This article explains the motivation, architecture, resource estimation, code generation algorithms, data modeling, database partitioning, caching strategies, and implementation details for building a scalable short URL system that handles billions of links and high QPS workloads.
The article explains several common reasons why Redis may degrade performance—such as network latency, misuse of high‑complexity commands, the KEYS command, clustered key expirations, and big‑key operations—and provides practical mitigation techniques like batch commands, TTL randomization, and lazy deletion.
This article introduces a Spring Boot starter that provides a ready‑to‑use Redis utility suite—including common tools, distributed locks, message queues, delay queues, pagination queries and web helpers—explains how to add the Maven dependency, configure modules via YAML, and details the internal auto‑configuration and bean implementations for MQ and delayed messaging.
This article explains common Redis performance pitfalls—including per‑command network latency, expensive commands like SUNION and KEYS, mass key expiration spikes, and big‑key deletions—and provides practical techniques such as MSET batching, randomizing expirations, and using UNLINK to keep your backend fast.
This article compares six practical backend approaches—JDK DelayQueue, RocketMQ delayed messages, Redis expiration, Redis Zset, a dedicated task center, and passive closure—to automatically close unpaid e‑commerce orders after a configurable timeout, outlining their advantages, drawbacks, and suitable scenarios.
Redis announced that starting with version 7.4 it will adopt a dual‑source licensing model (RSALv2 and SSPL), moving away from its permissive BSD‑3 license, sparking widespread community backlash, discussions about cloud provider restrictions, and prompting users to consider alternative databases or forks.
The article introduces go‑sniffer, a Go‑based packet sniffer that captures MySQL, Redis, and MongoDB traffic, explains how to install required dependencies and the tool itself on CentOS or Ubuntu, and provides command‑line examples for auditing and analyzing database operations.
RediSearch, a Redis module providing full-text search and secondary indexing, is introduced with its features, performance comparisons against Elasticsearch, benchmark results for index building and query throughput, detailed installation methods, and extensive command examples for creating, querying, updating, and managing indexes.
This article explains Redis databases, the structure of the keyspace, how to set key expiration, and the various memory reclamation and eviction policies, providing Java developers with the essential knowledge needed for advanced Redis interview questions.
The article details Bilibili’s live ranking system, explaining how configurable ranking lists—managed via a console, stored in MySQL and cached in Redis zsets—support diverse dimensions, scoring modes, and filters to boost streamer and viewer engagement, while addressing high traffic, reliability, and future scalability plans.
The article reviews Amazon MemoryDB, a Redis‑based in‑memory database that uses a distributed transaction log to achieve strong consistency and durable persistence for high‑throughput, latency‑sensitive workloads, and compares its architecture and performance with open‑source Redis.
This article explains the fundamentals of finite‑state machines, introduces Spring Statemachine’s core features, walks through a complete Java implementation with database schema, persistence (memory and Redis), REST APIs, exception handling, and an AOP‑based solution for reliable state transitions.
This article analyzes feed‑timeline architectures, compares pull‑based and push‑based models, proposes an online‑push/offline‑pull hybrid, and details practical implementations using Redis SortedSets, multi‑level caching with Cassandra, cursor‑based pagination, and large‑scale push task sharding.
This article systematically examines seven typical cache problems—penetration, breakdown, avalanche, data inconsistency, big‑key, hot‑key, and low hit rate—explaining their root causes, illustrating concrete scenarios with diagrams and code, and presenting step‑by‑step mitigation techniques such as parameter validation, Bloom filters, locking, auto‑renewal, random expirations, high‑availability setups, and cache warm‑up.
This article explains the principles of Redis Pipeline, compares Lettuce and Redisson client implementations in Spring Boot, presents performance tests showing dramatic speed gains over single commands, discusses practical usage scenarios, common pitfalls, and provides detailed source code examples for both clients.
This article walks through Redis's architectural journey—from a lone instance to a high‑availability, high‑performance cluster—covering persistence (RDB, AOF, hybrid), master‑slave replication, Sentinel automatic failover, sharding strategies, and the modern Redis Cluster design.
This article walks you through Redis’s architectural journey—from a simple single‑node setup, through persistence mechanisms, master‑slave replication, Sentinel‑driven automatic failover, and finally sharding with Redis Cluster—explaining each component’s purpose, trade‑offs, and how they collectively boost performance and reliability.
This article explains three common methods for implementing delayed queues with Redis—using key expiration notifications, Zset with scheduled tasks, and Redisson’s RDelayedQueue—detailing their concepts, core code examples, advantages, and limitations for backend developers.
This article explains how to design a high‑QPS hotspot data caching and retrieval system for e‑commerce homepages using OpenResty, Lua, Redis, and a message queue, detailing publishing, reading processes, workflow diagrams, and a complete Lua script that can sustain tens of thousands to millions of concurrent requests.
This article explains the concept of delayed queues, compares them with scheduled tasks, outlines common business scenarios, and provides a complete Redis implementation using Sorted Sets, Lua scripts, and PHP code, including producer and consumer examples and performance considerations.
This article explains how to build a multi‑level caching system for microservice applications, covering client‑side HTTP caching, CDN and Nginx static‑resource caching, in‑process and distributed Redis caches, consistency challenges, and practical guidelines for when such a design is beneficial.
Redis 7.4 will be released under a dual‑license model (RSALv2 and SSPLv1), ending its long‑standing BSD‑3 clause terms, sparking controversy among open‑source communities, cloud providers, and users while prompting discussions of alternatives like KeyDB, Garnet, and Dragonfly.
This article explains Redis's memory model—including memory statistics, allocation, internal data structures, object types, and encoding—while showing practical examples for estimating usage, optimizing consumption, and troubleshooting fragmentation in high‑concurrency environments.
This article outlines seven typical cache issues—including cache penetration, breakdown, avalanche, data inconsistency, large keys, hot keys, and low hit rates—explains their causes, and provides practical solutions such as parameter validation, Bloom filters, locking, expiration randomization, key sharding, and cache warming to improve system reliability and performance.
This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.
This article explains Redis Cluster's sharding architecture, demonstrates how to configure multiple Redis nodes on different ports, shows commands for creating and testing the cluster, and illustrates failover behavior, highlighting its scalability and high‑availability advantages over Sentinel mode for large‑scale data workloads.
This article explains how Redisson leverages Redis to implement distributed locks, detailing the underlying Lua scripts, lock acquisition and release processes, the watch‑dog mechanism for automatic lease renewal, and provides Java code examples for integrating and testing the lock functionality.
This article provides a comprehensive introduction to Redis, covering its core features, supported data types, common caching use cases in Spring Boot, typical cache‑related problems such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence mechanisms, master‑slave replication, and Sentinel high‑availability architecture.
This guide explains why Redis Labs changed its license, introduces the community‑driven Valkey fork, provides step‑by‑step commands to download, compile, install, configure as a systemd service, test with clients, and benchmark performance against Redis.
This article introduces RediSearch, a Redis module for full‑text search, outlines its extensive feature set, compares its indexing and query performance with Elasticsearch, and provides detailed installation steps and command‑line examples for creating, querying, updating, and managing indexes.
An in‑depth investigation of a Redis timeout problem in a Spring Cloud backend reveals that the Lettuce client’s Netty EventLoop threads become blocked by synchronous Pub/Sub callbacks, causing socket buffer buildup, and proposes solutions such as increasing I/O threads or off‑loading processing to avoid the issue.
This article warns developers about several Redis commands—such as KEYS, FLUSHDB/FLUSHALL, SAVE/BGSAVE, and DEBUG SLEEP—that can cause performance degradation, data loss, or security issues in production environments, and encourages careful usage to avoid serious operational risks.
The article explains why Redis stores a single logical collection using two underlying data structures—intset and hashtable for sets, skiplist and ziplist for sorted sets—detailing the encoding rules, upgrade process, example commands, and how this dual‑storage balances O(1) lookups with ordered range queries without duplicating data.
A Docker image upgrade reduced Netty EventLoop threads, causing a Pub/Sub listener’s blocking Future.get() to stall one thread, fill a Redis cluster connection’s receive buffer and trigger widespread Redis timeouts in the custom Lettuce cache framework, which were eliminated by increasing I/O threads or making the callback asynchronous.
This article analyzes how Redis pipelining works, compares Lettuce and Redisson clients under Spring Boot, presents performance benchmarks for batch inserts, discusses practical pitfalls, and explains the internal implementation of pipeline support in both clients to help developers avoid common issues.
This article recounts how a volunteer registration platform was redesigned to meet extreme concurrency demands—handling up to 40k QPS and 20k TPS—by evaluating MySQL limits, adding Redis caching, integrating RocketMQ, applying fault‑recovery mechanisms, and iteratively optimizing through multiple load‑testing rounds.
This article summarizes a Didi second‑round interview covering Redis persistence mechanisms, data structures, memory overflow and leak concepts, thread safety, process vs thread differences, deadlock prevention, TCP/UDP distinctions, and a couple of hand‑written algorithm problems, providing detailed explanations and code examples.
The article evaluates common delayed‑task implementations—Redis expiration listeners, RabbitMQ dead‑letter queues, time wheels, and Redisson DelayQueue—explaining their drawbacks, proper use cases, and recommending reliable message‑queue solutions for e‑commerce order‑closing scenarios.
This article explains Redis's two persistence mechanisms—AOF and RDB—detailing how they work, their write‑back strategies, rewrite process, snapshot principles, and the hybrid approach, and provides practical guidance on choosing the right configuration to balance performance and reliability.
This course provides an in‑depth exploration of core backend concepts—including processes, socket programming with TCP/IP, Nginx‑FASTCGI communication, host‑to‑network byte order conversion, and Redis fundamentals—to equip developers, system administrators, and network engineers with comprehensive backend development skills.
This article explains how to design ranking systems for games and social apps, compares database sorting and client‑side approaches, and provides step‑by‑step Java code for implementing Redis‑based counters, leaderboards, performance optimizations, and real‑world use cases.
This article compiles a set of Java interview questions covering the differences between ArrayList and LinkedList, the internal workings and resizing of HashMap, concurrency primitives like synchronized and ReentrantLock, JVM memory layout, garbage‑collection algorithms, reference types, and Redis persistence and distributed‑lock mechanisms.
This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using Redis caching and Redisson distributed locks, detailing the design of request lock annotations, unique key generation, and practical code examples for robust idempotent APIs.
Redis achieves its remarkable speed through in‑memory storage, an efficient hash table design, single‑threaded execution that eliminates context switches, epoll‑based I/O multiplexing, progressive rehashing, and cached timestamps, all of which together enable near O(1) operations and minimal latency.
This article explains three Redis‑based rate‑limiting approaches—using SETNX for simple counters, ZSET for sliding‑window limits, and a token‑bucket algorithm with List—providing Java code examples and discussing their advantages and drawbacks.
This article explains why Redis, an in‑memory database, needs persistence, compares the four official persistence options (RDB, AOF, RDB+AOF, and no persistence), details their configurations, performance trade‑offs, and introduces the hybrid RDB+AOF method for balanced durability and speed.
This article explains the concept, necessity, key characteristics, and step‑by‑step Java implementation of Redis‑based distributed locks, providing code examples and guidance for ensuring mutual exclusion, reliability, and performance in backend systems.
When faced with a business requirement to filter up to 100 000 records from a pool of tens of millions and then sort and de‑duplicate them, this article explores four technical solutions—multithreaded ClickHouse pagination, Elasticsearch scroll‑scan, a combined Elasticsearch‑HBase approach, and RediSearch with RedisJSON—detailing their design, implementation, performance testing, and trade‑offs.
This article explains Redis Sentinel’s role in providing monitoring, notifications, automatic failover, and configuration updates to achieve high availability, detailing its heartbeat mechanism, master‑down detection, leader election, failover selection criteria, and the trade‑offs of using this solution.
This article explains why Redis achieves exceptional speed by leveraging in‑memory storage, an efficient hash‑table data structure, a single‑threaded event loop, epoll I/O multiplexing, incremental rehashing, and cached timestamps, providing a comprehensive view of its performance optimizations.
Bloom filters are space‑efficient probabilistic structures that answer “definitely not” or “maybe” membership queries, with a controllable false‑positive rate derived from bit array size, element count, and hash functions, and can be implemented via Guava’s Java library, Redisson’s Redis wrapper, native Redis modules, or custom bitmap code, dramatically reducing memory usage and latency in large‑scale systems such as URL deduplication or user‑product checks.
The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.
Redis’s versatile list commands—such as LPUSH, RPUSH, LPOP, RPOP, BRPOPLPUSH, LPUSHX, and RPUSHX—enable developers to implement efficient FIFO queues, stacks, blocking queues, and advanced patterns like priority or delayed queues, while offering practical tips for monitoring, persistence, and error handling.
Learn how to use the Adapter pattern in Go to unify disparate Redis clients—*redis.Client* and *redis.ClusterClient*—by defining a common interface, implementing concrete adapters, and employing a factory method, resulting in cleaner, maintainable code that adheres to the open/closed principle.
This guide walks through setting up Flink CDC with MySQL on SpringBoot 2.7, covering binlog configuration, Maven dependencies, Java implementation for real‑time change capture, startup options, a custom Redis sink, and a web UI for monitoring the streaming pipeline.
This guide explains how to implement a robust, re‑entrant distributed lock using Redisson in a Spring Boot 2.7 application, covering basic and asynchronous APIs, Maven dependency setup, YAML configuration, custom annotation, AspectJ implementation, and comprehensive test cases.
This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, tags, filtering, follow relationships, and ranking—demonstrating how each can boost performance and simplify backend architecture.
This article compares JWT and session authentication, explains their differences, advantages, and drawbacks, and provides a complete Java implementation with Redis integration, token generation, validation, renewal, and related interceptor configuration for a robust backend authentication system.
This article explains how to integrate Lua scripts with Redis in a Spring Boot application, covering Lua basics, performance benefits, common use cases, step‑by‑step configuration, Java code examples, error handling, security considerations, and best practices for reliable backend development.
This article explains Redis's three persistence mechanisms—RDB snapshots, AOF append‑only logs, and their hybrid mode—detailing trigger conditions, configuration options, advantages, disadvantages, and practical guidance for selecting the appropriate method in production environments.
This article explains how to design an effective multi‑level caching system in microservice environments, covering client‑side browser caching, application‑layer static resource caching with CDNs and Nginx, and service‑layer caches using in‑process solutions and distributed Redis, while also addressing consistency and deployment considerations.
The article examines Redis's shift to a source‑available license, traces its history, analyzes the impact on cloud providers and open‑source communities, and evaluates emerging forks and alternatives such as Valkey, KeyDB, and Redict as potential replacements.
This article explains how MySQL auto‑increment primary keys work, the practical limits of various internal IDs such as auto‑increment, InnoDB row_id, Xid, trx_id, and thread_id, and compares them with external solutions like Redis‑based auto‑increment keys, providing guidance on choosing the right approach for different scenarios.
The article systematically compares eleven technical approaches for automatically closing expired e‑commerce orders, detailing each method’s implementation steps, trade‑offs, performance characteristics, and ideal deployment scenarios, and finally ranks them to guide practical selection.
This article explains how to extend the Higress cloud‑native gateway with WebAssembly plugins written in Go, C++ or Rust that call Redis for global rate limiting, token‑based AI usage control, and cookie‑based caching, including full code samples, configuration steps, and test results.
The Linux Foundation is backing Valkey, a BSD‑licensed fork of Redis, to preserve an open‑source, community‑driven in‑memory NoSQL database after Redis shifted to stricter RSALv2 and SSPLv1 licenses, drawing support from major cloud providers and sparking debate among industry leaders.
