This article explains why public APIs need protection, outlines anti‑tampering and anti‑replay strategies using timestamps and nonces, and provides complete SpringBoot code—including request signing, filter implementation, and Redis utilities—to safeguard API calls from manipulation and replay attacks.
A developer recounts a painful production incident caused by an un‑preheated Redis cache, explains why cache warm‑up is essential for high‑traffic services, and outlines practical techniques such as gray releases, database scanning, and ETL pipelines to safely preheat caches.
This article explains why using Redis List for a message queue is limited, introduces Redis Stream as a purpose‑built MQ with consumer groups, ACKs, and persistence, and dives into its internal Radix‑Tree and listpack structures, command usage, and memory‑saving techniques.
This article explores comprehensive strategies for handling hot‑key bottlenecks in high‑traffic flash‑sale scenarios, covering DB, Redis, sharding, local cache, failure handling, and scaling techniques across various QPS ranges to ensure reliable inventory control and user experience.
The Aikexing Open Source Community weekly newsletter shares curated database articles, technical insights on MySQL, OceanBase, and Redis, announces SQLE 2.2309.0‑pre2 release with Feishu integration, recaps recent events like QCon Beijing, and promotes upcoming meetups and open‑source projects.
This article introduces Redis as a high‑performance in‑memory key‑value store, explains its core features, data types, caching usage in Spring Boot, and discusses common cache problems such as consistency, avalanche, penetration, and breakdown along with mitigation strategies, plus details on persistence, replication, and Sentinel.
This guide explains how to combine local and remote caches using Alibaba's JetCache in a Spring Boot project, covering dependency setup, configuration files, annotation‑based usage, advanced API methods, testing procedures, and common troubleshooting tips for a robust multi‑level caching solution.
This article explains how distributed locks solve data‑consistency problems in clustered environments, introduces Redisson as a Redis‑based locking library, provides Maven and YAML configuration, shows Java code for Redisson setup and test cases, and analyses the underlying Lua scripts and source‑code mechanisms.
Redis is a high-performance, open-source in-memory key-value database offering rich data structures, persistence options, and advanced features like replication, clustering, and pub/sub, making it ideal for caching, counters, message queues, leaderboards, and session storage in demanding, high-concurrency applications.
This article explains how Redis 7.0.11’s multithreading mode is enabled through two configuration options, describes when the mode is activated or deactivated based on client write‑backlog, and outlines the read and write processing flow in multithreaded and single‑threaded stages.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, integration steps, core source code, and a cache‑penetration solution using BitMap hashing.
This guide demonstrates how to integrate Spring Boot 2 with OAuth2 for unified authentication, configure a Redis-backed token store, implement a resource server with custom security settings, and test protected endpoints, providing complete code snippets and configuration details.
This article introduces Redis as an open‑source in‑memory key‑value store, explains its data‑structure server nature, outlines common deployment options—including single instance, high‑availability, Sentinel, and Cluster—describes replication mechanisms, and details persistence models such as RDB, AOF, and hybrid approaches.
This article examines data consistency between Redis cache and MySQL database, explains common cache execution strategies such as Cache‑Aside, Read‑Through, Write‑Through, and Write‑Behind, analyzes four update sequences for consistency risks, and proposes solutions like delayed double‑delete, transactional guarantees, retry mechanisms, and binlog‑based cache invalidation.
This article examines the challenges of scaling inventory pre‑allocation in fast‑growing logistics platforms, outlines architectural principles for a lightweight, Redis‑driven solution that replaces MySQL bottlenecks, details data structures, consistency mechanisms, and performance results, and provides a roadmap for future capacity growth.
This tutorial walks through creating a full‑featured OAuth2 authorization server using Spring Boot 2.4.12, storing tokens in Redis, defining client and user entities in MySQL, configuring grant types, and testing the authorization, password, client‑credentials, and implicit flows.
This article explains how to leverage Redis Set, Sorted Set, Bitmap, and HyperLogLog data structures for various statistical scenarios such as user sign‑in tracking, friend recommendations, comment ranking, and UV counting, while addressing performance and memory considerations.
This article introduces Alibaba's JetCache Java caching framework, explains how to combine local and Redis remote caches for multi‑level caching, provides Maven dependencies, configuration examples, three usage patterns (AOP, API, advanced API), testing steps, and common troubleshooting tips for Spring Boot projects.
This comprehensive guide explains Redis fundamentals, its rich data types, differences from Memcached, thread model, persistence mechanisms (AOF, RDB, hybrid), memory eviction policies, clustering for high availability, cache design patterns, distributed locking, Redlock algorithm, and practical techniques for identifying and safely deleting big keys.
This article explains how to create Redis‑based distributed locks, discusses common pitfalls such as deadlocks and accidental deletions, and provides practical solutions including atomic expiration commands, Lua scripts, and a complete Redisson Java example for acquiring and releasing locks safely.
This article explains how to prevent duplicate API calls and achieve idempotency in Spring Boot 3.0.5 by using unique tokens, timestamps, or Spring AOP, and provides complete code examples for custom annotations, AOP aspects, interceptors, and Redis‑based token management.
During a Redis 3.x cluster master‑slave failover, the default Jedis connection timeout of two seconds combined with six automatic retries caused each request’s Redis calls to accumulate up to sixty seconds of latency, triggering Nginx timeouts and a service‑avalanche, which was resolved by lowering timeout and retry settings.
This article examines three practical approaches for preventing external exposure of specific APIs—service isolation, gateway‑based Redis whitelist, and gateway‑plus‑AOP—evaluates their trade‑offs, and provides step‑by‑step Java code to implement the preferred AOP solution in a Spring Cloud environment.
This article presents a full set of Java backend interview questions—ranging from self‑introduction and challenging projects to abstract classes, HashMap internals, B+‑tree characteristics, MySQL vs. skip‑list indexing, Redis skip‑list usage, large‑table optimization, join queries, JVM memory model, and Survivor space—along with detailed English explanations and sample code.
Redis 7.2, the first Unified Redis Release, introduces extensive AI support, vector database capabilities, scalable search, server‑side Triggers and Functions, enhanced geospatial queries, performance‑boosted sorted sets, and the Redis Data Integration tool, while expanding client and protocol compatibility.
The article explains why rate limiting is essential for high‑traffic Spring Boot services, compares counter, sliding‑window, token‑bucket and leaky‑bucket algorithms, demonstrates implementations with plain Java, Guava RateLimiter, AOP, and distributed approaches using Redis‑Lua and Nginx‑Lua, and provides practical configuration examples.
This guide explains why API rate limiting is essential, outlines common algorithms, and walks through three practical implementations in Spring Boot 3—using Guava, Spring Cloud Gateway with RedisRateLimiter, and a custom annotation‑based solution with Redis backing.
This article explains how Redis handles memory exhaustion by distinguishing expiration and eviction policies, detailing the maxmemory setting, enumerating all eviction strategies—including LRU and LFU algorithms—and showing how to view and modify these policies for optimal cache performance.
This article analyzes the high‑concurrency contract‑query workload of JD Logistics, examines call sources, query dimensions and volume patterns, and proposes a three‑layer protection architecture—Bloom filter, Redis cache, and database fallback—along with strategies for cache penetration, breakdown, and avalanche mitigation.
Redis 7.2, the first Unified Redis Release, introduces AI‑ready vector indexing, hybrid semantic search, scalable RAG support, server‑side Triggers and Functions, enhanced geospatial queries, and a preview of high‑performance searchable indexes, while expanding client library support and integrating Redis Data Integration for seamless enterprise data pipelines.
This report details the design, deployment, and extensive performance testing of a Miop protocol‑based push service, describing the test environment, methodology, multi‑stage load tests up to one million concurrent connections, observed metrics, encountered issues, and recommendations for ensuring stability and scalability.
This article explains how to leverage Redis data structures such as Set, Sorted Set, Bitmap, and HyperLogLog to perform aggregation, sorted, binary‑state, and cardinality statistics efficiently in large‑scale applications, while addressing performance considerations and practical implementation details.
This article explains how to achieve idempotent order creation and updates in backend services by using unique request identifiers, database unique constraints, Redis flags, and optimistic locking with version columns, while also addressing the ABA problem with practical code examples and diagrams.
This article explains what Redis bigkeys are, their impact on performance and memory, how they are generated, methods to detect and analyze them—including built‑in commands, SCAN, memory usage, and RDB file inspection—and practical steps to mitigate their effects.
To improve stability and reduce costs during high‑traffic events, we replaced the Zookeeper‑dependent TBSchedule framework with a lightweight, Redis‑based distributed scheduler that decentralizes task execution, uses thread pools instead of timers, and supports dynamic scaling and seamless degradation for reliable order processing.
This article explains PHP data caching techniques—including memory, file, and database caches—provides practical code samples, and outlines key index design principles such as uniqueness, expiration, hotspot optimization, efficient updates, and hierarchical caching to improve performance.
This article explains the concept of idempotency, identifies naturally idempotent HTTP methods, discusses why idempotency is essential for retries, async callbacks, and message queues, and provides a complete Spring Boot implementation using a custom @Idempotent annotation, AOP, and Redis for token storage.
This article explains the common reasons why Redis performance degrades—such as network latency, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, and memory fragmentation—and provides detailed optimization and troubleshooting steps to restore low latency.
The article explains that Redis achieves exceptional performance through four main factors—its in‑memory storage, optimized data structures, a single‑threaded architecture, and non‑blocking I/O—detailing how each contributes to speed and efficiency.
The article explains why using the KEYS command on a large Redis dataset can block the server, introduces the SCAN command as a non‑blocking alternative with cursor‑based iteration, and provides usage examples and best‑practice tips for safely listing prefixed keys.
This article explains the concept of distributed global unique identifiers, outlines four essential characteristics of such IDs, and provides a detailed comparison of five generation schemes—UUID, database‑generated IDs, Redis, Zookeeper, and Snowflake—highlighting their advantages, drawbacks, and suitable use cases.
This article details the end‑to‑end high‑availability architecture—including dual‑center Elasticsearch clusters, Redis caching with distributed locks, and a dual‑center MySQL partitioned setup—that enables a membership platform serving billions of users to sustain massive traffic while ensuring data consistency and rapid recovery.
This article provides a detailed backend interview cheat‑sheet covering Redis data structures and performance issues, MySQL indexing and transaction principles, operating‑system process and thread concepts, TCP/UDP networking differences, and common Java garbage‑collection algorithms, all illustrated with examples and code snippets.
This article explains the importance of rate limiting in microservice systems, compares various governance frameworks such as Dubbo and Spring Cloud, and provides detailed implementations using Guava, Sentinel, Redis+Lua scripts, and a custom Spring Boot starter, complete with code examples and deployment steps.
This article walks through the importance of rate limiting in microservice architectures, compares Dubbo, Spring Cloud, and gateway approaches, explains token‑bucket, leaky‑bucket and sliding‑window algorithms, and provides step‑by‑step AOP implementations using Guava, Sentinel, and Redis with full code samples.
This article explains the Redis Sorted Set data type, its underlying storage mechanisms (listpack and skiplist + dict), the internal structures and algorithms, and demonstrates how to build a real‑time game leaderboard using ZADD, ZRANGE and ZREVRANK commands.
This article explains why API idempotency is crucial in real‑world systems, outlines which operations need it, discusses the trade‑offs of adding idempotency, and presents four practical implementation patterns—including unique primary keys, optimistic locking, anti‑duplicate tokens, and downstream sequence numbers—complete with SpringBoot code examples.
This article explains how Redis stores set and sorted‑set objects using dual encodings—intset vs hashtable for sets and skiplist vs ziplist for sorted sets—detailing their internal structures, upgrade mechanisms, configuration thresholds, and the essential commands for manipulating these data types.
This guide explains why distributed locks are needed, how to correctly acquire and release them, compares Redis and Zookeeper implementations—including single‑master, Redlock, and Zookeeper approaches—and offers practical recommendations for ensuring atomicity, preventing deadlocks, and protecting shared resources in production environments.
This guide walks through the background, implementation, usage examples, and step‑by‑step open‑source contribution process for adding Redis cache expiration and memory‑limit chaos experiments to the ChaosBlade platform, including code snippets, Git workflow, and testing procedures.
This article explains how to design and implement a microservice permission system using Apache Shiro, Spring Boot, Dubbo, and Redis, covering challenges of integrating Shiro with gateways, shared session management, custom Cache and SessionDAO implementations, and provides complete code examples and configuration details.
This article dissects ten common traps when implementing Redis distributed locks—such as non‑atomic setnx/expire, missing expirations, lock release ordering, non‑re‑entrancy, master‑slave replication issues, and the Redlock algorithm—while providing concrete code examples and practical remedies.
A service‑wide avalanche occurred when a Redis 3.x master‑slave failover coincided with Jedis’ default 2‑second connection timeout and six retry attempts, causing up to 60‑second latencies; adjusting connectionTimeout, soTimeout to 100 ms and reducing maxAttempts to two limited latency to about one second and prevented cascade failures.
This article explains the typical reasons why a Redis instance becomes slow—such as high latency, expensive commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, and memory fragmentation—and provides concrete diagnostics and optimization steps to resolve each issue.
This article provides a detailed interview recap covering Redis in‑memory database concepts, MySQL transaction and indexing fundamentals, OSI network layers, operating‑system memory layout, Java versus Go differences, and key takeaways for future study, all aimed at backend developers.
This article provides Python code examples for using Redis as a database—including connection, basic CRUD, list and sorted set operations, key expiration, publishing/subscribing, distributed locking, and caching—followed by a detailed comparison of Redis and MySQL across data model, persistence, query capabilities, performance, scalability, and transaction support.
Learn how to use Redis with Python for basic CRUD, list and sorted‑set manipulation, key expiration, Pub/Sub messaging, distributed locks, and caching, and understand when Redis is a suitable complement or alternative to MySQL based on data model, performance, and transaction needs.
This article explains how the WeChat multi‑dimensional monitoring platform, which processes billions of data points daily, identified performance bottlenecks in its Druid‑based data layer and applied sub‑query splitting, Redis caching, and sub‑dimension tables to achieve over 85% cache hit rate and bring average query time down to around 100 ms.
The article describes how a membership system serving billions of users across multiple platforms achieves high performance and high availability through dual‑center Elasticsearch clusters, traffic‑isolated three‑cluster ES architecture, Redis caching with distributed locks, dual‑center MySQL partitioning, and fine‑grained flow‑control and degradation strategies.
This article walks through Redis's evolution from a simple single‑instance cache to a highly available, high‑performance cluster, explaining persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel automatic failover, and sharding strategies with concrete examples and trade‑offs.
Ximalaya’s KV storage progressed from a simple Redis master‑slave setup to client‑side sharding, then adopted Codis clustering for elastic scaling, integrated Pika’s disk‑based store with cold‑hot separation, introduced KV‑blob separation, fast‑slow command pools, second‑level expansion, ehash fields, large‑key circuit breaking, multi‑active data‑center replication, and now targets cloud‑native deployment, advanced features, and AI‑driven operations.
This article explains why rate limiting is essential for distributed systems, compares it with circuit breaking and smoothing, outlines a generic limiting workflow, and provides complete Java implementations of four algorithms—fixed window, sliding window, leaky bucket, and token bucket—using Redis and Redisson.
This article outlines the design goals, architecture, and implementation details of a high‑performance distributed caching solution for Spring Boot applications, combining Redis as a first‑level cache with Caffeine as a second‑level cache, and provides configuration, usage examples, and future enhancement plans.
The article explains Redis’s set and sorted‑set data structures, detailing how sets use intset or hashtable encodings and how sorted sets employ skiplist or ziplist encodings, including the conditions for each encoding, the underlying C structs, upgrade processes, and common Redis commands.
This article explains how large hotel‑booking platforms such as Airbnb, Booking.com and OYO use a micro‑service architecture—including hotel management, customer search/booking, and view‑booking services—combined with load balancers, Kafka, Elasticsearch, Redis, Cassandra and Hadoop to achieve a seamless, high‑throughput booking flow.
This article explains why rate limiting is needed in high‑traffic backend services, outlines common methods such as token‑bucket with Guava, Redis‑based counters, Nginx configuration, and thread‑pool limits, and provides complete Java code examples for implementing each approach.
This article explains Redis as an in‑memory key‑value NoSQL database, outlines its data types and high‑availability features, and details common cache problems such as avalanche, penetration and breakdown along with practical mitigation strategies, followed by interview commentary on how to discuss Redis effectively.
Explore comprehensive strategies for implementing rate limiting in Java microservice architectures, covering Dubbo and Spring Cloud governance, token bucket, semaphore, Sentinel, Redis+Lua, and custom Spring Boot starter solutions, complete with code samples, configuration steps, and performance testing guidance.
Redis implements approximate LRU and LFU eviction policies by sampling keys and using a compact 24‑bit field to store timestamps and counters, where LRU evicts the least recently accessed items and LFU evicts those with low, decay‑adjusted access frequency, each with trade‑offs for different workloads.
This article explains how to achieve efficient pagination and multi‑condition fuzzy searches in Redis by leveraging Sorted Sets for ordered paging, Hashes with HSCAN for pattern matching, and combining both techniques with caching and expiration strategies to optimize performance.
This article explains how to install and configure Redis, connect to it using Python's redis library, and demonstrates storing and retrieving various data structures—including strings, hashes, lists, sets, and sorted sets—followed by proper disconnection, providing a practical guide for Python developers.
This guide walks through building a SpringBoot architecture that updates MySQL first, deletes Redis cache asynchronously via Canal and RabbitMQ, resolves common Canal meta‑data mismatches, and configures manual RabbitMQ acknowledgments to guarantee reliable cache invalidation.
This guide walks through essential Redis operations, covering real‑time monitoring with the INFO command and Prometheus‑compatible exporters, data migration using Redis‑shake, consistency verification via Redis‑full‑check, and comprehensive cluster management with CacheCloud, providing practical tools for reliable Redis administration.
This article provides an in‑depth tutorial on designing and implementing various rate‑limiting strategies—such as token bucket, leaky bucket, and sliding window—in Java microservice architectures, with practical code examples using Guava, Sentinel, Redis+Lua, and a reusable Spring Boot starter.
This article explains why rate limiting is critical for microservice architectures, reviews common limiting algorithms, and provides step‑by‑step implementations using Dubbo, Spring Cloud, Guava token‑bucket, Sentinel, Redis+Lua, and a reusable Spring Boot starter with custom annotations and AOP.
This article explains how to protect high‑concurrency Java applications using rate‑limiting techniques, covering basic algorithms such as counter, leaky‑bucket and token‑bucket, demonstrating a single‑node implementation with Guava’s RateLimiter and custom annotations, and showing a distributed solution based on Redis and Lua scripts.
This article explains how to implement API rate limiting in PHP by connecting to Redis, defining a RateLimiter class with limitRequests method, and demonstrates usage to restrict requests per time window, while detailing the underlying logic and code examples.
This guide explains why Logstash may import fewer rows from a large PostgreSQL table into Elasticsearch, and provides two practical solutions—ID comparison via shell scripts and accelerated comparison using Redis—to quickly identify and resolve data inconsistencies.
This article explains the Bloom filter data structure, its space‑efficient probabilistic nature, common scenarios such as cache‑bypass and URL deduplication, and provides practical Java Guava and Redis module implementations with code examples.
This article examines the common consistency challenges between Redis cache and MySQL, explains why strict consistency is hard to achieve, and presents four practical approaches—cache‑first delete, delayed double delete, DB‑first update with lock, and MQ‑based retry—to minimize inconsistency windows and ensure reliable data synchronization.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article demonstrates how to use Redis as a database with Python code examples for basic operations, advanced features like pub/sub and distributed locks, and compares Redis to MySQL across data model, persistence, query capabilities, performance, scalability, and transaction support.
This article explains how to use Redis sets, sorted sets, lists, bitmaps, and HyperLogLog to perform aggregation, ordered queries, binary state tracking, and cardinality estimation for large‑scale applications such as sign‑in systems, e‑commerce comments, and social‑network friend lists.
This article examines various order timeout handling techniques in e‑commerce, detailing JDK’s DelayQueue, RabbitMQ delayed messages, RocketMQ timer‑wheel, Redis expiration listeners, and distributed batch processing with SchedulerX, comparing their advantages, drawbacks, and suitability for different latency and scale requirements.
This article explains how Redisson extends Redis to provide a rich set of distributed Java objects and services, walks through integrating Redisson into a Spring Boot project, demonstrates various lock types (reentrant, read‑write, semaphore, latch) with code examples, and details the internal watchdog mechanism that guarantees atomic lock acquisition and automatic renewal.
This article reviews the latest Mica releases, highlighting version compatibility with Spring Boot, new Redis and XSS features, core utility enhancements, bug fixes, and upcoming support for Spring Boot 3.1.x, providing developers with a concise overview of the library’s recent advancements.
Aeraki Mesh 1.3.0 (code‑named Dragonboat) adds Istio 1.16.x compatibility, introduces connection multiplexing, enables MetaProtocol routing on gateways, expands Dubbo service governance options, provides Redis traffic management, and migrates official images to GitHub Packages, with a detailed changelog and configuration examples.
This article explains Redis’s persistence mechanisms—including RDB snapshots, AOF append‑only logs, and the hybrid approach—detailing how to enable each method, their commands, configuration options, performance trade‑offs, rewrite processes, and recovery procedures to help you choose the right strategy for reliable data durability.
A detailed investigation reveals that excessive Redis latency was caused by misconfigured JedisPool parameters, leading to long connection wait times and frequent connection churn, and shows how adjusting pool settings dramatically improved response times and overall system performance.
This article analyzes why Redis's increment operation returns null when used inside a Spring @Transactional method with transaction support enabled, details the debugging steps, experiments, and presents two practical solutions to prevent the issue.
This article explains Redis Pub/Sub fundamentals, demonstrates channel‑based and pattern‑based subscription with command‑line examples, dives into the internal data structures that power them, and shows how to integrate Redis Pub/Sub in Spring Boot using Redisson for lightweight messaging.
This article explains how to implement efficient pagination and multi‑condition fuzzy queries in Redis using Sorted Sets and Hashes, outlines the underlying commands, discusses combining both techniques, and offers optimization strategies such as expiration handling to maintain cache performance.
This article explains three progressively refined approaches to caching paginated list data—directly caching whole pages, caching individual object entries after querying ID lists, and caching both ID lists and object entries—highlighting trade‑offs, implementation details, and performance considerations using Java and Redis.
This article explains how Redis Sentinel provides automated failover, details the replication process that keeps master and slave data synchronized, and compares the roles of master‑slave replication, Sentinel, and Redis Cluster in achieving high availability and horizontal scalability.
This article explains how to limit the number of requests an API endpoint can receive within a specified time window by creating a @RequestLimit annotation, a Redis‑backed interceptor, and the necessary Spring Boot configuration and controller examples.
Redis is an open‑source, in‑memory key‑value store written in C that uses hash tables, various data structures, and a single‑threaded event loop to achieve high performance, and this article explains its basic types, persistence mechanisms (AOF and RDB), replication, sentinel failover, and cluster sharding.
This article explains how to set up and use ThinkPHP 6’s email queue functionality, covering Redis installation, queue configuration, creating a SendMailJob class, pushing jobs to the queue, and running the queue listener to improve email sending performance and reliability.
This guide demonstrates how to create a powerful web-based Redis CRUD interface by integrating Django for the backend API, MySQL for metadata storage, and Vue for a responsive frontend, covering environment setup, project scaffolding, model and view implementation, routing, and deployment steps.
This article provides a comprehensive overview of Redis's ten data types—including strings, hashes, lists, sets, sorted sets, streams, hyperloglog, geospatial, bitmap, and bitfield—detailing their structures, encoding mechanisms, application scenarios, and underlying implementation details with code examples.
This article explains why publicly exposed APIs are vulnerable, describes the concepts of anti‑tampering and anti‑replay protection, and provides a complete Spring Boot implementation—including request signing, timestamp and nonce validation, and Redis‑based replay detection—to safeguard API endpoints.
