This article reviews essential Redis string concepts, covering typical interview questions, encoding types, the EMBSTR threshold, SDS structure, and memory allocation details to help readers solidify their understanding of Redis string implementation.
This article explains three practical Redis‑based rate‑limiting methods—using SETNX, ZSET sliding windows, and a token‑bucket algorithm with List—complete with Java code examples and a discussion of their advantages and drawbacks.
This article presents a comprehensive backend architecture for flash‑sale systems, covering Nginx static‑dynamic separation, Redis‑based rate limiting and distributed locks, MQ buffering, database sharding, safety protections, page optimization, and detailed Nginx configuration examples to handle massive concurrent traffic.
This article explains Redis eviction policies such as allkeys‑lru, volatile‑ttl, and others, discusses how the eviction process works, and provides practical solutions for cache penetration, breakdown (stampede), and avalanche, including Bloom filters, mutex locks, and randomized TTLs.
This article explains how to design an effective multi-level caching system in a microservice environment, covering client‑side browser caching, application‑layer CDN and Nginx caching, and service‑layer in‑process and distributed caches, along with consistency strategies and practical deployment examples.
This tutorial walks through the evolution from manual Redis calls to Spring Cache abstraction, explains AOP‑based proxying, details core annotations, demonstrates Caffeine and Redisson integration, explores list caching, and shows how to build a custom two‑level cache for high‑performance Java back‑ends.
This tutorial explains how to implement a like/unlike feature using Spring Boot, Redis caching, and periodic persistence to a database with Quartz, covering data modeling, key design, service layers, controller APIs, and scheduled synchronization.
This guide walks developers through transforming a single‑node Redis cache into a stable, high‑performance cluster by explaining data persistence options (RDB, AOF, hybrid), master‑slave replication, Sentinel‑driven automatic failover, and both client‑side and proxy‑based sharding for horizontal scalability.
This article explains why the Lettuce asynchronous Redis client, built on Netty, outperforms the traditional Jedis client for high‑concurrency caching, covering Redis client differences, Netty NIO fundamentals, Redis Cluster architecture, smart client redirection handling, and practical Java code examples.
This article compares two Redis‑based delayed‑queue approaches—listening to key‑space expiration events and using Redisson’s built‑in delayed queue—detailing their principles, Spring Boot demos, pitfalls, and why Redisson offers a more reliable solution for distributed applications.
This article explains the complete user login process, including mobile verification, token generation, token expiration policies, request‑rate limiting with Redis, anonymous request handling, blacklist management, and provides full Java Spring code examples for implementing these backend authentication mechanisms.
This article walks through installing Docker and Docker‑Compose, creating a project directory, writing a docker‑compose.yml that defines Redis, MySQL, Nginx, Java, and a file‑preview service, configuring each container, and using docker‑compose commands to build, start, monitor, and manage the full SpringBoot‑Vue application stack.
Tencent’s QQ reminder subscription push system combines push‑pull prefetching, heterogeneous MySQL/Redis storage, delayed‑queue triggers, Redis‑based rate‑limiting, task scattering, message‑queue decoupling, at‑least‑once delivery, and dual‑replica disaster recovery within a dispatcher‑worker architecture to ensure reliable, controllable, low‑latency mass notifications.
This article explains why Redis is essential for flash‑sale (秒杀) systems, detailing the load characteristics, the three sale phases, stock‑checking and decrement strategies, atomic operations, distributed locks, data modeling, and practical deployment recommendations for high‑concurrency back‑end services.
This article explains Redis's Append‑Only File (AOF) rewrite mechanism, detailing how the rewrite buffer is defined, the fork‑based background process, inter‑process pipe communication, and the advantages and drawbacks of AOF rewriting, accompanied by relevant source code snippets.
This article explains Redis's internal memory architecture, details the various memory components such as used_memory, object memory, client buffers, and fragmentation, and provides practical optimization techniques and real‑world case studies to reduce memory usage and improve performance.
This article explains the three main Redis cache anomalies—cache avalanche, cache penetration, and cache breakdown—detailing their symptoms, root causes, and practical mitigation strategies with Java code examples and architectural recommendations.
This article explains various methods to monitor Redis key changes—including using the MONITOR command, configuring keyspace event notifications, and parsing AOF files with optional timestamps—detailing their setup, advantages, limitations, and practical code examples for accurate change tracking in production environments.
This article examines a business requirement to filter and rank up to 100,000 records from a pool of tens of millions, presenting and evaluating four technical solutions—multithreaded ClickHouse pagination, Elasticsearch scroll‑scan deep paging, an ES‑HBase combined query, and a RediSearch + RedisJSON approach—along with performance data and code examples.
Redis version 7.0.8 has been released, addressing critical security vulnerabilities (CVE-2022-35977 and CVE-2023-22458) and fixing several bugs related to command handling, incremental rehashing, timeout blocking, and sentinel IP changes, with a full changelog available on GitHub.
RedisObject serves as a bridge between Redis's external data structures and internal implementations, enabling efficient storage and retrieval of data types like strings, lists, hashes, sets, and sorted sets through a unified object model.
This article explains two sliding‑window rate‑limiting methods for SMS sending—one based on IP address and another on phone number—and provides a complete PHP implementation using Redis sorted sets to enforce per‑minute, per‑10‑minute, and per‑hour limits.
This guide explains essential Redis monitoring metrics, the tools and commands for collecting performance, memory, activity, persistence, and error data, and shows how to use INFO, slowlog, and redis-benchmark to assess and improve database operations.
This comprehensive guide walks you through Spring Security fundamentals, setting up a Spring Boot project, configuring authentication with JWT and Redis, implementing RBAC permission management, customizing error handling, enabling CORS, and addressing CSRF, providing complete code examples and detailed explanations for secure backend development.
This guide explains how to install, configure, and run a lightweight Redis Monitor that visualizes connection count, QPS, memory usage and replication delay, supports standalone, sentinel and cluster modes, and provides email and WeChat alerts via simple PHP scripts.
This article analyzes the limitations of traditional HTTP session mechanisms in single‑server and clustered environments, explains why session sharing is essential for multi‑system products, and presents practical solutions such as session replication and centralized Redis storage, followed by a detailed walkthrough of CAS‑based single sign‑on implementation with Java Spring code examples and a comparison to OAuth2.
This article explains why Redis is essential for flash‑sale systems, detailing load characteristics, the three sale phases, Redis features such as high concurrency and atomic operations, and practical implementations using Lua scripts and distributed locks to ensure safe stock checking and deduction.
This article explains the fundamentals, characteristics, and use‑cases of distributed caching, compares Memcached and Redis, and provides a step‑by‑step Spring Boot implementation with code samples, testing guidance, and solutions to common cache pitfalls such as hot keys, penetration, and avalanche.
Facing a four‑hour coupon‑calculation bottleneck at eLong, I explored Storm’s stream‑processing model, identified the data‑extraction stage as the weak link, refactored the hotel‑pull service, leveraged RocketMQ for threading, and ultimately reduced full‑batch processing time to just over an hour.
This article explores sixteen practical Redis patterns—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, queues, lotteries, likes, tags, product filtering, follow relationships, and leaderboards—detailing their data types, commands, and code examples for building high‑performance systems.
This article explains how Redis implements the Pub/Sub messaging pattern by storing subscription relationships in hash‑based dictionaries, detailing the processing flow of SUBSCRIBE and PUBLISH commands, cluster propagation, and key limitations such as lack of persistence and client buffer constraints.
This article provides a comprehensive overview of Redis persistence mechanisms, detailing the concepts, features, advantages, disadvantages, trigger strategies, operational processes, configuration options, and troubleshooting steps for both RDB (snapshot) and AOF (append‑only file) approaches.
This article provides a comprehensive overview of Redis, covering basic concepts, pipeline optimization, publish/subscribe messaging, key expiration strategies, transaction behavior, persistence mechanisms (RDB, AOF, hybrid), distributed locking techniques, Redisson and Redlock algorithms, as well as high‑availability setups using replication, Sentinel and Cluster modes.
This comprehensive guide covers Redis fundamentals, pipeline, pub/sub, expiration strategies, transactions, persistence mechanisms, distributed lock implementations, and the three clustering modes, while also addressing common cache problems and practical deployment steps.
This article explains how to replace manual cache handling with Spring Cache annotations, introduces the concepts of L1 (Caffeine) and L2 (Redis) caches, discusses design considerations for consistency, null handling, eviction, and provides practical Maven and configuration examples for Java backend applications.
This article explains how Redis achieves high performance by storing data in memory and using a variety of specialized data structures—such as SDS, quicklist, listpack, hash tables, and skip lists—to implement its key‑value store, covering their designs, trade‑offs, and evolution across Redis versions.
This article explains why modern internet products need caching to handle massive real‑time data, introduces Redis as an in‑memory database with persistence, master‑slave replication, and clustering, and demonstrates how these techniques dramatically improve performance, scalability, and reliability of web services.
This article explains Redis String data type usage, the Simple Dynamic String (SDS) implementation details, memory‑saving techniques, encoding options, and demonstrates a practical distributed ID generator built with Redis commands and persistence strategies.
This article clarifies the common misconception that Redis is purely single‑threaded by detailing its single‑threaded network I/O model, the evolution of multithreading support across versions, the client‑server request flow, and the underlying Reactor patterns that enable efficient concurrency.
This article details the requirements analysis, design approach, database schema, and step‑by‑step implementation of a follow/unfollow microservice using MySQL for persistence and Redis Sets for efficient set operations, including Maven dependencies, Spring Boot configuration, RedisTemplate setup, service, controller, and testing of common‑follow queries.
This article walks through the complete design and implementation of a friend‑follow microservice, covering requirement analysis, MySQL table schema, Redis set operations, Spring Boot dependencies, configuration, service and controller code, gateway routing, and end‑to‑end testing with concrete examples and performance insights.
This article explains why short-lived JWT tokens need automatic renewal, outlines a Redis‑based solution, and provides complete Spring interceptor and utility code to create, verify, and refresh tokens without forcing users to re‑login frequently.
This article compares three popular Java Redis clients—Jedis, Lettuce, and Redisson—detailing their advantages, drawbacks, and recommended usage scenarios, helping developers select the most suitable client based on performance, thread safety, and advanced Redis features such as clustering, sentinel, and distributed locks.
This comprehensive guide explores Redis fundamentals and advanced features, covering pipelines for reduced RTT, publish/subscribe messaging, key expiration strategies, transaction behavior, persistence mechanisms (RDB, AOF, hybrid), distributed locking techniques, sentinel high‑availability, and cluster sharding, with practical code examples and diagrams.
The article explains how to improve large file upload experiences by using instant (MD5‑based) upload, chunked upload, and resumable upload techniques, and provides complete Java backend implementations with Redis tracking, RandomAccessFile and MappedByteBuffer, plus practical deployment recommendations.
This article explains why a custom business rate‑limiting (risk‑control) component is needed for AI‑driven services, compares open‑source solutions, and provides a complete implementation using Redis+Lua scripts, Kotlin code, and Spring AOP annotations, including testing and deployment tips.
This article explains why a business needs its own risk‑control (rate‑limit) component, compares open‑source options, and provides a complete Kotlin/Spring implementation using Redis Lua scripts, annotations, and AOP to enforce real‑time adjustable limits.
This article explains common Redis caching issues—cache penetration, cache breakdown, and cache avalanche—detailing their causes and practical mitigation techniques such as parameter validation, null caching, Bloom filters, mutex locks, hot‑data strategies, and staggered expiration to ensure system stability.
This article analyzes the functional decomposition, data structures, system architecture, push‑pull mode selection, and message flow of a one‑to‑one instant messaging service, providing practical design guidelines and example Redis/MySQL schemas for building a scalable chat backend.
This article explains the concept of distributed locks, illustrates real‑world scenarios such as concurrent ATM transactions, and details how to implement reliable distributed locking with Redis using TTL keys, SETNX, Lua scripts, lock renewal, high‑availability considerations, and the RedLock algorithm.
This article breaks down the functional requirements, data models, layered architecture, push‑pull messaging choices, and message flow for building a robust one‑to‑one instant‑messaging service using Redis, MySQL and asynchronous queues.
This article explains three common Redis cache issues—penetration, breakdown, and avalanche—detailing their causes and offering practical solutions such as parameter validation, empty-value caching, Bloom filters, mutex locks, and staggered expiration to keep systems reliable under heavy load.
This guide details Alibaba Cloud Redis development standards, including readable key naming, value size limits, safe command usage, client connection pooling, eviction policies, useful tooling, and efficient big‑key deletion methods, helping engineers build high‑performance, reliable Redis services.
This article explains how to protect time‑consuming business operations using a Redis‑based distributed lock, detailing the annotation design, AOP pointcut, lock acquisition and release, timeout handling, and a scheduled renewal mechanism with sample Java code.
This article presents a comprehensive analysis and multiple design alternatives—including multithreaded ClickHouse pagination, Elasticsearch scroll‑scan, ES+HBase hybrid, and RediSearch+RedisJSON—to efficiently filter, sort, and de‑duplicate up to 100,000 records from a pool of tens of millions, with detailed performance comparisons and code examples.
This article walks through the design and implementation of a friend‑follow microservice using MySQL for persistence, Redis Sets for fast set operations, and Spring Boot, covering requirement analysis, data modeling, dependency setup, configuration, service logic, and testing with concrete code examples and performance insights.
Learn how to efficiently store and query massive binary state data—such as user login status and daily sign‑in records—using Redis Bitmap, covering underlying structures, memory advantages, key design, and practical commands like SETBIT, GETBIT, BITCOUNT, BITPOS, and BITOP for real‑world analytics.
This article examines ten common traps when implementing Redis distributed locks—ranging from non‑atomic setnx/expire operations and missing expirations to lock release ordering, re‑entrancy, master‑slave replication issues, and the Redlock algorithm—providing concrete code examples, explanations, and best‑practice solutions.
This article analyzes the latency spikes observed in large‑scale Redis clusters after node expansion, identifies the CLUSTER SLOTS command and slot‑migration handling in hiredis‑vip and Jedis as the root cause, proposes a slot‑traversal optimization, and demonstrates a ten‑fold performance improvement with detailed benchmarks.
This article describes a Redis 5.0 memory leak scenario where 20 million keys with expiration caused memory not to be released, details the investigation steps, findings about the activeExpireCycle, and concludes that memory will eventually be freed, followed by a promotional announcement for a PHP online live class.
This article explains Redis's three clustering approaches—master‑slave replication, Sentinel, and native Cluster—detailing their architectures, replication mechanisms, advantages, disadvantages, and suitable scenarios for high‑availability and high‑concurrency database deployments.
This article explains cache penetration scenarios, outlines Redis memory eviction strategies, introduces RedisBloom's Bloom filter and Cuckoo filter for detecting illegal requests, provides configuration details, and demonstrates practical commands to mitigate cache penetration in backend systems.
This article explores the challenges of cache‑database consistency under the cache‑aside pattern, compares four cache‑update strategies, and provides practical techniques—including delayed double delete, MQ‑driven invalidation, and binlog subscription—to achieve near‑real‑time consistency while maintaining high read performance.
This guide explains the fundamental dimensions of rate limiting, compares token‑bucket, leaky‑bucket, and sliding‑window algorithms, and details practical implementations using Guava, Nginx, Redis, and Sentinel for both single‑node and distributed systems.
This article explains how Redisson provides Redis‑based distributed locks, covering atomic lock acquisition via Lua scripts, lease time handling, watchdog auto‑extension, re‑entrant and fair locks, read‑write locks, multi‑lock batching, and the RedLock algorithm for high‑availability scenarios.
This article explains how to design and implement a friend/follow microservice using MySQL for persistence and Redis sets for efficient set operations, covering database schema, Spring Boot configuration, Redis template setup, service and controller logic, and testing of follow, unfollow, and mutual‑follow features.
This article explains how to design the storage layer for an e‑commerce shopping cart, covering core functionalities, required attributes, client‑side temporary storage, server‑side persistence options with MySQL and Redis, and the trade‑offs between reliability, performance, and complexity.
This article explains three common inventory‑deduction strategies for e‑commerce—single‑field MySQL, multi‑row MySQL, and Redis incrby—analyzes their drawbacks under high concurrency, and provides a complete Redis‑Lua based solution with distributed locking, including full Java code examples for the callback interface, stock service, and controller.
This article explains the fundamentals of caching, why caches (especially Redis) are essential for high‑performance and high‑concurrency scenarios, describes local, distributed, and multi‑level cache architectures, outlines their pros and cons, and provides practical implementation guidance.
This article provides a step‑by‑step tutorial on creating a SpringBoot demo that integrates Apache HttpClient for GET/POST requests, handles token acquisition and caching with Redis, optimizes configuration via application.yml, and implements distributed locking and Guava‑based rate limiting for high‑concurrency scenarios.
This article shares common pitfalls of Java candidates, emphasizes building a solid Java foundation, and provides a curated collection of over 100 interview questions covering Spring, Redis, MyBatis, and multithreading, with a QR code for accessing the full answer set.
IntelliJ IDEA 2022.3 introduces a refreshed UI, a universal Settings Sync solution, native WSL 2 project handling, enhanced Spring Bean autowiring, OpenAPI generation, full Redis support, improved intent previews, Search Everywhere, Java 19 features, Maven plugin changes, and numerous editor and user‑experience refinements, all aimed at boosting developer productivity.
This article explains the fundamental concepts of rate limiting, reviews popular algorithms such as token bucket, leaky bucket, and sliding window, and details practical implementation methods across single‑machine and distributed environments using tools like Guava, Nginx, Redis, and Sentinel.
This article explains how Redis achieves high availability through master‑slave replication, automatic failover with Sentinel, and true sharding with Redis Cluster, while also comparing popular sharding solutions such as client‑side hashing, Twemproxy, and Codis.
This article explains how to design and implement a friend follow microservice by combining MySQL for persistent storage with Redis sets for efficient follow/unfollow operations and mutual follow queries, covering database schema, Maven dependencies, Spring Boot configuration, RedisTemplate setup, service and controller logic, and testing procedures.
This article explains how to identify Redis latency problems, measure baseline performance, monitor slow commands, and address common causes such as network RTT, forked RDB snapshots, transparent huge pages, swap usage, AOF configuration, key expiration bursts, and big keys, providing practical solutions and a checklist for remediation.
This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the client with enums, implementing a connection pool using r2d2, creating a global singleton with once_cell, and providing example code for querying and storing data.
This article explains how to integrate Redis into a Rust backend by defining resource structs, wrapping the redis‑rs client, implementing a connection manager for r2d2, creating a global singleton pool with OnceCell, and demonstrating basic CRUD operations through example code.
The article explains why traditional auto‑increment primary keys are unsuitable for distributed systems, outlines the key requirements for a distributed identifier, and reviews several practical generation schemes—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID—along with their advantages, drawbacks, and sample implementations.
This article explains why distributed systems need special ID generation, outlines the key requirements such as global uniqueness and monotonicity, and compares various solutions including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID.
This article explains how a large‑scale membership system achieves high performance and high availability by using a dual‑center Elasticsearch cluster, traffic‑isolated three‑cluster architecture, Redis caching with dual‑center clusters, and a MySQL partitioned dual‑center setup, while also detailing optimization, migration, and fine‑grained flow‑control strategies.
This article explains the fundamental concepts of Redis cluster architecture, covering high‑availability with Sentinel, data partitioning methods, proxy‑based sharding techniques, the mechanics of Redis Cluster without a central node, and practical considerations for multi‑key operations in a distributed environment.
This comprehensive guide explains what Redis is, its core data structures, typical scenarios such as caching, counters, message queues and leaderboards, installation steps on Linux, configuration options, advanced features like pipelines, Lua scripting, persistence mechanisms, replication, caching strategies, consistency challenges, and distributed locking techniques.
This article provides an in‑depth overview of Redis, covering its single‑threaded architecture, core data structures (String, Hash, List, Set, ZSet), persistence mechanisms (RDB, AOF, hybrid), replication, Sentinel and cluster designs, memory eviction policies, bitmap analytics, skiplist implementation, and strategies for ensuring data consistency.
This article explains Redisson's role as a Java in‑memory data grid built on Redis, compares it with Jedis and Lettuce, and details how Redisson implements distributed locks—including simple lock/unlock, Lua‑based reentrant locks, automatic lock renewal (WatchDog), and a fair lock using Redis lists and sorted sets—providing complete code examples and execution flow.
This article explains why distributed ID generation is essential for modern micro‑service architectures, outlines the key requirements such as global uniqueness and monotonicity, and compares popular solutions like UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID with practical code examples.
This article explains the problem of cache penetration, introduces Bloom filters as a space‑efficient probabilistic data structure to block invalid queries, demonstrates implementations using Guava and Redis with Java code, analyzes false‑positive rates, and discusses practical application scenarios and performance testing results.
This article introduces Redis’s evolution, key features for distributed locking, explains lock and unlock workflows with Jedis, presents Java code examples, discusses pitfalls like non‑atomic operations, and offers configuration and performance tuning tips for reliable, high‑availability lock services.
This article explains cache penetration, introduces Bloom filters as a space‑efficient probabilistic data structure, demonstrates how to implement them with Guava and Redis in Java, and discusses practical usage scenarios and performance considerations.
This article investigates a production issue where Redis increment operations return null each morning, explores hypotheses about Redis pipelines, transactions, and Spring @Transactional interaction, reproduces the bug, analyzes the source code, and proposes two practical solutions to prevent null returns.
This article explains how to determine whether Redis is truly experiencing latency issues, outlines benchmark testing methods, identifies common causes such as network problems, high‑complexity commands, big keys, slow logs, memory limits, fork overhead, AOF configuration, swap usage, fragmentation, and provides practical troubleshooting and optimization steps.
A production microservice failed each morning because Redis's increment operation returned null when generating IDs, and restarting the service temporarily fixed it; the article investigates the root cause—Redis transaction support combined with Spring @Transactional—and presents two concrete remediation strategies.
Redis 6.0 implements several compact data structures—SDS, ziplist, quicklist, hash, set, and ZSet—each optimized for memory efficiency and performance, and this guide explains their definitions, internal layouts, usage scenarios, and key implementation details such as packing attributes, incremental rehashing, and skiplist operations.
This post shares a free, extensive compilation of interview questions and detailed explanations covering Java fundamentals, multithreading, Spring framework, Redis, MyBatis and other backend technologies, encouraging systematic preparation and offering a QR‑code method to obtain the full document.
Redis achieves high speed by keeping data in memory, but to avoid data loss it offers two persistence methods—RDB and AOF; this article explains RDB’s snapshot mechanism, the SAVE vs BGSAVE commands, copy‑on‑write handling, automatic save configuration, and the internal structures that drive periodic backups.
This article explains why database selection is critical, outlines the evolution and types of databases, presents a methodology for evaluating requirements, and reviews Volcengine's cloud database offerings to help you pick the most suitable solution for OLTP workloads.
The article explains what Redis bigkeys are, why they arise, the performance and availability problems they cause, and presents practical detection methods and optimization techniques—including key splitting, tool improvements, and migration safeguards—to help DBAs and developers prevent and resolve bigkey‑related incidents.
The article explains how using a Redis cache can boost read performance but introduces consistency challenges, compares four cache‑aside write strategies, and recommends the reliable “update database then delete cache” approach combined with short expiration times and asynchronous message‑queue invalidation to keep data fresh.
This article examines the evolution of Redis’s persistence mechanisms—from early RDB snapshots and AOF logging to recent innovations such as Baidu Cloud’s forkless RDB implementation, mixed RDB/AOF formats, and Multi‑AOF architectures—detailing design principles, version milestones, and practical performance optimizations.
This article explains why MySQL's count(*) can become a performance bottleneck, especially with InnoDB, and presents practical optimization techniques such as Redis caching, second‑level in‑memory caches, parallel execution, reducing unnecessary joins, and using column‑store databases like ClickHouse.
