This article walks through the complete process of implementing a custom login authentication in Spring Boot, including custom authentication filters, success/failure handlers, a token stored in Redis, role‑based URL security, and detailed configuration of Spring Security headers and session handling.
This article analyzes why Lettuce's mget on Redis Cluster performs poorly due to slot-based architecture, presents client-side refactoring using hashtags and pipeline‑based JedisCluster modifications, and shows benchmark results demonstrating up to double speed improvement over Lettuce.
In his first 2024 blog post, Redis founder antirez shares a programmer's perspective on large language models, sharply critiques Google's search engine, evaluates current AIGC as both foolish and historically knowledgeable, and argues that generative AI mainly amplifies the abilities of already strong developers.
This article explains cache prewarming—its purpose, benefits, and various strategies such as startup loading, scheduled tasks, manual triggers, and cache loaders—while providing concrete Spring Boot and Redis examples, including code snippets for ApplicationReadyEvent, CommandLineRunner, InitializingBean, @PostConstruct, @Scheduled, and Caffeine cache loader.
This article explains why Redis traditionally operates with a single thread, how its memory‑centric design, simple data structures and I/O multiplexing keep it fast, and why newer Redis versions introduced multithreading for network I/O and lazy deletion of large keys.
This article covers Java backend architecture fundamentals, including front‑end/back‑end separation, Maven configuration, distributed lock implementations with Redis and Zookeeper, session handling in distributed systems, database locking strategies, and useful code snippets for common patterns.
A sudden Redis outage caused a shopping homepage to take 20 seconds to load, prompting a rapid analysis of data‑volume growth, a post‑mortem of the fallback logic, and the design of a combined local‑cache, MongoDB, and database strategy to restore fast, reliable service.
This article explains how to prevent API abuse by using a Spring Interceptor combined with Redis to count requests per IP and URI, demonstrates step‑by‑step code implementations, discusses custom annotations, mapping rules, time‑window challenges, path‑parameter handling, and real‑IP extraction for robust backend rate limiting.
This article reveals the most common Redis pitfalls—including unexpected key expiration loss, O(1) commands that block or cause OOM, master‑slave synchronization quirks, and persistence bugs—while providing practical guidance to avoid each issue and keep your cache performant and reliable.
The article analyzes the inventory oversell problem caused by concurrent purchase requests and presents four backend solutions—including a Redis distributed lock, MySQL row lock, optimistic locking with version fields, and conditional SQL updates—illustrated with Java code and SQL examples to ensure data consistency.
This article explains Redis's two persistence mechanisms—Append Only File (AOF) and RDB snapshots—detailing their operation, advantages, risks, write‑back strategies, rewrite process, and how to choose the appropriate method for performance and reliability requirements.
This article explains two API rate‑limiting strategies—fixed‑window using Redis keys and sliding‑window using Redis sorted sets—detailing their principles, drawbacks, and providing complete Java implementations with Lua scripts, AOP annotations, and Redis configuration to enforce request limits.
This guide explores ten practical Redis scenarios—including login authentication, counters, fan following, leaderboards, anti‑scraping, message queues, browser history, distributed locks, user sign‑in tracking, and website UV statistics—showcasing commands and patterns to boost performance in real‑world applications.
Redis is an open‑source, in‑memory NoSQL database that provides ultra‑fast key‑value storage, rich data structures, persistence, clustering and extensible modules, making it the preferred distributed cache over Memcached, which lacks these features and is now rarely chosen for new projects.
This article presents a concise Spring Cloud microservice architecture diagram, explains each component such as DNS, CDN, LVS, Nginx, Nacos, Sentinel, Redis, and Elasticsearch, and offers practical guidance on their roles, selection criteria, and implementation details for interview preparation.
This article explains three Spring Boot approaches—using @Scheduled tasks, RabbitMQ delayed queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with code samples and configuration guidance.
This article explains how KeyDB, a Redis fork, redesigns the single‑threaded key‑value store into a multi‑threaded system, covering its thread model, connection management, fastlock mechanism, and active‑replica features while maintaining full Redis API compatibility.
This article explains the core design goals, sharding strategies, replication models, communication protocols, cache selection, and monitoring techniques needed to build high‑performance, highly available, and scalable distributed cache systems for large‑scale internet applications.
This article provides a step‑by‑step guide to implementing custom login authentication in a Spring Boot application, including Redis‑backed session storage, token handling, security headers, and fine‑grained role‑based URL permission checks using custom filters and handlers.
This article explains how to use Spring Boot Security for authentication and improve performance by caching user details in Redis, covering dependency setup, security configuration, Redis integration, testing endpoints, and optimization tips for a robust backend authentication solution.
This article explains how to migrate a specific Redis database (db8) to another server's db15 by writing a Python script that batches keys, tracks progress, estimates remaining time, and verifies the migration results.
This article demonstrates step‑by‑step how to prevent API abuse in a Spring MVC application by using an Interceptor combined with Redis for counting requests, customizing limits per endpoint through annotations and reflection, handling mapping rules, path‑parameter challenges, and obtaining the real client IP.
This article compares delayed tasks with scheduled tasks and presents six practical Java solutions—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, Redis key‑space notifications, and RabbitMQ delayed queues—detailing their implementations, advantages, and drawbacks for handling order‑timeout scenarios.
This article introduces Redis Stack’s RedisJSON module, explains its JSONPath syntax, details the full set of JSON commands for handling various data types, provides practical code examples, and highlights how RedisJSON enables Redis to function as a document, full‑text, and vector search database.
A Redis lock timeout caused users to be blocked for two hours, revealing problems with lock leakage and mis‑release; the article explains the root causes, proper use of SETNX with EXPIRE, and Lua scripts for atomic operations and safe lock deletion.
RedisInsight is a GUI for Redis that monitors memory, connections, hit rate, and uptime, supports clusters, SSL/TLS, and key editing, and can be installed on Linux via a downloadable package with environment variables and launched as a service, or deployed on Kubernetes using a NodePort service and a Deployment of the redislabs/redisinsight image, after which the UI provides metrics, data editing, and memory analysis.
This article explores Redis's capabilities beyond simple caching, detailing its use for distributed locks, rate limiting, session storage, complex business scenarios, and various messaging patterns—including List‑based queues, blocking commands, Pub/Sub, and the Stream data structure—while highlighting practical limitations and best‑practice recommendations.
This article introduces Redis, explains its key advantages as an in‑memory data store, provides step‑by‑step installation instructions for CentOS including required packages, and demonstrates basic commands to start the server and interact with the database.
This article explains why duplicate form submissions occur, the risks they pose, and demonstrates a Spring Boot solution that uses a custom @RequestLock annotation together with Redis SETNX to generate a unique key and block rapid repeated requests, complete with project setup, code examples, and usage instructions.
Redis implements its own Simple Dynamic String (SDS) instead of plain C strings because SDS stores length for O(1) queries, pre‑allocates extra space and lazily reuses freed bytes, prevents buffer overflows, handles binary data, and uniformly backs all string keys, values and container elements.
This article walks through the design of a billion‑user group chat platform, covering functional and non‑functional requirements, core components, database schema, face‑to‑face group creation, message flow, storage strategies, and performance‑optimizing techniques such as clustering, message queues, multithreading, and Redis caching.
Salvatore Sanfilippo, a self‑taught hobbyist who launched Redis in 2009, broke traditional database rules by building an in‑memory NoSQL system, sharing his open‑source philosophy, and shaping a thriving community that powers companies like Uber, Slack, and Twitter.
This article explains how to implement API request rate limiting in Spring Boot by creating a custom @RequestLimit annotation, using Redis to track request counts, and configuring a HandlerInterceptor and WebMvcConfig to enforce limits on controller methods.
This article explains how to design and implement a token generation, storage, and verification system for both PC and mobile clients in a distributed microservice architecture, using Spring Boot, Redis, custom annotations, AOP aspects, and Vue front‑end integration.
This tutorial demonstrates how to use Docker‑Compose to deploy a Redis exporter, configure Prometheus to collect its metrics, and define alerting rules for Redis health monitoring, providing step‑by‑step commands and YAML examples for a complete monitoring setup.
This article compiles a comprehensive set of ByteDance daily internship interview questions covering Java backend fundamentals, networking protocols, operating system concepts, Linux process management, Redis data structures and persistence, MySQL indexing and query optimization, as well as essential algorithms, providing detailed explanations and code examples for each topic.
This article explains how to design and implement a distributed rate‑limiting solution that supports multiple concurrent rules—such as per‑minute and per‑hour limits—by analyzing the shortcomings of simple string counters, introducing atomic Lua scripts and Zset structures, and providing complete Java annotation and AOP code examples.
This article explains how KeyDB, a multithreaded fork of Redis, restructures the original single‑threaded design by introducing worker threads, per‑thread connection handling, a fastlock spin‑lock implementation, and an active‑replica feature that enables writable replicas with conflict‑resolution using timestamped keys.
This guide walks through Redis fundamentals, covering how data persists after restarts, core key operations, database selection, serialization, expiration handling, key movement, random retrieval, renaming, and how to check the number of configured databases, all with practical command examples and visual illustrations.
Jedis uses Apache Commons’ GenericObjectPool to manage Redis connections, with Spring‑Data‑Redis creating a JedisConnectionFactory that holds a configurable pool where borrowObject and returnObject handle idle queues, eviction and validation settings (testOnBorrow, testWhileIdle, etc.) can be tuned, and JMX metrics aid troubleshooting.
This article walks through a real‑world sales‑ranking scenario, explains why a simple SQL solution falls short at scale, and demonstrates how Redis Set and ZSet data structures provide high‑performance, real‑time ranking, including detailed command examples, performance metrics, and an in‑depth look at ZSet's internal listpack and skiplist‑dict implementations.
Learn how to generate text embeddings with OpenAI's ChatGPT API, store them in Redis' vector database, and perform efficient similarity searches using PHP, covering installation, API calls, index creation, vector storage, KNN querying, and practical code examples.
The article explains how to handle the most complex part of an e‑commerce order flow—stock deduction under high concurrency—by using JVM and distributed locks, Redis atomic operations, two‑phase commit, hot‑cold routing, fault tolerance, and cache rebuilding strategies.
This guide introduces RedisSearch, walks through installation, explains its rich feature set, details core concepts like data models and indexing, shows command‑line operations for creating indexes and querying, and provides a complete PHP example for integrating RedisSearch into applications.
This article compiles essential backend interview questions and answers covering MySQL storage engines and indexes, Redis persistence modes, Java collection frameworks and HashMap internals, thread‑safe ConcurrentHashMap implementations, as well as HTTP message structure and TCP reliability mechanisms, providing a thorough review for candidates preparing for backend positions.
The article explains the concept of delayed tasks versus scheduled tasks in payment systems, outlines their key differences, and evaluates five practical implementation approaches—Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET/Keyspace notifications, and RabbitMQ delayed queues—detailing their code examples, advantages and drawbacks.
This article explains why traditional file uploads struggle with large files, then introduces three advanced techniques—instant (秒传), chunked (分片上传), and resumable (断点续传) uploads—detailing their core logic, implementation steps, and Java code examples for backend developers.
KeyDB is a high‑performance, multithreaded fork of Redis that retains full protocol compatibility while adding features like Active Replication, flash storage support, and advanced locking, offering up to double the query throughput and reduced latency on the same hardware.
This article explains the concept of idempotency, presents several strategies to achieve it, and provides a complete Spring Boot implementation using Redis, a custom @AutoIdempotent annotation, token generation and verification, interceptor configuration, and test cases to ensure only the first request succeeds.
This article presents a complete solution for reliable, resumable file upload and download over MQTT in distributed IoT platforms, leveraging FastDFS for storage and Redis for caching file metadata and progress, detailing the architecture, data structures, and handling of packet fragmentation, offsets, and cluster coordination.
This guide explains how to set up Redis Stack with Docker, covering its components, available images, commands to pull and run the containers with volume mounts and port mappings, configuration file details, and how to access RedisInsight for visual data management.
This article explores how counters, especially 24‑bit timestamps, are employed in Redis’s LRU eviction algorithm and other memory‑constrained scenarios, detailing implementation tricks, precision trade‑offs, and practical code examples for efficient cyclic counters and compact storage techniques.
This article explains how to determine whether Redis is truly experiencing latency spikes, outlines a step‑by‑step benchmarking process, identifies common causes such as high‑complexity commands, big keys, memory limits, fork overhead, AOF settings, CPU binding, swap usage, and provides concrete configuration and code examples to resolve each issue.
RediSearch, a low‑memory Redis module, offers comparable full‑text search capabilities to Elasticsearch, with faster indexing and query performance on modest hardware; this article explains its features, compares benchmarks, shows Docker installation, and provides Java/Jedis code examples for creating, querying, and managing indexes.
This article explains the concept of idempotency, outlines common strategies, and provides a complete Spring Boot implementation that uses Redis, a custom @AutoIdempotent annotation, token generation, and a web interceptor to ensure each API request affects the database only once.
Redis serves as a powerful in‑memory key‑value store for distributed caching, offering various data structures, persistence options, deployment modes, eviction policies, and update strategies, while addressing consistency challenges, cache miss scenarios, and failure modes such as penetration, breakdown, and avalanche.
This article introduces the Lock4j distributed lock library for Java, outlines its key features and supported backends, provides step‑by‑step Maven dependency setup, Redis configuration, annotation details, and demonstrates both basic and advanced usage patterns including custom executors and lock‑failure strategies.
This article explains the fundamentals of finite state machines, introduces Spring Statemachine, shows how to define states, events, and transitions for an order lifecycle, demonstrates memory and Redis persistence, provides full Java code for controller, service, listeners, and discusses testing, error handling, and AOP logging.
The article presents a collection of typical Java backend coding mistakes—ranging from misused ternary operators and poor parameter validation to logging pitfalls, dead code, improper exception handling, AOP self‑invocation issues, Redis resilience problems, and Excel file upload bugs—along with concrete examples, images, and corrected code snippets to help developers avoid and fix them.
This article presents a concise tutorial on building a flash‑sale (Seckill) system with SpringBoot, MySQL, Redis, RabbitMQ and a basic HTML/JQuery front‑end, covering architecture, key features, code snippets, over‑selling prevention, rate limiting, and deployment screenshots.
This article walks through a production incident where a Redis Cluster pipeline caused Dubbo threads to block and eventually deadlock, detailing the root‑cause analysis, code inspection, and verification steps using jstack, jmap, and MAT to confirm the deadlock and propose fixes.
This guide walks through installing the open‑source JumpServer bastion host on a Kubernetes cluster using Helm, configuring external MySQL and Redis databases, customizing Helm values, and exposing the web UI through an Istio gateway for secure access.
The article details a step‑by‑step investigation and optimization of a Java backend service that initially delivered only 50 requests per second under load, covering profiling, slow‑SQL fixes, thread‑pool tuning, JVM memory adjustments, and Spring bean creation overhead to approach the target 500 req/s.
This article provides a comprehensive overview of Redis, covering its architecture, key features, data types, caching use cases, common pitfalls such as consistency, avalanche, penetration and breakdown, as well as performance reasons, eviction policies, persistence options, replication, and Sentinel high‑availability mechanisms.
This article walks through the full engineering process of importing a billion 1 KB log records into MySQL, covering data size calculations, B‑tree index limits, batch‑insert strategies, storage‑engine trade‑offs, fast file‑reading techniques, task coordination with Redis and Redisson, and distributed‑lock design using Zookeeper.
This article explains Redis persistence options, detailing how the Append‑Only File (AOF) and snapshot (RDB) mechanisms work, their write‑back strategies, log rewriting process, and the trade‑offs between performance and reliability for choosing the appropriate approach.
This article explains how to use Redis BitMap to build an efficient sign‑in feature and monthly statistics in a Spring Boot microservice, covering basic BitMap commands, key design, code implementation, testing procedures, and a cache‑penetration mitigation strategy.
To import one billion 1 KB log records into MySQL efficiently, the article examines data size constraints, B‑tree index limits, batch insertion strategies, storage engine choices, file‑reading techniques, task coordination with Redis, Redisson semaphores, and distributed lock handling to ensure ordered, reliable, high‑throughput loading.
This tutorial walks you through creating mount directories, configuring redis.conf, running a Redis container with Docker, and verifying the setup using redis-cli and a visual client, providing all necessary commands and explanations for a successful deployment.
Hot keys in Redis—high‑frequency accessed keys—can overload the cache and downstream databases, causing crashes; this article explains what hot keys are, why they arise, their risks, how to detect them, and practical mitigation strategies such as scaling clusters, using secondary caches, monitoring commands, and traffic analysis.
This article explains how to use Redis' Sorted Set and Hash structures to achieve efficient pagination, multi‑condition fuzzy queries, and their combination, while also discussing performance optimizations such as expiration handling and data synchronization strategies.
This article details the design and implementation of a self‑managed Redis KV cache system spanning tens of terabytes, covering its Proxy‑based architecture, ConfigServer high‑availability via Raft, Redis‑Proxy slot routing, async‑fork optimizations, data migration strategies, and a comprehensive automation platform for deployment, scaling, monitoring, and stability governance.
This article explains how to design microservice permission control using Apache Shiro, sharing session data via Redis, outlines failed approaches, presents a workable solution with custom cache and session managers, and provides complete code examples for realms, configuration, and login flow.
An in‑depth, timeline‑driven investigation of a production Redis memory leak revealed that the custom 3.2.8 build’s getKeysInSlot function failed to free a temporary key‑array after traversing the radix‑tree, causing hundreds of megabytes of leaked SDS strings, which was fixed by adding a single free call and highlighted the need for functional code reviews and early leak detection.
This comprehensive guide walks you through setting up Spring Security in a Spring Boot project, configuring password encoding, implementing JWT-based authentication, building custom login and logout endpoints, managing user details with MyBatis Plus, and applying role‑based access control with custom permission handlers, all illustrated with complete code examples.
This article explains why Redis may become slower, covering benchmark testing, high‑complexity commands, big keys, concentrated expirations, memory limits, fork overhead, huge pages, AOF settings, CPU binding, swap usage, memory fragmentation, and lazy‑free mechanisms, and provides practical optimization steps.
This article explains how Redis can be used for distributed locks, rate limiting, various message‑queue patterns, delayed queues, distributed sessions and complex business scenarios, while also discussing the limitations of using Redis as a message queue and recommending dedicated solutions like RocketMQ or Kafka.
This article explains how to implement a memory-efficient sign-in system and continuous-sign-in statistics using Redis BitMap, covering basic BitMap commands, Spring Boot integration, core source code, and a BitMap-based approach to mitigate cache-penetration attacks.
This guide explains how to build a dynamic IP blacklist using Nginx, Lua, and Redis, covering installation of LuaJIT, compiling Nginx with required modules, configuring Redis, writing Lua access‑limit scripts, and verifying that frequent requests are automatically blocked for a set period.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
This article analyzes a coupon‑claiming race condition that caused stock to become negative under load and presents four solutions—including Java synchronized blocks, SQL conditional updates, Redis SETNX locks, and Redisson client locks—to reliably prevent over‑issuance in backend systems.
This article explains how to achieve conditional fuzzy queries and pagination in Redis by leveraging Sorted Sets and Hashes, detailing command usage, data modeling, combination strategies, and performance optimizations such as expiration and real‑time updates.
This article explains how to implement cross‑platform caching in PHP using both file‑based storage and Redis, providing complete code examples and detailing the functions involved to ensure compatibility, performance, and proper cache expiration handling.
Redis‑On‑Rocks (ROR) extends the Redis codebase with RocksDB to provide cold‑hot data tiering, reducing memory costs by about two‑thirds while maintaining low latency and high throughput, and the article details its design, implementation, benchmarking against Redis‑on‑Flash, and production experience.
The article explains what constitutes a big key in Redis, why they arise, the performance and blocking issues they cause, and provides multiple practical methods—including built‑in commands, SCAN, MEMORY USAGE, RDB analysis tools, and cloud services—to detect and mitigate big keys effectively.
This article explains what Redis hotkeys are, the performance and replication problems they cause, various techniques for detecting them—including client statistics, MONITOR, the HOTKEYS command, and TCP packet capture—and practical mitigation approaches such as sharding, multi‑level caching, and monitoring optimization.
To achieve disaster-recovery and cross-data-center resilience, Didi progressed from a simple proxy double-write scheme to a sophisticated MQ-free multi-active Redis design that uses a dedicated syncer, shard-based loop prevention, op-id replay protection, conflict detection, and incremental AOF durability, ensuring low latency, no data loss, and consistent availability.
This article details the design and implementation of a Java‑based flash‑sale (Seckill) system using SpringBoot, Redis, RabbitMQ, and related technologies, covering architecture, security, caching, asynchronous processing, oversell prevention, and rate‑limiting techniques.
This comprehensive guide covers essential programming fundamentals—including Python memory management, metaclasses, decorators, multithreading, data structures, algorithmic techniques, database concepts such as ACID, indexing, and transaction isolation, Redis operations, Linux memory handling, networking protocols, Docker/Kubernetes commands, and core testing methodologies—providing clear explanations and practical code examples.
This article explains how Redis evolved from a simple cache to a high‑performance distributed data store, covering its architecture, persistence models, scalability, high‑availability features, complex data structures, and the trade‑offs of using it as a primary database versus a traditional relational system.
This step‑by‑step guide shows how to download, configure, and launch SkyWalking with Spring Boot, connect it to Elasticsearch, instrument a sample service and Redis calls, and view real‑time monitoring data through the SkyWalking UI and Kibana.
The incident showed that Redis hashes encoded as ziplist incur O(N) HEXISTS latency, causing high CPU on hot keys, while hashtable‑encoded hashes remain O(1); adjusting hash‑max‑ziplist settings or redesigning hot‑key patterns can convert to faster, though more memory‑hungry, hashtable encoding.
This article explains various PHP caching techniques—including file‑system, memory (Memcache and Redis), and framework (Laravel) caches—providing code examples and configuration steps to reduce database load, speed up page rendering, and enhance overall user experience.
This article explains why traditional local locks fail in distributed systems, surveys common distributed‑lock approaches, and provides a step‑by‑step guide to building a robust Redis‑based lock in Java—including expiration handling, UUID safety, Lua‑script atomicity, re‑entrancy, automatic renewal, and the RedLock algorithm—while comparing its performance against plain local locks.
This article examines the benefits and drawbacks of implementing caching in PHP backend development, illustrating how caching can boost page load speed, reduce database load, and improve performance, while also discussing cache expiration, data consistency, and memory usage, accompanied by practical code examples.
This article explains how to integrate Lua scripts into Spring Boot projects for Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation with code examples, error handling, security considerations, and best‑practice recommendations for backend developers.
This article explains how Redis data structures such as SortedSet, Hash, and List can efficiently store and retrieve live‑stream room rankings, count‑type data, timeline events, and multi‑device IM message synchronization, with concrete command examples and implementation steps.
This article explains how Redis implements geospatial indexing with GEOADD and GEORADIUS commands, walks through their source‑code implementations, describes the underlying geohash calculations and nine‑cell grid search strategy, and derives the O(N + log M) time complexity for nearby‑people queries.
This article analyzes the constraints of loading one billion 1 KB log records from distributed storage into MySQL, evaluates single‑table limits, proposes batch‑insert, sharding, storage‑engine, file‑reading, and distributed‑task coordination techniques to achieve high‑speed, ordered, and reliable data ingestion.
This article examines why local locks fail in distributed micro‑service environments, introduces Redis‑based distributed locking, walks through five incremental lock designs—from a simple SETNX implementation to a Lua‑script atomic solution—highlighting each scheme's trade‑offs, code examples, and practical pitfalls.
