BestHub
Sign in
Tagged articles

Redis

3508 articles · Page 17 of 36
Aikesheng Open Source Community
Aikesheng Open Source Community
Dec 19, 2022 · Databases

Using Redis Bloom Filter to Prevent Cache Penetration and Understanding Redis Memory Eviction Policies

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.

Bloom filterCache PenetrationRedis
0 likes · 10 min read
Using Redis Bloom Filter to Prevent Cache Penetration and Understanding Redis Memory Eviction Policies
dbaplus Community
dbaplus Community
Dec 18, 2022 · Backend Development

Mastering Cache Consistency: Strategies to Keep Redis and MySQL in Sync

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.

Cache AsideCache ConsistencyMySQL
0 likes · 17 min read
Mastering Cache Consistency: Strategies to Keep Redis and MySQL in Sync
Java High-Performance Architecture
Java High-Performance Architecture
Dec 15, 2022 · Backend Development

How to Build a High‑Performance Follow Service with MySQL, Redis, and Spring Boot

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.

Follow ServiceJavaMySQL
0 likes · 19 min read
How to Build a High‑Performance Follow Service with MySQL, Redis, and Spring Boot
JavaEdge
JavaEdge
Dec 14, 2022 · Backend Development

Designing Scalable Shopping Cart Storage: Principles and Choices

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.

Data synchronizationMySQLRedis
0 likes · 12 min read
Designing Scalable Shopping Cart Storage: Principles and Choices
Top Architect
Top Architect
Dec 14, 2022 · Backend Development

Implementing Inventory Deduction and Preventing Overselling in E‑commerce with MySQL and Redis

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.

InventoryRedisdistributed lock
0 likes · 10 min read
Implementing Inventory Deduction and Preventing Overselling in E‑commerce with MySQL and Redis
Top Architect
Top Architect
Dec 14, 2022 · Backend Development

Cache Basics: Concepts, Types, Advantages, and Implementation Strategies

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.

Multi-Level CacheRedisdistributed cache
0 likes · 10 min read
Cache Basics: Concepts, Types, Advantages, and Implementation Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Dec 14, 2022 · Backend Development

Comprehensive Guide to Building a SpringBoot Backend with HttpClient, Token Management, Redis Caching, and Rate Limiting

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.

HttpClientJavaRedis
0 likes · 22 min read
Comprehensive Guide to Building a SpringBoot Backend with HttpClient, Token Management, Redis Caching, and Rate Limiting
Java Architect Essentials
Java Architect Essentials
Dec 11, 2022 · Industry Insights

What’s New in IntelliJ IDEA 2022.3? A Deep Dive into UI, Redis, and Java Enhancements

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.

IDEIntelliJ IDEAJava
0 likes · 9 min read
What’s New in IntelliJ IDEA 2022.3? A Deep Dive into UI, Redis, and Java Enhancements
Java Captain
Java Captain
Dec 8, 2022 · Backend Development

Design and Implementation of a Friend Follow Microservice Using MySQL and Redis

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.

Follow FeatureJavaMySQL
0 likes · 15 min read
Design and Implementation of a Friend Follow Microservice Using MySQL and Redis
Sohu Tech Products
Sohu Tech Products
Dec 7, 2022 · Databases

How to Diagnose and Resolve Redis Performance Issues

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.

DatabaseOptimizationPerformance
0 likes · 18 min read
How to Diagnose and Resolve Redis Performance Issues
JD Tech Talk
JD Tech Talk
Dec 7, 2022 · Backend Development

Using Redis in Rust: Singleton Pattern and Connection Pooling with r2d2

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.

Connection PoolingRedisbackend-development
0 likes · 8 min read
Using Redis in Rust: Singleton Pattern and Connection Pooling with r2d2
Top Architect
Top Architect
Dec 6, 2022 · Backend Development

Distributed ID Generation: Principles, Requirements, and Common Solutions

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.

Redisbackenddistributed ID
0 likes · 13 min read
Distributed ID Generation: Principles, Requirements, and Common Solutions
Architect
Architect
Dec 5, 2022 · Backend Development

Distributed ID Generation: Requirements, Schemes, and 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.

Redisdistributed IDid generation
0 likes · 13 min read
Distributed ID Generation: Requirements, Schemes, and Implementations
Java High-Performance Architecture
Java High-Performance Architecture
Dec 5, 2022 · Backend Development

How to Build a High‑Performance, Highly Available Membership System with ES, Redis, and MySQL

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.

ElasticsearchMySQLRedis
0 likes · 21 min read
How to Build a High‑Performance, Highly Available Membership System with ES, Redis, and MySQL
Aikesheng Open Source Community
Aikesheng Open Source Community
Dec 1, 2022 · Databases

Understanding Redis Cluster Architecture: High Availability, Data Partitioning, and Proxy 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.

ClusterData PartitioningRedis
0 likes · 9 min read
Understanding Redis Cluster Architecture: High Availability, Data Partitioning, and Proxy Strategies
Tencent Cloud Developer
Tencent Cloud Developer
Dec 1, 2022 · Databases

Mastering Redis: From Basics, Installation to Advanced Features and Real‑World Use Cases

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.

Data StructuresDistributed LocksPerformance
0 likes · 64 min read
Mastering Redis: From Basics, Installation to Advanced Features and Real‑World Use Cases
Architect's Guide
Architect's Guide
Dec 1, 2022 · Databases

Comprehensive Guide to Redis: Architecture, Data Structures, Persistence, Replication, Clustering, and Advanced Features

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.

ClusteringData StructuresPersistence
0 likes · 27 min read
Comprehensive Guide to Redis: Architecture, Data Structures, Persistence, Replication, Clustering, and Advanced Features
Java Architect Essentials
Java Architect Essentials
Nov 30, 2022 · Backend Development

Understanding Redisson Distributed Locks: Architecture, Reentrancy, Fairness, and WatchDog Mechanism

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.

LuaRedisRedisson
0 likes · 31 min read
Understanding Redisson Distributed Locks: Architecture, Reentrancy, Fairness, and WatchDog Mechanism
Java High-Performance Architecture
Java High-Performance Architecture
Nov 28, 2022 · Backend Development

Mastering Distributed ID Generation: Strategies, Pros, and Code Samples

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.

Redisbackenddistributed ID
0 likes · 13 min read
Mastering Distributed ID Generation: Strategies, Pros, and Code Samples
Top Architect
Top Architect
Nov 27, 2022 · Fundamentals

Understanding Bloom Filters and Their Use in Preventing Cache Penetration

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.

Bloom filterCacheFalse positive
0 likes · 17 min read
Understanding Bloom Filters and Their Use in Preventing Cache Penetration
ITPUB
ITPUB
Nov 26, 2022 · Databases

Mastering Redis Distributed Locks with Jedis: A Step‑by‑Step Guide

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.

DatabaseJavaRedis
0 likes · 20 min read
Mastering Redis Distributed Locks with Jedis: A Step‑by‑Step Guide
Architect
Architect
Nov 25, 2022 · Fundamentals

Understanding Bloom Filters and Their Role in Preventing Cache Penetration

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.

Bloom filterCache PenetrationData Structures
0 likes · 17 min read
Understanding Bloom Filters and Their Role in Preventing Cache Penetration
Sanyou's Java Diary
Sanyou's Java Diary
Nov 24, 2022 · Backend Development

Why Does Redis Increment Return Null Inside @Transactional? The Hidden Interaction Explained

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.

RedisRedis TransactionTransactional
0 likes · 10 min read
Why Does Redis Increment Return Null Inside @Transactional? The Hidden Interaction Explained
政采云技术
政采云技术
Nov 24, 2022 · Databases

Is Redis Really Slowing Down? A Comprehensive Diagnosis and Optimization Guide

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.

DatabaseRedislatency
0 likes · 26 min read
Is Redis Really Slowing Down? A Comprehensive Diagnosis and Optimization Guide
dbaplus Community
dbaplus Community
Nov 23, 2022 · Backend Development

Why Redis Increment Returns Null with @Transactional and How to Fix It

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.

RedisTransactionalspring
0 likes · 10 min read
Why Redis Increment Returns Null with @Transactional and How to Fix It
Thoughts on Knowledge and Action
Thoughts on Knowledge and Action
Nov 23, 2022 · Databases

Inside Redis 6.0: Understanding SDS, Ziplist, Quicklist, and ZSet Data Structures

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.

Data StructuresRedisbackend development
0 likes · 16 min read
Inside Redis 6.0: Understanding SDS, Ziplist, Quicklist, and ZSet Data Structures
Java Captain
Java Captain
Nov 23, 2022 · Backend Development

Free Comprehensive Collection of Big‑Tech Interview Questions and Answers (Java, Spring, Redis, MyBatis, etc.)

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.

Interview QuestionsJavaMyBatis
0 likes · 8 min read
Free Comprehensive Collection of Big‑Tech Interview Questions and Answers (Java, Spring, Redis, MyBatis, etc.)
ITPUB
ITPUB
Nov 22, 2022 · Databases

How Redis RDB Works: Snapshotting, BGSAVE, and Copy‑On‑Write Explained

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.

BGSAVECopy-on-WriteDatabase
0 likes · 13 min read
How Redis RDB Works: Snapshotting, BGSAVE, and Copy‑On‑Write Explained
Architecture Digest
Architecture Digest
Nov 20, 2022 · Databases

Understanding and Mitigating Bigkey Issues in Redis Operations

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.

BigKeyDatabaseRedis
0 likes · 14 min read
Understanding and Mitigating Bigkey Issues in Redis Operations
Tencent Cloud Developer
Tencent Cloud Developer
Nov 18, 2022 · Backend Development

Cache Consistency Strategies and Best Practices

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.

Cache AsideMySQLRedis
0 likes · 20 min read
Cache Consistency Strategies and Best Practices
Baidu Intelligent Cloud Tech Hub
Baidu Intelligent Cloud Tech Hub
Nov 18, 2022 · Databases

Redis Persistence Evolution and Baidu Cloud’s Forkless & Multi‑AOF Optimizations

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.

AOFBaidu CloudPersistence
0 likes · 14 min read
Redis Persistence Evolution and Baidu Cloud’s Forkless & Multi‑AOF Optimizations
Su San Talks Tech
Su San Talks Tech
Nov 16, 2022 · Databases

Why count(*) Slows Down MySQL and How to Optimize It

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.

COUNTClickHouseMySQL
0 likes · 10 min read
Why count(*) Slows Down MySQL and How to Optimize It
vivo Internet Technology
vivo Internet Technology
Nov 16, 2022 · Operations

Understanding and Mitigating Bigkey Issues in Redis Operations

Bigkeys—Redis values over 1 MB or structures with more than 2,000 elements—cause memory imbalance, command blocking, network overload, and migration failures, so DBAs must detect them using built‑in commands or RDB analysis, split or partition oversized keys, and tune migration settings to preserve performance and availability.

BigKeyPerformanceRedis
0 likes · 14 min read
Understanding and Mitigating Bigkey Issues in Redis Operations
vivo Internet Technology
vivo Internet Technology
Nov 16, 2022 · Big Data

Vivo Hawking A/B Experiment Platform: Architecture, Practices, and Solutions

The Vivo Hawking platform provides a company‑wide, one‑stop A/B testing solution with a layered architecture, covariate‑balanced split algorithms, real‑time monitoring, and unified SDKs for Android, Java and H5, enabling thousands of daily experiments, automated analysis, and rapid product iteration across multiple departments.

Covariate balancingData PipelineExperiment Platform
0 likes · 22 min read
Vivo Hawking A/B Experiment Platform: Architecture, Practices, and Solutions
Architecture Digest
Architecture Digest
Nov 16, 2022 · Backend Development

Comprehensive Collection of Interview Questions and Answers for Major Tech Companies (Java, Spring, Redis, MyBatis, etc.)

This article compiles over a thousand interview questions and detailed explanations covering core Java fundamentals, multithreading, Spring framework, Redis, MyBatis, and related backend technologies, offering a free downloadable resource to help candidates prepare effectively for major tech company interviews.

Interview QuestionsJavaMyBatis
0 likes · 8 min read
Comprehensive Collection of Interview Questions and Answers for Major Tech Companies (Java, Spring, Redis, MyBatis, etc.)
Su San Talks Tech
Su San Talks Tech
Nov 16, 2022 · Databases

Why count(*) Is Slow in MySQL InnoDB and How to Speed It Up

This article explains why MySQL's count(*) can be slow on InnoDB, compares different count variations, and presents practical optimization techniques such as Redis caching, second‑level caches, multithreading, reducing joins, and using ClickHouse for massive datasets.

COUNTClickHouseInnoDB
0 likes · 12 min read
Why count(*) Is Slow in MySQL InnoDB and How to Speed It Up
Programmer DD
Programmer DD
Nov 14, 2022 · Backend Development

Choosing Between JWT and Session: Pros, Cons, and Implementation Guide

This article compares JWT and session authentication, outlines their differences, advantages, security considerations, performance impacts, and provides a complete Java implementation with Redis integration, helping developers decide the best approach for their projects.

AuthenticationJWTJava
0 likes · 16 min read
Choosing Between JWT and Session: Pros, Cons, and Implementation Guide
ITPUB
ITPUB
Nov 9, 2022 · Databases

Mastering Redis Persistence: RDB vs AOF Explained

This article provides a comprehensive guide to Redis persistence, covering the theory and configuration of both RDB snapshotting and AOF append‑only logging, their advantages, drawbacks, practical setup commands, recovery procedures, and performance‑tuning tips for reliable data durability.

AOFConfigurationPerformance
0 likes · 16 min read
Mastering Redis Persistence: RDB vs AOF Explained
21CTO
21CTO
Nov 8, 2022 · Operations

Building a Billion‑User Membership System: ES, Redis & MySQL High‑Availability

This article details how a large‑scale membership platform achieves high performance and near‑zero downtime by employing dual‑center Elasticsearch clusters, traffic‑isolated ES architectures, deep ES optimizations, Redis caching with distributed locks, and a seamless MySQL migration with partitioned, dual‑center databases.

OperationsRedisSystem Architecture
0 likes · 20 min read
Building a Billion‑User Membership System: ES, Redis & MySQL High‑Availability
Efficient Ops
Efficient Ops
Nov 7, 2022 · Operations

Essential Redis Monitoring Metrics and Commands for Effective Operations

This guide details key Redis monitoring metrics—including performance, memory, activity, persistence, and error indicators—along with practical commands, configuration settings, and code snippets to help operators efficiently track and troubleshoot Redis instances.

OperationsPerformanceRedis
0 likes · 6 min read
Essential Redis Monitoring Metrics and Commands for Effective Operations
Sanyou's Java Diary
Sanyou's Java Diary
Nov 7, 2022 · Backend Development

Is Redis a Viable Message Queue? List, Pub/Sub, and Stream Compared

This article examines whether Redis can serve as a reliable message queue by exploring its List, Pub/Sub, and Stream data types, comparing their features, performance, and limitations, and ultimately guiding readers on suitable use cases versus professional queue solutions.

Message QueueRedisStream
0 likes · 27 min read
Is Redis a Viable Message Queue? List, Pub/Sub, and Stream Compared
Java Architect Essentials
Java Architect Essentials
Nov 6, 2022 · Backend Development

Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java

This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.

AOPRedisScheduledExecutorService
0 likes · 12 min read
Implementing a Distributed Redis Lock with AOP and Automatic Renewal in Java
ITPUB
ITPUB
Nov 6, 2022 · Databases

Master‑Slave, Sentinel, and Cluster: Unlocking Redis High Availability

This guide explains Redis high‑availability mechanisms, covering master‑slave replication, the Sentinel monitoring and automatic failover process, and the Redis Cluster sharding architecture, including hash slots, MOVED/ASK redirection, gossip communication, and practical considerations such as data consistency, network partitions, and slot allocation.

ClusterGossipHash Slots
0 likes · 25 min read
Master‑Slave, Sentinel, and Cluster: Unlocking Redis High Availability
php Courses
php Courses
Nov 6, 2022 · Backend Development

Concepts, Principles, and Implementation Methods of Message Queues

This article explains the fundamentals of message queues, their typical use cases such as decoupling and traffic shaping, compares implementation options like MySQL, Redis, and dedicated message systems, and provides detailed PHP code examples for flash‑sale and RabbitMQ integrations.

PHPRedisflash sale
0 likes · 6 min read
Concepts, Principles, and Implementation Methods of Message Queues
Java High-Performance Architecture
Java High-Performance Architecture
Nov 4, 2022 · Backend Development

Mastering Distributed Locks with Redis: From Basic SetNX to Redisson’s Atomic Solutions

This article walks through the evolution of Redis-based distributed locking—from simple SETNX placeholders and manual expiration, through atomic SETNX EX, UUID‑based lock ownership, Lua‑scripted unlocks, and finally Redisson’s high‑level lock API—highlighting common pitfalls and robust solutions for backend developers.

JavaRedisRedisson
0 likes · 10 min read
Mastering Distributed Locks with Redis: From Basic SetNX to Redisson’s Atomic Solutions
Selected Java Interview Questions
Selected Java Interview Questions
Nov 2, 2022 · Backend Development

Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java Backend

This article explains various backend file upload techniques—including instant (秒传) transfer, chunked (分片) upload, and breakpoint resume—detailing their principles, Redis-based state tracking, and providing Java implementations using RandomAccessFile, MappedByteBuffer, and a slice upload template.

Chunked UploadJavaRedis
0 likes · 11 min read
Implementing Fast File Upload: Instant Transfer, Chunked Upload, and Resume Support in Java Backend
Qunar Tech Salon
Qunar Tech Salon
Nov 2, 2022 · Databases

Design of a Next‑Generation Qunar Database Automation Platform: Architecture, Communication Protocol, and Security

This article describes the layered architecture of Qunar's next‑generation database automation platform, outlines the design goals for secure Agent/Plugin‑Server communication, compares communication and encryption methods, and details the authentication and request flow using symmetric encryption and token‑based security.

Agent-Server CommunicationDatabase AutomationEncryption
0 likes · 9 min read
Design of a Next‑Generation Qunar Database Automation Platform: Architecture, Communication Protocol, and Security
ITPUB
ITPUB
Nov 1, 2022 · Backend Development

How Redis Cluster Uses Gossip to Keep Nodes in Sync

This article explains why Redis clusters need distributed metadata, compares centralized and decentralized metadata storage, introduces the epidemic‑style Gossip protocol, and details how Redis Cluster implements Gossip messaging, node discovery, failure detection, and state synchronization through concrete code examples.

ClusterData ConsistencyRedis
0 likes · 27 min read
How Redis Cluster Uses Gossip to Keep Nodes in Sync
Top Architect
Top Architect
Oct 28, 2022 · Backend Development

Configuring Redis Memory Size and Eviction Policies (LRU & LFU)

This article explains how to size Redis memory, configure maxmemory and maxmemory‑policy settings, and choose among various eviction strategies—including no‑eviction, allkeys‑lru, allkeys‑lfu, and volatile options—while detailing the underlying LRU and LFU algorithms used by Redis.

LFUMemoryRedis
0 likes · 7 min read
Configuring Redis Memory Size and Eviction Policies (LRU & LFU)
Shopee Tech Team
Shopee Tech Team
Oct 27, 2022 · Backend Development

Design and Implementation of a Scalable Fund Routing Decision Engine at Shopee

Shopee’s scalable fund‑routing decision engine combines a configurable Go‑based rule engine with Redis‑backed, Lua‑driven quota control to dynamically match loan orders to external capital providers, enforce multi‑dimensional volume limits, achieve tens of thousands TPS, and provide extensible risk‑management capabilities across markets.

GoMySQLRedis
0 likes · 17 min read
Design and Implementation of a Scalable Fund Routing Decision Engine at Shopee
Top Architect
Top Architect
Oct 27, 2022 · Backend Development

Redis Cache Expiration Avalanche and Mitigation Strategies

The article explains how Redis cache expiration can cause a request avalanche that overloads databases, and presents mitigation techniques such as semaphore rate limiting, per‑key locking, fault‑tolerant cache rebuilding, and example Java code using Spring and Redis.

CacheJavaRedis
0 likes · 8 min read
Redis Cache Expiration Avalanche and Mitigation Strategies
Xianyu Technology
Xianyu Technology
Oct 27, 2022 · Backend Development

Scalable Discount System Design with Crowd Synchronization

The article proposes a three‑step, crowd‑based discount system that decomposes discount elements, pre‑computes fan group membership in Redis, and combines offline batch with real‑time event synchronization, achieving tens of thousands QPS, millisecond latency, and both eventual and strong data consistency.

Data synchronizationRedisbackend architecture
0 likes · 9 min read
Scalable Discount System Design with Crowd Synchronization
dbaplus Community
dbaplus Community
Oct 26, 2022 · Databases

Mastering Redis Expiration and Eviction: LRU vs LFU Explained

This article explains how Redis handles key expiration, the three expiration deletion strategies, the eight memory‑eviction policies configurable via maxmemory, and the inner workings of Redis's LRU and LFU algorithms, including sampling, lru_clock, and counter decay mechanisms.

LFULRUMemory Management
0 likes · 13 min read
Mastering Redis Expiration and Eviction: LRU vs LFU Explained
Architect
Architect
Oct 26, 2022 · Information Security

Choosing Between JWT and Session for Authentication: Technical Selection and Implementation

This article compares JWT and session authentication, discusses their differences, security, performance, and lifecycle considerations, and provides a complete Java implementation—including dependency configuration, token utilities, Redis integration, login/logout flows, password updates, and request interception—guiding developers to select the most suitable approach for their projects.

AuthenticationJWTJava
0 likes · 14 min read
Choosing Between JWT and Session for Authentication: Technical Selection and Implementation
Selected Java Interview Questions
Selected Java Interview Questions
Oct 26, 2022 · Backend Development

Choosing the Right Delayed‑Task Solution: Why Redis Expiration and RabbitMQ Dead‑Letter Queues Are Problematic

The article evaluates common approaches for implementing delayed tasks such as order‑closing, critiques unreliable methods like Redis expiration listeners and RabbitMQ dead‑letter queues, and recommends robust solutions like RocketMQ, Pulsar, or Redisson delay queues with proper compensation mechanisms.

Message QueueRedisbackend
0 likes · 8 min read
Choosing the Right Delayed‑Task Solution: Why Redis Expiration and RabbitMQ Dead‑Letter Queues Are Problematic
Programmer DD
Programmer DD
Oct 25, 2022 · Backend Development

JWT vs Session: Pros, Cons, and How to Implement Secure Authentication

This article compares JWT and session-based authentication, detailing their differences, advantages, disadvantages, security considerations, performance impacts, and provides a complete Java implementation with token generation, Redis storage, login, logout, password update, and interceptor configuration.

JWTJavaRedis
0 likes · 15 min read
JWT vs Session: Pros, Cons, and How to Implement Secure Authentication
Java High-Performance Architecture
Java High-Performance Architecture
Oct 21, 2022 · Databases

What Makes Redis So Fast? Inside Its Data Structures and Single‑Threaded Design

Redis achieves remarkable speed by operating as an in‑memory database, leveraging specialized data structures like SDS, linked lists, hash tables, skip lists, and ziplists, while using a single‑threaded event loop with I/O multiplexing, incremental rehashing, and optimized memory management to minimize latency.

I/O multiplexingIn-Memory DatabaseRedis
0 likes · 19 min read
What Makes Redis So Fast? Inside Its Data Structures and Single‑Threaded Design
Architect
Architect
Oct 21, 2022 · Databases

Designing Efficient POI Proximity Search with MySQL, GeoHash, and Redis

This article explains how to implement fast nearby POI queries by calculating distances with the Haversine formula, designing MySQL tables and indexes, applying GeoHash for dimensionality reduction, and leveraging Redis Geo for high‑concurrency scenarios, while also providing Go code examples for each step.

GoMySQLPOI
0 likes · 29 min read
Designing Efficient POI Proximity Search with MySQL, GeoHash, and Redis
MaGe Linux Operations
MaGe Linux Operations
Oct 20, 2022 · Databases

Boost Ranking Performance with Redis Sorted Sets and Go

This article explains why MySQL struggles with large‑scale ranking, introduces Redis sorted sets as a high‑performance alternative, and provides complete Go code examples—including direct command usage and a struct‑based wrapper—to implement, query, and manage ranked data efficiently.

GoRedisSorted Set
0 likes · 8 min read
Boost Ranking Performance with Redis Sorted Sets and Go
Top Architect
Top Architect
Oct 20, 2022 · Backend Development

Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal

This article explains how to implement a Redis-based distributed lock in Spring Boot using custom annotations, AOP interception, and a scheduled executor to automatically renew lock expiration, providing a complete design, code examples, and testing guidance for handling long-running operations safely.

JavaRedisScheduledExecutorService
0 likes · 12 min read
Implementing a Redis Distributed Lock with Spring AOP and Automatic Renewal
Java High-Performance Architecture
Java High-Performance Architecture
Oct 18, 2022 · Backend Development

How to Implement a Robust Redis Distributed Lock with Spring AOP and Auto‑Renewal

This article explains the design and implementation of a Redis‑based distributed lock using Spring AOP, covering annotation creation, pointcut definition, lock acquisition, automatic renewal via a scheduled thread pool, error handling, and testing to ensure safe concurrent access to critical business data.

JavaRedisScheduledExecutorService
0 likes · 13 min read
How to Implement a Robust Redis Distributed Lock with Spring AOP and Auto‑Renewal
政采云技术
政采云技术
Oct 18, 2022 · Databases

Understanding Redis Internal Data Structures: SDS, Hash Tables, Ziplist, Quicklist, and Skiplist

This article explains Redis's superior performance by detailing its six underlying data structures—Simple Dynamic Strings, hash tables, ziplist, quicklist, skiplist, and integer sets—covering their implementations, memory optimizations, collision handling, and lookup complexities, with code examples and diagrams.

Data StructuresHash TableIn-Memory Database
0 likes · 12 min read
Understanding Redis Internal Data Structures: SDS, Hash Tables, Ziplist, Quicklist, and Skiplist
Spring Full-Stack Practical Cases
Spring Full-Stack Practical Cases
Oct 17, 2022 · Backend Development

Spring Boot Session Auto‑Configuration: How Filters and Repositories Work

This article walks through Spring Boot 2.3's session auto‑configuration process, detailing how core SessionConfiguration classes are registered, how the appropriate SessionRepository is selected based on store type, and how the SessionRepositoryFilter wraps requests and responses to manage session data with implementations such as Redis.

JavaRedisSession management
0 likes · 13 min read
Spring Boot Session Auto‑Configuration: How Filters and Repositories Work
Architect's Guide
Architect's Guide
Oct 15, 2022 · Information Security

Understanding Session Mechanisms, Cluster Session Challenges, and SSO Solutions with a CAS Implementation

This article explains traditional HTTP session handling, the problems of session sharing in clustered and multi‑service environments, and presents practical SSO solutions—including session replication, centralized Redis storage, and a complete CAS‑based single sign‑on implementation with Java code examples.

CASJavaRedis
0 likes · 14 min read
Understanding Session Mechanisms, Cluster Session Challenges, and SSO Solutions with a CAS Implementation
Architecture Digest
Architecture Digest
Oct 13, 2022 · Databases

Comprehensive Overview of Redis: Architecture, Data Structures, Persistence, Replication, Clustering and Advanced Features

This article provides an in‑depth technical guide to Redis, covering its single‑threaded model, core data structures (String, Hash, List, Set, ZSet) with practical commands, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and cluster architectures, cache eviction policies, memory management, progressive rehash, skiplist implementation, bitmap statistics, and consistency challenges when coupling Redis with MySQL.

ClusteringData StructuresDatabase
0 likes · 28 min read
Comprehensive Overview of Redis: Architecture, Data Structures, Persistence, Replication, Clustering and Advanced Features
Top Architect
Top Architect
Oct 11, 2022 · Backend Development

Implementing Distributed Locks with Redis and AOP in Spring Boot

This article explains how to protect time‑consuming business operations by using Redis as a distributed lock together with Spring AOP, covering annotation design, aspect implementation, lock acquisition, automatic renewal via a scheduled executor, and practical testing examples.

AOPJavaRedis
0 likes · 15 min read
Implementing Distributed Locks with Redis and AOP in Spring Boot
Architect
Architect
Oct 10, 2022 · Databases

Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Design, and I/O Multiplexing

This article explains why Redis delivers high query speed by leveraging its in‑memory architecture, custom data structures such as SDS, linked lists, hash tables, skip‑lists, and intsets, a single‑threaded execution model combined with efficient I/O multiplexing, and recent multithreaded I/O enhancements.

Data StructuresI/O multiplexingIn-Memory Database
0 likes · 18 min read
Why Redis Is Fast: In‑Memory Storage, Specialized Data Structures, Single‑Threaded Design, and I/O Multiplexing
DeWu Technology
DeWu Technology
Oct 10, 2022 · Big Data

Offline and Real-Time User Profile Fusion Architecture

The architecture combines a nightly batch job that generates offline user profiles stored in HBase with a Flink‑based stream layer that lazily loads those profiles on app start and creates real‑time updates, then fuses both streams into a unified, timestamp‑ordered profile in Redis, forming a Lambda‑style pipeline.

Batch ProcessingFlinkHBase
0 likes · 10 min read
Offline and Real-Time User Profile Fusion Architecture
IT Architects Alliance
IT Architects Alliance
Oct 9, 2022 · Databases

Comprehensive Overview of Redis: Architecture, Data Structures, Persistence, Replication, Cluster, Eviction, and Advanced Mechanisms

This article provides an in‑depth technical guide to Redis, covering its single‑threaded I/O model, core data structures (String, Hash, List, Set, ZSet), persistence options (RDB, AOF, hybrid), master‑slave replication, Sentinel, cluster slot allocation, eviction policies, progressive rehash, skip‑list implementation, and consistency challenges between MySQL and Redis.

ClusteringData StructuresPersistence
0 likes · 28 min read
Comprehensive Overview of Redis: Architecture, Data Structures, Persistence, Replication, Cluster, Eviction, and Advanced Mechanisms
Top Architect
Top Architect
Oct 9, 2022 · Databases

Comprehensive Guide to Redis: Architecture, Data Structures, Persistence, Clustering, and Advanced Features

This article provides an in‑depth overview of Redis, covering its single‑threaded design, core data structures, persistence mechanisms (RDB, AOF, hybrid), master‑slave replication, Sentinel and Cluster architectures, eviction policies, progressive rehash, bitmap usage for massive analytics, skiplist implementation, and strategies for handling MySQL‑Redis write inconsistencies.

ClusteringData StructuresPersistence
0 likes · 27 min read
Comprehensive Guide to Redis: Architecture, Data Structures, Persistence, Clustering, and Advanced Features
Laravel Tech Community
Laravel Tech Community
Oct 8, 2022 · Databases

Comparative Review of Popular Redis Visualization Tools

This article compares a range of Redis visualization solutions—including desktop clients, a web‑based platform, and an IDE plugin—detailing their features, licensing, platform support, and command‑line integration to help developers choose the most efficient tool for their workflow.

Database ToolsDesktop ClientIDE plugin
0 likes · 8 min read
Comparative Review of Popular Redis Visualization Tools
ITPUB
ITPUB
Oct 3, 2022 · Databases

Understanding Redis Persistence: RDB vs AOF Explained

This article explains how Redis ensures data durability by describing the two persistence mechanisms—RDB snapshots and AOF append‑only logs—including their creation, loading, configuration options, performance trade‑offs, and guidance on choosing the appropriate method for different workloads.

AOFData RecoveryDatabase
0 likes · 11 min read
Understanding Redis Persistence: RDB vs AOF Explained
Top Architect
Top Architect
Sep 30, 2022 · Backend Development

Implementing JWT Blacklist with RedisTokenStore in Spring Security OAuth2

This article explains why JWT is not ideal for logout and token renewal, recommends using a Redis‑backed token store, and provides three Redis‑based blacklist implementations with detailed Java code snippets for extending JwtTokenStore, custom converters, and global filters in Spring Security OAuth2.

JWTJavaOAuth2
0 likes · 12 min read
Implementing JWT Blacklist with RedisTokenStore in Spring Security OAuth2
Java Architect Essentials
Java Architect Essentials
Sep 27, 2022 · Backend Development

How to Combine Redis and Guava for Lazy‑Loading Cache in Java

This article explains how to reduce Redis read/write pressure by introducing a Guava local cache for lazy loading, presents design diagrams, provides complete Java code examples for both simple lazy caching and a microservice‑oriented device‑increment cache, and discusses the advantages, disadvantages, and practical considerations of each approach.

GuavaJavaRedis
0 likes · 11 min read
How to Combine Redis and Guava for Lazy‑Loading Cache in Java
Laravel Tech Community
Laravel Tech Community
Sep 27, 2022 · Databases

Understanding Redis: Overview, Architecture, and Persistence Model

Redis is an open‑source in‑memory key‑value data‑structure server that serves as a cache, primary database, and messaging system; this article explains its core concepts, deployment options (single instance, HA, Sentinel, Cluster), and persistence mechanisms (RDB, AOF, and hybrid approaches).

ClusteringIn-Memory DatabasePersistence
0 likes · 18 min read
Understanding Redis: Overview, Architecture, and Persistence Model
dbaplus Community
dbaplus Community
Sep 27, 2022 · Operations

How to Build a Scalable Rate‑Limiting System with Kong in Cloud‑Native Operations

This article outlines a comprehensive, cloud‑native rate‑limiting solution using Kong gateway, covering background challenges, design considerations, multi‑layer architecture, plugin development, CI/CD workflow, deployment strategies, and operational best practices to achieve low cost, high efficiency, and high quality across diverse projects.

CI/CDKongOperations
0 likes · 24 min read
How to Build a Scalable Rate‑Limiting System with Kong in Cloud‑Native Operations
MaGe Linux Operations
MaGe Linux Operations
Sep 27, 2022 · Databases

What Is Redis? A Deep Dive into Its Architecture and Persistence

Redis is an open‑source, in‑memory key‑value store that functions as a data‑structure server, offering caching, replication, high‑availability, clustering, and various persistence options such as RDB snapshots and AOF logs, with detailed deployment models including single instances, Sentinel, and cluster architectures.

ClusterIn-Memory DatabasePersistence
0 likes · 18 min read
What Is Redis? A Deep Dive into Its Architecture and Persistence
Top Architect
Top Architect
Sep 27, 2022 · Databases

Configuring Redis Memory Size and Eviction Policies (LRU and LFU)

Redis caches can fill up, requiring memory eviction; this guide explains how to set Redis maxmemory (e.g., 5GB), choose appropriate eviction policies such as allkeys-lru or allkeys-lfu, and details the underlying LRU and LFU algorithms and their configuration commands.

LFULRUMemory Management
0 likes · 7 min read
Configuring Redis Memory Size and Eviction Policies (LRU and LFU)
ITPUB
ITPUB
Sep 26, 2022 · Databases

Redis Persistence Explained: RDB Snapshots vs AOF Logging

The article narrates how Redis, personified as a character, discovers data loss risks, implements RDB snapshotting and configurable save intervals, learns from MySQL's binary log, adopts Append‑Only File logging with flush policies, and finally adds AOF rewrite to keep storage efficient.

AOFData RecoveryDatabase
0 likes · 9 min read
Redis Persistence Explained: RDB Snapshots vs AOF Logging