BestHub
Sign in
Tagged articles

Redis

3563 articles · Page 25 of 36
Code Ape Tech Column
Code Ape Tech Column
Aug 10, 2021 · Backend Development

How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis, and Cookie Solutions

This article explains why session sharing is critical in micro‑service architectures, compares common Nginx load‑balancing methods, and provides four practical solutions—ip_hash load balancing, Tomcat session replication, Redis‑based session caching, and cookie‑based sharing—complete with configuration examples and pros/cons.

BackendNginxRedis
0 likes · 6 min read
How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis, and Cookie Solutions
Top Architect
Top Architect
Aug 8, 2021 · Backend Development

My First Java Web Project: From Planning to Deployment – A Full‑Stack Journey

This article recounts the author’s experience building a simple Java web application for a university anniversary, covering planning, environment setup, documentation, database design, coding challenges with Spring Boot, Redis, and session handling, deployment on Alibaba Cloud, and the lessons learned about architecture, logging, and monitoring.

JavaMySQLRedis
0 likes · 10 min read
My First Java Web Project: From Planning to Deployment – A Full‑Stack Journey
21CTO
21CTO
Aug 8, 2021 · Backend Development

Guaranteeing No Message Loss in RabbitMQ with Persistence and Confirm

This article examines how to ensure reliable message delivery in RabbitMQ by using durable queues, the confirm mechanism, and supplemental strategies such as persisting messages to Redis, implementing idempotent processing with optimistic locking or unique‑ID fingerprints, and employing compensation tasks to achieve near‑zero message loss in high‑concurrency systems.

Confirm MechanismOptimistic LockRabbitMQ
0 likes · 9 min read
Guaranteeing No Message Loss in RabbitMQ with Persistence and Confirm
Architecture Digest
Architecture Digest
Aug 8, 2021 · Backend Development

Implementing Rate Limiting in Spring Boot Using a Custom Annotation and Redis

This article demonstrates how to create a custom @AccessLimit annotation in Spring Boot, implement a rate‑limiting interceptor that checks request frequency via Redis, register the interceptor, and apply the annotation to controller methods to enforce request limits with optional login verification.

Custom AnnotationInterceptorJava
0 likes · 6 min read
Implementing Rate Limiting in Spring Boot Using a Custom Annotation and Redis
Top Architect
Top Architect
Aug 7, 2021 · Backend Development

Redis Practical Use Cases: Caching, Distributed Locks, Global IDs, Counters, Rate Limiting, Bitmaps, Shopping Cart, Timeline, Message Queue, and More

This article presents a comprehensive guide to using Redis for various backend scenarios, including caching hot data, sharing sessions, implementing distributed locks, generating global IDs, counting, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, tags, product filtering, follow relationships, and ranking, all illustrated with concrete code examples.

BitmapsCachingMessage Queue
0 likes · 8 min read
Redis Practical Use Cases: Caching, Distributed Locks, Global IDs, Counters, Rate Limiting, Bitmaps, Shopping Cart, Timeline, Message Queue, and More
Java Tech Enthusiast
Java Tech Enthusiast
Aug 7, 2021 · Backend Development

Cache Optimization and Distributed Locking in High-Concurrency Systems

By illustrating how to replace simple HashMap caching with Redis‑based distributed caches and locks—using SETNX, Lua scripts, and Redisson—the article shows Spring Boot developers how to prevent cache breakdown, ensure data consistency, and dramatically improve throughput in high‑concurrency web applications.

CachingDistributed lockingHigh Concurrency
0 likes · 16 min read
Cache Optimization and Distributed Locking in High-Concurrency Systems
ITPUB
ITPUB
Aug 6, 2021 · Backend Development

How to Guarantee RabbitMQ Message Delivery and Achieve Zero Loss

This article examines common pitfalls in RabbitMQ message delivery, explains persistence and confirm mechanisms, and proposes a robust solution combining pre‑storage in Redis, confirm callbacks, scheduled retries, and idempotent processing to ensure virtually zero message loss in high‑concurrency systems.

Confirm MechanismOptimistic LockRabbitMQ
0 likes · 11 min read
How to Guarantee RabbitMQ Message Delivery and Achieve Zero Loss
Wukong Talks Architecture
Wukong Talks Architecture
Aug 6, 2021 · Databases

Redis Operational Best Practices and Guidelines

This guide presents a comprehensive set of mandatory, reference, and recommended Redis usage standards—including command restrictions, key naming, data sizing, persistence configurations, monitoring, and deployment strategies—to improve performance, reliability, and operational efficiency for production environments.

OperationsPersistenceRedis
0 likes · 9 min read
Redis Operational Best Practices and Guidelines
Code Ape Tech Column
Code Ape Tech Column
Aug 6, 2021 · Backend Development

Common Redis Use Cases: Caching, Distributed Locks, Counters, Rate Limiting, and More

This article outlines a variety of practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmap statistics, shopping carts, timelines, message queues, lotteries, likes, product tagging, filtering, follow/recommendation models, and ranking—demonstrating how Redis can support diverse backend functionalities.

BackendBitmapDistributedLock
0 likes · 9 min read
Common Redis Use Cases: Caching, Distributed Locks, Counters, Rate Limiting, and More
TAL Education Technology
TAL Education Technology
Aug 5, 2021 · Backend Development

Understanding epoll Programming and Its Use in Redis Server

This article explains the basic network programming pattern, introduces epoll as an I/O multiplexing solution for high‑concurrency servers, and demonstrates how Redis 5.0 integrates epoll through its event‑loop abstraction with detailed code examples and debugging tips.

C++EpollRedis
0 likes · 13 min read
Understanding epoll Programming and Its Use in Redis Server
Sohu Tech Products
Sohu Tech Products
Aug 4, 2021 · Backend Development

Resolving Duplicate OpenID Insertions with Distributed Locks in a Fast App Center

To prevent duplicate OpenID records caused by concurrent synchronization requests in the Fast App Center, this article analyzes the root cause, evaluates database‑level unique indexes versus application‑level distributed locks, and presents a Redis‑based lock implementation with cleanup procedures to ensure data consistency.

BackendJavaMySQL
0 likes · 16 min read
Resolving Duplicate OpenID Insertions with Distributed Locks in a Fast App Center
Efficient Ops
Efficient Ops
Aug 4, 2021 · Backend Development

How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning

This article documents a step‑by‑step performance optimization of a Python web module, covering requirement analysis, environment setup, load‑testing results, database and TCP bottleneck identification, caching strategies, kernel tuning, and the final achievement of 50,000 QPS with low latency.

Load TestingPythonRedis
0 likes · 9 min read
How I Boosted a Python Service to 50k QPS: Real‑World Performance Tuning
Wukong Talks Architecture
Wukong Talks Architecture
Aug 3, 2021 · Databases

Redis Eviction Policies Explained

This article introduces the various Redis eviction strategies—including volatile-ttl, volatile-random, volatile-lru, volatile-lfu, allkeys-random, allkeys-lru, and allkeys-lfu—explains their behavior, shows where they are configured in redis.conf and the initServer source code, and notes the default noeviction policy when memory exceeds maxmemory.

Rediscachedatabases
0 likes · 3 min read
Redis Eviction Policies Explained
Java Interview Crash Guide
Java Interview Crash Guide
Jul 28, 2021 · Backend Development

How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis & Cookie Solutions

This article explains why session sharing is needed in micro‑service architectures, outlines common Nginx reverse‑proxy strategies, and presents four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis centralized cache, and cookie‑based sharing—detailing their implementations and trade‑offs.

RedisTomcatdistributed systems
0 likes · 6 min read
How to Share Sessions Across Distributed Servers: Nginx, Tomcat, Redis & Cookie Solutions
Tencent Cloud Developer
Tencent Cloud Developer
Jul 27, 2021 · Backend Development

Comprehensive Guide to Go Unit Testing: Tools, Mocking, and Dependency Management

This guide explains Go’s built‑in testing framework, assertion libraries, table‑driven and sub‑tests, and demonstrates how to mock functions, structs, interfaces, databases, and Redis using tools such as ngmock, gomock, sqlmock and miniredis, while covering test setup, teardown, coverage handling, and best‑practice insights.

Dependency InjectionGoMock
0 likes · 21 min read
Comprehensive Guide to Go Unit Testing: Tools, Mocking, and Dependency Management
dbaplus Community
dbaplus Community
Jul 25, 2021 · Backend Development

Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls

This article thoroughly explains why distributed locks are needed, walks through basic Redis lock implementations, exposes deadlock and expiration issues, presents robust solutions with unique IDs and Lua scripts, examines the Redlock algorithm, reviews the Martin‑Antirez debate, and compares Redis with Zookeeper locks.

LuaRedisRedlock
0 likes · 40 min read
Is Redis Distributed Lock Safe? Deep Dive into Redlock and Zookeeper Pitfalls
Laravel Tech Community
Laravel Tech Community
Jul 23, 2021 · Backend Development

Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies

The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis‑based systems, describes the performance risks they pose to persistent databases, and presents practical mitigation techniques such as Bloom filters, empty‑object caching, hot‑key permanence, distributed locks, high‑availability clusters, rate limiting, and data pre‑warming.

BackendBloom FilterRedis
0 likes · 6 min read
Cache Penetration, Cache Breakdown, and Cache Avalanche: Concepts and Mitigation Strategies
Programmer DD
Programmer DD
Jul 22, 2021 · Backend Development

How to Achieve Exactly‑Once Message Processing in RocketMQ Without Heavy Transactions

This article explains why message middleware guarantees at‑least‑once delivery, the challenges of duplicate consumption, and presents both simple and advanced deduplication strategies—including transactional and non‑transactional approaches using relational databases or Redis—to achieve effectively exactly‑once semantics in RocketMQ.

Exactly-OnceIdempotenceRedis
0 likes · 18 min read
How to Achieve Exactly‑Once Message Processing in RocketMQ Without Heavy Transactions
vivo Internet Technology
vivo Internet Technology
Jul 21, 2021 · Backend Development

Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions

The Fast App Center’s duplicate OpenID rows were traced to a non‑atomic check‑then‑insert race condition, prompting the team to evaluate a unique‑index safeguard versus application‑level distributed locking, ultimately implementing a Redis‑based lock to serialize inserts and adding a cleanup job to purge existing duplicates.

Database ConcurrencyJavaMySQL
0 likes · 18 min read
Resolving Duplicate OpenID Insertions in Fast App Center: Analysis and Distributed Lock Solutions
Wukong Talks Architecture
Wukong Talks Architecture
Jul 21, 2021 · Fundamentals

Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management

This article explains the Redis Simple Dynamic String (SDS) data structure, comparing it with traditional C strings, detailing its struct layout, O(1) length retrieval, pre‑allocation strategy, lazy space release, and provides code examples illustrating how SDS avoids buffer overflows and improves performance.

C stringsData StructuresRedis
0 likes · 11 min read
Understanding Redis Simple Dynamic Strings (SDS): Structure, Benefits, and Memory Management
Efficient Ops
Efficient Ops
Jul 20, 2021 · Databases

Master Redis: 13 Proven Practices to Boost Memory, Performance & Reliability

Discover a comprehensive Redis best‑practice guide covering memory optimization, performance tuning, high reliability, daily operations, resource planning, monitoring, and security, with actionable tips such as key length control, maxmemory settings, lazy‑free, connection pooling, replication strategies, and safe deployment practices.

Database ManagementOperationsRedis
0 likes · 23 min read
Master Redis: 13 Proven Practices to Boost Memory, Performance & Reliability
Architect
Architect
Jul 20, 2021 · Databases

Redis New Features and Architecture Options Overview

This article reviews Redis 6.0 and 5.0 new features, compares deployment architectures such as cluster, master-replica, and read-write split, and provides Java connection-pool code examples to help engineers select the appropriate Redis setup for performance, reliability, and scalability requirements.

ClusterJavaJedis
0 likes · 11 min read
Redis New Features and Architecture Options Overview
Selected Java Interview Questions
Selected Java Interview Questions
Jul 20, 2021 · Backend Development

Session Sharing Solutions for Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie Approaches

In distributed micro‑service environments, session sharing is essential to prevent repeated logins, and this article explains four practical solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized sessions, and cookie‑based sharing—detailing their implementations, advantages, and drawbacks.

NginxRedisTomcat
0 likes · 5 min read
Session Sharing Solutions for Distributed Systems: Nginx ip_hash, Tomcat Replication, Redis Cache, and Cookie Approaches
Java Interview Crash Guide
Java Interview Crash Guide
Jul 20, 2021 · Backend Development

Designing a Universal Cache Strategy for Static Data in Microservices

This article outlines a universal caching strategy for low‑frequency static data in microservice systems, explaining why in‑memory caches like Redis are needed, detailing a six‑component architecture with services, queues, and consistency checks, and weighing trade‑offs such as cache eviction, persistence, and scalability.

CachingQueueRedis
0 likes · 15 min read
Designing a Universal Cache Strategy for Static Data in Microservices
Programmer DD
Programmer DD
Jul 19, 2021 · Backend Development

How Redis Ziplist Compresses Memory and When to Use It

This article explains Redis's ziplist compressed list structure, its internal fields, lookup algorithm, performance characteristics, configuration thresholds for Hash and List types, and demonstrates a real‑world use case with memory‑saving calculations and experimental results.

Data StructuresMemory CompressionRedis
0 likes · 11 min read
How Redis Ziplist Compresses Memory and When to Use It
Top Architect
Top Architect
Jul 18, 2021 · Backend Development

Implementing Distributed Locks with Redis and Redisson in Java

The article explains why Java's synchronized lock cannot be used for distributed scenarios, demonstrates how to build a Redis‑based distributed lock with setIfAbsent, discusses pitfalls such as server crashes and lock expiration, and presents robust solutions including atomic expiration, thread‑ID verification, lock renewal, and Redisson usage.

JavaRedisRedisson
0 likes · 6 min read
Implementing Distributed Locks with Redis and Redisson in Java
Top Architect
Top Architect
Jul 14, 2021 · Databases

Redis Read‑Write Separation Architecture: Star vs. Chain Replication

This article explains Alibaba Cloud's Redis read‑write separation architecture, comparing star and chain replication models, their performance and scalability trade‑offs, and how transparent compatibility, high availability, and high performance are achieved through redis‑proxy, HA monitoring, and optimized binlog replication.

Read-Write SeparationRedisdatabases
0 likes · 8 min read
Redis Read‑Write Separation Architecture: Star vs. Chain Replication
Su San Talks Tech
Su San Talks Tech
Jul 14, 2021 · Databases

Why Is Redis So Fast? Deep Dive into Its Core Architecture and Performance

Redis achieves its remarkable speed through a combination of in‑memory data storage, optimized data structures like SDS, ziplist, quicklist and skiplist, a single‑threaded command model, efficient I/O multiplexing, and sophisticated persistence, replication, Sentinel and Cluster mechanisms that together ensure high performance and reliability.

ClusterIn-Memory DatabasePersistence
0 likes · 25 min read
Why Is Redis So Fast? Deep Dive into Its Core Architecture and Performance
Programmer DD
Programmer DD
Jul 12, 2021 · Backend Development

How to Scale Redis for Billions of Keys: Memory‑Saving Strategies

This article examines the challenges of storing massive DMP data in Redis, analyzes memory fragmentation, key‑value explosion, and latency constraints, and presents practical solutions such as eviction policies, bucket hashing, key compression, and fragmentation reduction to enable efficient in‑memory storage.

JavaRedislarge-scale storage
0 likes · 11 min read
How to Scale Redis for Billions of Keys: Memory‑Saving Strategies
Su San Talks Tech
Su San Talks Tech
Jul 12, 2021 · Backend Development

Master Redisson: Simplify Distributed Locks in Spring Boot

This tutorial explains how to integrate Redisson into a Spring Boot application to implement robust distributed locks, covering Redisson's architecture, configuration, code examples, lock types, watchdog mechanism, and practical testing procedures for reentrant, read‑write, and semaphore locks.

RedisRedissonSpring Boot
0 likes · 13 min read
Master Redisson: Simplify Distributed Locks in Spring Boot
Top Architect
Top Architect
Jul 10, 2021 · Backend Development

Optimizing Complex Search Queries with Redis: A Backend Development Demo

This article explores how backend developers can handle intricate e‑commerce search filters by first attempting a monolithic SQL solution, then improving performance with index analysis and query splitting, and finally achieving fast, scalable results using Redis sets, sorted sets, and transaction commands.

CachingRedisSQL
0 likes · 8 min read
Optimizing Complex Search Queries with Redis: A Backend Development Demo
Selected Java Interview Questions
Selected Java Interview Questions
Jul 9, 2021 · Backend Development

Various Strategies for Deploying Distributed Scheduled Tasks on a Single Server

The article compares five practical methods—single‑server deployment, IP‑based restriction, database‑driven task selection, Redis expiration with distributed lock, and Quartz clustering—to ensure that a scheduled job runs only once across multiple servers, outlining each approach's advantages, drawbacks, and implementation details.

MySQLQuartzRedis
0 likes · 5 min read
Various Strategies for Deploying Distributed Scheduled Tasks on a Single Server
Architect
Architect
Jul 9, 2021 · Backend Development

Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies

This article explains how to design a flash‑sale (秒杀) system that can handle massive traffic spikes by using static page CDN caching, gateway request interception, Redis inventory control, asynchronous order processing, and thorough business, deployment, and data isolation to ensure high performance and stability without affecting regular services.

CDNHigh ConcurrencyRedis
0 likes · 10 min read
Designing a High‑Concurrency Flash Sale System: Architecture, Caching, Rate Limiting, and Isolation Strategies
Beike Product & Technology
Beike Product & Technology
Jul 8, 2021 · Fundamentals

Understanding HyperLogLog: Algorithm Principles, Redis Implementation, and Experimental Analysis

This article explores the HyperLogLog algorithm for cardinality estimation, tracing its development from Linear and LogLog counting, detailing its Redis implementation with sparse and dense encodings and command workflows, and presenting experiments that demonstrate its memory efficiency and analyze observed error rates versus the theoretical 0.81% standard deviation.

HyperLogLogRedisalgorithm
0 likes · 13 min read
Understanding HyperLogLog: Algorithm Principles, Redis Implementation, and Experimental Analysis
Sohu Tech Products
Sohu Tech Products
Jul 7, 2021 · Backend Development

Implementing Nearby‑People (LBS) with MySQL and Redis GEO

This article explains how to build a location‑based "nearby people" feature by storing coordinates in MySQL, filtering with rectangular bounds, calculating distances in Java, and then scaling the solution with Redis GEO using GeoHash and Sorted Sets for high‑performance proximity queries.

GeoHashLBSLocation Services
0 likes · 14 min read
Implementing Nearby‑People (LBS) with MySQL and Redis GEO
vivo Internet Technology
vivo Internet Technology
Jul 7, 2021 · Databases

Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients

Lettuce, a thread‑safe, Netty‑based Java Redis client supporting synchronous, asynchronous, reactive, Cluster, Sentinel, pipelining and custom codecs, outperforms Jedis’s non‑thread‑safe pooled connections by reducing resource consumption, simplifying Spring integration, and offering advanced features like read‑write splitting, topology refresh, and optional pooling for high‑throughput applications.

JavaJedisLettuce
0 likes · 15 min read
Lettuce vs Jedis: Features, Usage, and Comparison of Java Redis Clients
Selected Java Interview Questions
Selected Java Interview Questions
Jul 7, 2021 · Operations

Redis Monitoring Metrics and Commands Guide

This article provides a comprehensive overview of Redis monitoring metrics—including performance, memory, basic activity, persistence, and error indicators—along with recommended monitoring tools, configuration settings, and command-line examples for gathering and interpreting these metrics in production environments.

MonitoringOperationsRedis
0 likes · 7 min read
Redis Monitoring Metrics and Commands Guide
macrozheng
macrozheng
Jul 5, 2021 · Backend Development

Master Spring Cache: Simplify Caching Across Redis, Ehcache, and More

This article introduces Spring Cache as a unified caching solution that abstracts away the specifics of Redis, Ehcache, and other providers, explains its core concepts, annotations, configuration, and demonstrates practical usage with code examples to eliminate manual cache handling.

CachingEhcacheJava
0 likes · 16 min read
Master Spring Cache: Simplify Caching Across Redis, Ehcache, and More
Java Interview Crash Guide
Java Interview Crash Guide
Jul 1, 2021 · Backend Development

How to Store Billions of IDs in Redis Efficiently: Strategies for Massive DMP Caches

This article examines the challenges of storing and querying billions of DMP identifiers in Redis, analyzes data characteristics and memory fragmentation issues, and presents practical solutions such as eviction policies, bucket‑based key hashing, and fragmentation reduction techniques to achieve low‑latency, large‑scale caching.

DMPJavaKey hashing
0 likes · 11 min read
How to Store Billions of IDs in Redis Efficiently: Strategies for Massive DMP Caches
ITPUB
ITPUB
Jun 30, 2021 · Databases

Why GaussDB for Redis Outperforms Open‑Source Redis: Architecture, Benefits, and Real‑World Performance

This article explains the limitations of open‑source Redis, introduces Huawei Cloud's GaussDB for Redis with its compute‑storage separation architecture, details its design, implementation, and disaster‑recovery mechanisms, and summarizes the competitive advantages such as strong consistency, high availability, elastic scaling, and superior performance.

Compute-Storage SeparationGaussDBNoSQL
0 likes · 14 min read
Why GaussDB for Redis Outperforms Open‑Source Redis: Architecture, Benefits, and Real‑World Performance
Code Ape Tech Column
Code Ape Tech Column
Jun 30, 2021 · Databases

Implementing Like Functionality with Redis Bitmaps

This article explains how to use Redis bitmap operations to efficiently implement like, sign‑in, and other binary state features, covering bitmap fundamentals, common use cases, essential commands, Java code examples with Jedis, and range query techniques.

BackendBitmapJava
0 likes · 7 min read
Implementing Like Functionality with Redis Bitmaps
Wukong Talks Architecture
Wukong Talks Architecture
Jun 29, 2021 · Backend Development

Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware

This article introduces Spring Cache as a framework‑agnostic caching abstraction that eliminates manual cache code, explains its core concepts, annotations, configuration options, and demonstrates practical usage with Redis and custom key, condition, and eviction strategies in Spring Boot applications.

BackendEhcacheJava
0 likes · 15 min read
Comprehensive Guide to Spring Cache: A Unified Caching Solution for Redis, Ehcache and Other Middleware
ITPUB
ITPUB
Jun 29, 2021 · Backend Development

Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives

This article thoroughly examines the safety of Redis‑based distributed locks, explains basic SETNX locking, explores deadlock and lock‑release problems, presents robust solutions such as atomic SET with expiration, Lua scripts, and unique tokens, and critically compares Redlock with Zookeeper while summarizing expert debates and best‑practice recommendations.

LuaRedisRedlock
0 likes · 34 min read
Is Redis Distributed Lock Really Safe? A Deep Dive into Redlock, Pitfalls, and Alternatives
dbaplus Community
dbaplus Community
Jun 28, 2021 · Cloud Native

From chroot to Kubernetes: Choosing the Right Redis Container Strategy

This talk walks through the evolution of containerization—from early chroot and jails to modern Kubernetes—explains Redis’s core features, compares various container solutions for Redis deployment, and offers practical guidance on installation, scaling, monitoring, and fault recovery in both single‑instance and clustered environments.

DockerKubernetesRedis
0 likes · 30 min read
From chroot to Kubernetes: Choosing the Right Redis Container Strategy
The Dominant Programmer
The Dominant Programmer
Jun 27, 2021 · Backend Development

Cache Database Data in Redis with Custom SpringBoot AOP Annotations

This guide demonstrates how to add a custom AOP‑based caching layer to a SpringBoot application, using Redis to store frequently queried MySQL table data, defining @AopCacheEnable and @AopCacheEvict annotations, implementing an aspect, handling key generation, expiration, and cache eviction on CRUD operations.

AOPCustom AnnotationMySQL
0 likes · 9 min read
Cache Database Data in Redis with Custom SpringBoot AOP Annotations
Programmer DD
Programmer DD
Jun 26, 2021 · Backend Development

Implementing a Spring Boot Anti‑Crawler Filter with kk‑anti‑reptile

This article explains how to integrate the kk‑anti‑reptile anti‑crawler component into a Spring Boot application, covering system requirements, filter workflow, rule configuration, Maven setup, Redis and Apollo settings, as well as front‑end handling of the 509 response and captcha verification.

CAPTCHARedisanti‑crawler
0 likes · 7 min read
Implementing a Spring Boot Anti‑Crawler Filter with kk‑anti‑reptile
Ctrip Technology
Ctrip Technology
Jun 24, 2021 · Backend Development

Design and Implementation of Distributed Cache with Eventual and Strong Consistency at Ctrip Finance

This article presents Ctrip Finance's design of a unified high‑availability Redis cache service, covering both eventual‑consistency and strong‑consistency scenarios, the overall architecture, data‑accuracy, completeness and availability mechanisms, lock handling, fault‑tolerant updates, and operational recovery strategies.

ConsistencyMySQLRedis
0 likes · 26 min read
Design and Implementation of Distributed Cache with Eventual and Strong Consistency at Ctrip Finance
Java Architect Essentials
Java Architect Essentials
Jun 23, 2021 · Databases

How Redis Read‑Write Separation Boosts Performance and Cuts Costs

This article explains the background, architecture, and replication models of Redis read‑write separation, compares star and chain replication, and outlines its transparent compatibility, high availability, and performance benefits while noting consistency trade‑offs for read‑heavy workloads.

Read-Write SeparationRedisdatabase architecture
0 likes · 9 min read
How Redis Read‑Write Separation Boosts Performance and Cuts Costs
Sohu Tech Products
Sohu Tech Products
Jun 23, 2021 · Backend Development

Using Redis Data Structures for Efficient Large‑Scale Statistics: Cardinality, Sorting, and Aggregation

The article explains how to choose appropriate Redis data structures—such as Bitmap, HyperLogLog, Set, List, Hash, and Sorted Set—to efficiently handle massive statistical scenarios like UV counting, ranking, and set‑based aggregation, while providing concrete command examples and performance considerations.

Data StructuresHyperLogLogRedis
0 likes · 13 min read
Using Redis Data Structures for Efficient Large‑Scale Statistics: Cardinality, Sorting, and Aggregation
vivo Internet Technology
vivo Internet Technology
Jun 23, 2021 · Backend Development

Overview of Vivo Mall Promotion System Architecture and Technical Challenges

The article outlines Vivo Mall’s new independent promotion system architecture—introducing a unified discount model, flexible pricing engine, and scalable, high‑concurrency design—while detailing technical solutions such as Redis caching, batching, hot‑cold separation, rate‑limiting, idempotency, circuit‑breaker safeguards, and lessons learned from Redis SCAN and hot‑key issues.

Redisbackend architecturepromotion system
0 likes · 12 min read
Overview of Vivo Mall Promotion System Architecture and Technical Challenges
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jun 23, 2021 · Databases

Redis Concepts and Command Reference

This article introduces Redis as a high‑performance, in‑memory key‑value database, explains its core features such as persistence, pub/sub, data structures, and atomic operations, and provides a comprehensive list of commands for keys, strings, hashes, lists, sets, and sorted sets.

NoSQLRediscommands
0 likes · 15 min read
Redis Concepts and Command Reference
IT Architects Alliance
IT Architects Alliance
Jun 20, 2021 · Databases

Master‑Slave Replication Pitfalls and Deep Dive into Redis Sentinel

This article examines the limitations of Redis master‑slave replication, such as manual failover and single‑node bottlenecks, and provides an in‑depth exploration of Redis Sentinel’s architecture, configuration parameters, detection mechanisms, automatic failover process, and best‑practice recommendations for achieving high availability.

RedisReplicationSentinel
0 likes · 11 min read
Master‑Slave Replication Pitfalls and Deep Dive into Redis Sentinel
IT Architects Alliance
IT Architects Alliance
Jun 20, 2021 · Backend Development

When to Replace In‑Process Cache with Redis? A Practical Guide

This article explains the differences between in‑process caches and external cache services like Redis, outlines the drawbacks of process‑level caching in distributed systems, and provides concrete criteria and strategies for deciding when to migrate to a dedicated cache service.

CachingRedisbackend architecture
0 likes · 9 min read
When to Replace In‑Process Cache with Redis? A Practical Guide
Liangxu Linux
Liangxu Linux
Jun 19, 2021 · Fundamentals

Why Unicode Matters: Understanding UTF‑8, UTF‑16, and UTF‑32 Encoding

This article traces the evolution from ASCII to Unicode, explains how Unicode defines universal code points, compares the UTF‑8, UTF‑16 and UTF‑32 encoding schemes, discusses byte order and BOM, and shows practical fixes for common encoding problems in Redis and MySQL.

Character EncodingMySQLRedis
0 likes · 15 min read
Why Unicode Matters: Understanding UTF‑8, UTF‑16, and UTF‑32 Encoding
IT Architects Alliance
IT Architects Alliance
Jun 19, 2021 · Backend Development

Mastering Cache Strategies: From CDN to Distributed Systems

This article provides a comprehensive overview of caching in large‑scale distributed systems, covering cache fundamentals, classification, major implementations such as CDN, reverse‑proxy, local, and distributed caches, detailed analyses of Memcached and Redis, common design challenges, and real‑world industry solutions.

BackendCachingMemcached
0 likes · 12 min read
Mastering Cache Strategies: From CDN to Distributed Systems
ITPUB
ITPUB
Jun 18, 2021 · Databases

How to Build a Fast Search API with Redis: From Complex SQL to Set‑Based Caching

This article walks through the challenges of implementing a multi‑criteria product search for a shopping site, compares a naïve SQL solution with optimized query splitting, and then shows how Redis sets, sorted sets, and transactions can dramatically improve performance while adding pagination and update handling.

RedisSQLsearch
0 likes · 9 min read
How to Build a Fast Search API with Redis: From Complex SQL to Set‑Based Caching
IT Architects Alliance
IT Architects Alliance
Jun 17, 2021 · Backend Development

A General Cache Handling Mechanism for Static Business Data in Microservice Architecture

The article proposes a comprehensive microservice‑based caching solution for low‑frequency static data such as vehicle models and user profiles, detailing why caching is needed, why Redis and persistent queues are chosen, how consistency checks work, and the trade‑offs compared with simple expiration strategies.

QueueRedisbackend architecture
0 likes · 14 min read
A General Cache Handling Mechanism for Static Business Data in Microservice Architecture
New Oriental Technology
New Oriental Technology
Jun 17, 2021 · Backend Development

Cache Basics, Types, Patterns, and Common Issues

This article explains why caching is used, distinguishes between local and distributed caches, compares popular Java cache libraries, describes Redis and Memcached differences, outlines the Cache‑Aside pattern, and discusses common cache problems such as inconsistency, penetration, breakdown, avalanche, hot‑key detection, and their mitigation strategies.

JavaRedisdistributed cache
0 likes · 15 min read
Cache Basics, Types, Patterns, and Common Issues
21CTO
21CTO
Jun 16, 2021 · Backend Development

How to Build a Universal Static Data Cache for Microservices with Redis

This article explains a reusable caching architecture for low‑frequency static data in microservice systems, covering why caching is needed, the role of Redis, persistent queues, consistency checks, and trade‑offs such as cache expiration and operational complexity.

CachingQueueRedis
0 likes · 14 min read
How to Build a Universal Static Data Cache for Microservices with Redis
vivo Internet Technology
vivo Internet Technology
Jun 16, 2021 · Backend Development

Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study

The case study details how a high‑traffic Dubbo service handling 1.8 billion daily requests suffered periodic circuit‑breaks due to thread‑pool exhaustion, traced to a cache‑bypass bug, Redis setex spikes, and an improperly warmed commons‑pool2 connection pool, and resolved by fixing the bug, scaling Redis, and tuning or downgrading the pool configuration to enable pre‑warming via minEvictableIdleTimeMillis.

Circuit BreakingDubboRedis
0 likes · 13 min read
Troubleshooting Dubbo Thread Pool Exhaustion: A Redis Performance Optimization Case Study
Aikesheng Open Source Community
Aikesheng Open Source Community
Jun 16, 2021 · Databases

High‑Availability Strategies for Redis: Sentinel Service Discovery, VIP Binding, Keepalived VRRP, and Proxy Approaches

The article explains various Redis high‑availability solutions—including Sentinel service discovery, VIP binding, keepalived VRRP, and proxy middleware—for both master‑slave and cluster architectures, and shows how clients can reliably locate the current master node after failover.

JedisProxyRedis
0 likes · 7 min read
High‑Availability Strategies for Redis: Sentinel Service Discovery, VIP Binding, Keepalived VRRP, and Proxy Approaches
macrozheng
macrozheng
Jun 15, 2021 · Backend Development

Mastering Redisson: Seamless Distributed Locks in Spring Boot

This tutorial explains what Redisson is, how it extends Redis with powerful distributed data structures and lock mechanisms, and provides step‑by‑step Spring Boot integration, code examples, and detailed testing of re‑entrant, read‑write, and semaphore locks.

JavaRedisRedisson
0 likes · 15 min read
Mastering Redisson: Seamless Distributed Locks in Spring Boot
dbaplus Community
dbaplus Community
Jun 14, 2021 · Backend Development

How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive

This article traces Redis’s transition from its original single‑threaded design to a multi‑threaded architecture by examining the historical VM thread, the BIO background‑job threads introduced in Redis 2.4 and 4.0, and the network IO threads added in Redis 6.0, complete with source‑code excerpts and detailed explanations of each component’s purpose and implementation.

BIO threadIO threadRedis
0 likes · 43 min read
How Redis Evolved from Single‑Threaded to Multi‑Threaded: VM, BIO, and IO Thread Deep Dive
Architecture Digest
Architecture Digest
Jun 13, 2021 · Backend Development

Implementing a Real-Time Leaderboard with Redis for a Mobile Game

This article explains how to build a real‑time, dual‑dimension leaderboard for a mobile tank game using Redis Sorted Sets, covering ranking types, composite score calculations, dynamic updates, efficient data retrieval with pipelines, and a complete PHP implementation.

LeaderboardPHPRedis
0 likes · 8 min read
Implementing a Real-Time Leaderboard with Redis for a Mobile Game
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 12, 2021 · Databases

Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools

This article compares eight Redis visualization tools—desktop clients, a web app, and an IDE plugin—detailing their features, pricing, platform support, and usability, while also showing how command‑line tricks can enhance JSON handling, helping developers choose the most efficient solution for their workflow.

Database ManagementGUIRedis
0 likes · 10 min read
Which Redis GUI Reigns Supreme? A Deep Dive into 8 Popular Tools
Java Backend Technology
Java Backend Technology
Jun 12, 2021 · Databases

Why My Spring API Stalled: Debugging Redis Connection Pool Blocking

A Spring‑based service repeatedly hung because Redis connections were never returned to the pool, leading to thread starvation; the article walks through the investigation using top, jstack, Arthas, and code analysis, then shows the proper way to use RedisCallback and release connections to prevent the deadlock.

JavaJedisRedis
0 likes · 9 min read
Why My Spring API Stalled: Debugging Redis Connection Pool Blocking
IT Architects Alliance
IT Architects Alliance
Jun 11, 2021 · Backend Development

Understanding Message Queues: From Redis List to Kafka and Pulsar

This article explains the evolution of message‑queue middleware by comparing the basic double‑ended queue implementation, Redis list usage, Kafka’s partitioned log architecture with segment files and sparse indexes, and Pulsar’s compute‑storage separation using BookKeeper, highlighting their designs, strengths, and trade‑offs.

KafkaMessage QueuePulsar
0 likes · 28 min read
Understanding Message Queues: From Redis List to Kafka and Pulsar
macrozheng
macrozheng
Jun 11, 2021 · Backend Development

How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story

An in‑depth look at how mattsta’s CRCSpeed implementation replaced Redis’s original CRC algorithm, delivering up to four‑fold speed gains, the history of its development from 2014 to its 2020 integration, and the performance impact on RDB generation and cluster slot hashing.

CRCRedisalgorithm
0 likes · 14 min read
How a Faster CRC-64 Boosted Redis Performance: The CRCSpeed Story
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 10, 2021 · Backend Development

Why Kafka Beats Redis List: A Deep Dive into Message Queue Architecture

This article compares popular message middleware such as Redis, Kafka, and Pulsar, explaining their underlying data structures, strengths and weaknesses, and how concepts like partitions, replication, cursors, and storage segmentation enable high performance, scalability, and reliability in modern distributed messaging systems.

BackendKafkaPulsar
0 likes · 29 min read
Why Kafka Beats Redis List: A Deep Dive into Message Queue Architecture