Skip to content
Tagged articles

Idempotency

417 articles · Page 4 of 5
Top Architect
Top Architect
Mar 30, 2022 · Backend Development

Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations

The article discusses how to achieve interface idempotency using unique business identifiers or token mechanisms, then explores distributed rate limiting by outlining its dimensions, common algorithms such as token bucket and leaky bucket, and provides concrete implementation examples with Guava RateLimiter, Nginx, and Redis‑Lua scripts.

BackendDistributed SystemsIdempotency
0 likes · 20 min read
Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations
DevOps
DevOps
Mar 16, 2022 · Backend Development

Principles and Challenges of Service Integration in Microservice Architecture

The article examines the practical difficulties of integrating services within a microservice architecture—such as circular dependencies, third‑party system coupling, and non‑idempotent APIs—and proposes concrete design principles like one‑way dependencies, minimal redundant data, façade services, idempotency, and contract testing to preserve system health.

Design PrinciplesIdempotencyService Integration
0 likes · 9 min read
Principles and Challenges of Service Integration in Microservice Architecture
DaTaobao Tech
DaTaobao Tech
Mar 9, 2022 · Cloud Native

Distributed System Consistency Handling

The article explains how distributed systems maintain request consistency by employing idempotent IDs, state‑machine tracking, snapshot recording, and coordinated error‑handling strategies—including retries, queries, and messaging—while also addressing read/write separation limits, reconciliation, and disaster‑recovery measures to prevent duplicate actions and state divergence.

ConsistencyDistributed SystemsIdempotency
0 likes · 18 min read
Distributed System Consistency Handling
Cognitive Technology Team
Cognitive Technology Team
Mar 5, 2022 · Backend Development

Ant Financial Wealth Coding Guidelines – Comprehensive Backend Development and Operations Best Practices

This document presents Ant Financial's comprehensive coding standards covering concurrency control, idempotency, state management, object handling, SQL practices, time handling, exception safety, code quality, architecture design, middleware usage, data quality, production change procedures, emergency response, and client‑frontend considerations to ensure robust, secure, and maintainable backend systems.

Idempotencyarchitecturecoding standards
0 likes · 19 min read
Ant Financial Wealth Coding Guidelines – Comprehensive Backend Development and Operations Best Practices
Architecture Digest
Architecture Digest
Mar 4, 2022 · Backend Development

Idempotent API Design and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Nginx, and Redis+Lua

This article explains how to achieve interface idempotency using unique business IDs or token mechanisms and presents comprehensive distributed rate‑limiting techniques—including token‑bucket and leaky‑bucket algorithms, Nginx directives, Guava RateLimiter, and Redis‑Lua scripts—along with practical Spring Boot code examples.

IdempotencyLeaky BucketLua
0 likes · 16 min read
Idempotent API Design and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Nginx, and Redis+Lua
Java Interview Crash Guide
Java Interview Crash Guide
Feb 22, 2022 · Backend Development

Ensuring API Idempotency: Prevent Duplicate Requests in Scalable Systems

Idempotency ensures that repeated API calls produce the same result, preventing duplicate processing in high‑traffic systems; this article explains why it matters, typical duplicate request scenarios, and a practical implementation using client‑generated identifiers to cache and filter repeated submissions.

API designIdempotencymicroservices
0 likes · 4 min read
Ensuring API Idempotency: Prevent Duplicate Requests in Scalable Systems
Top Architect
Top Architect
Feb 17, 2022 · Backend Development

Understanding API Idempotency and How to Ensure It

This article explains the concept of API idempotency, why duplicate requests occur in distributed systems, and presents a comprehensive set of server‑side and client‑side techniques—including token mechanisms, PRG pattern, unique indexes, optimistic locking, distributed locks, and idempotent state machines—to guarantee that repeated calls produce only a single effect.

APIBackendDistributed Systems
0 likes · 10 min read
Understanding API Idempotency and How to Ensure It
Architecture Digest
Architecture Digest
Jan 20, 2022 · Backend Development

Preventing Order Loss in Payment Systems: Best Practices and Strategies

This article explains the typical order flow in payment systems, identifies external and internal order loss scenarios, and provides concrete measures such as adding a "payment in progress" state, setting timeout queries, ensuring idempotent notifications, and using Redis hashes to avoid duplicate submissions.

Idempotencyorder losspayment
0 likes · 5 min read
Preventing Order Loss in Payment Systems: Best Practices and Strategies
Top Architect
Top Architect
Jan 16, 2022 · Backend Development

Key Practices in Large‑Scale Backend Architecture: Product Positioning, Microservice Design, Real‑Time Messaging, Idempotency, and Service Governance

This article outlines essential techniques for building large‑scale backend systems, covering product analysis, microservice architecture principles, the evolution of real‑time push technologies, request idempotency strategies, and comprehensive service governance challenges and solutions.

Backend ArchitectureIdempotencyReal-time Messaging
0 likes · 5 min read
Key Practices in Large‑Scale Backend Architecture: Product Positioning, Microservice Design, Real‑Time Messaging, Idempotency, and Service Governance
Selected Java Interview Questions
Selected Java Interview Questions
Dec 29, 2021 · Backend Development

Understanding Interface Idempotency and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Guava RateLimiter, Nginx, and Redis+Lua

This article explains the concept of interface idempotency, demonstrates how to achieve idempotent update and insert operations using version numbers and token mechanisms, and provides a comprehensive guide to distributed rate limiting—including time‑window and resource dimensions, token‑bucket and leaky‑bucket algorithms, Guava RateLimiter, Nginx configurations, and Redis‑Lua integration with Spring Boot.

Idempotency
0 likes · 20 min read
Understanding Interface Idempotency and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Guava RateLimiter, Nginx, and Redis+Lua
dbaplus Community
dbaplus Community
Nov 29, 2021 · Backend Development

How to Build a High‑Concurrency System: Real‑World Practices from a Delivery Platform

This article shares practical experience on designing and operating a high‑concurrency order‑delivery system, covering infrastructure choices, database scaling techniques such as read‑write separation and sharding, architectural patterns like caching, message queues and service governance, as well as application‑level optimizations including compensation, idempotency, async processing and warm‑up strategies.

IdempotencyService Governancecaching
0 likes · 34 min read
How to Build a High‑Concurrency System: Real‑World Practices from a Delivery Platform
Top Architect
Top Architect
Nov 26, 2021 · Backend Development

Implementing Automatic Idempotency in Spring Boot Using Redis and Interceptors

This article demonstrates how to achieve automatic request idempotency in Spring Boot applications by leveraging Redis for token storage, custom annotations, and interceptor configuration, providing step-by-step code examples for building a Redis service, token service, custom annotation, interceptor, and testing the solution.

IdempotencyInterceptorJava
0 likes · 10 min read
Implementing Automatic Idempotency in Spring Boot Using Redis and Interceptors
IT Architects Alliance
IT Architects Alliance
Nov 26, 2021 · Fundamentals

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS

This article explains the challenges of mutual exclusion and idempotency in distributed environments, compares thread‑level and process‑level solutions, describes the principles and typical implementations of distributed locks (Zookeeper, Redis, Tair, Cerberus), and introduces GTIS as a reliable idempotency framework.

ConcurrencyIdempotencyJava
0 likes · 34 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Locks, Implementations, and GTIS
Architect
Architect
Nov 16, 2021 · Backend Development

Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations

This article explains how to achieve reliable API idempotency in Spring Boot applications by using Redis for token storage, defining a custom @AutoIdempotent annotation, configuring an interceptor to enforce token checks, and providing complete Java code examples and testing steps.

IdempotencyInterceptorJava
0 likes · 9 min read
Implementing API Idempotency with Spring Boot, Redis, and Custom Annotations
JD Tech
JD Tech
Oct 27, 2021 · Backend Development

Understanding Idempotency: When and How to Implement It in Backend Systems

This article examines the concept of idempotency, illustrates typical business scenarios such as order placement and fund transfer, analyzes which layers of a classic system architecture should enforce idempotency, and provides concrete database‑level strategies and code examples to achieve reliable, repeatable operations.

BackendCRUDDAO
0 likes · 8 min read
Understanding Idempotency: When and How to Implement It in Backend Systems
Top Architect
Top Architect
Oct 24, 2021 · Backend Development

Message Deduplication and Exactly‑Once Semantics in RocketMQ

This article explains why RocketMQ guarantees at‑least‑once delivery, describes the three typical duplicate‑message scenarios, compares transaction‑based and non‑transactional deduplication approaches (including a Redis‑based solution), provides sample SQL and Java code, and discusses the limitations and best‑practice recommendations for achieving idempotent message consumption.

IdempotencyJavaRocketMQ
0 likes · 20 min read
Message Deduplication and Exactly‑Once Semantics in RocketMQ
Programmer DD
Programmer DD
Oct 22, 2021 · Backend Development

Implementing Automatic Idempotency in Spring Boot with Redis and Interceptors

This tutorial explains the concept of idempotency in web APIs and demonstrates a complete Spring Boot solution using Redis, custom annotations, token validation, and interceptor configuration to ensure that each request modifies the database only once, even under repeated calls.

IdempotencyInterceptorJava
0 likes · 12 min read
Implementing Automatic Idempotency in Spring Boot with Redis and Interceptors
YunZhu Net Technology Team
YunZhu Net Technology Team
Oct 15, 2021 · Backend Development

Idempotency in Software Systems: Definitions, Real‑World Scenarios, and Implementation Strategies

The article explains the concept of idempotency, illustrates everyday examples of its importance, defines it mathematically and in software, and presents a comprehensive set of practical solutions—including database constraints, frontend controls, locking mechanisms, token‑based forms, message queues, and RPC safeguards—to achieve reliable idempotent behavior in distributed backend systems.

IdempotencyOptimistic Lockpessimistic lock
0 likes · 11 min read
Idempotency in Software Systems: Definitions, Real‑World Scenarios, and Implementation Strategies
Top Architect
Top Architect
Oct 4, 2021 · Backend Development

Mutual Exclusion and Idempotency in Distributed Systems: Problems, Principles, and Solutions

This article examines the challenges of mutual exclusion and idempotency in distributed environments, explains their underlying principles, compares multithread and multiprocess approaches, and presents practical distributed‑lock implementations such as Zookeeper, Redis, Tair, and the Cerberus framework, as well as the GTIS solution for idempotency.

CerberusDistributed SystemsGTIS
0 likes · 32 min read
Mutual Exclusion and Idempotency in Distributed Systems: Problems, Principles, and Solutions
Architecture Digest
Architecture Digest
Sep 28, 2021 · Backend Development

Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Shared Storage Strategies

The article explains why idempotency is essential for reliable services, describes how unique identifiers such as UUIDs and Snowflake-generated IDs can guarantee idempotent operations, and outlines practical storage and query techniques using databases or Redis to prevent duplicate orders, inventory deductions, and payments.

IdempotencySnowflakeUnique ID
0 likes · 6 min read
Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Shared Storage Strategies
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 MechanismIdempotencyOptimistic Lock
0 likes · 9 min read
Guaranteeing No Message Loss in RabbitMQ with Persistence and Confirm
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 MechanismIdempotencyOptimistic Lock
0 likes · 11 min read
How to Guarantee RabbitMQ Message Delivery and Achieve Zero Loss
vivo Internet Technology
vivo Internet Technology
Aug 4, 2021 · Backend Development

Design, Migration, and High‑Performance Architecture of Vivo Mall Coupon System

Vivo Mall transformed its monolithic coupon component into an independent, sharded microservice through a rolling, dual‑write migration, employing Redis distributed locks, batch inserts, multi‑level caching, and read‑write splitting to eliminate bottlenecks, achieve non‑downtime deployment, and deliver scalable, high‑performance coupon handling for future growth.

CacheCoupon SystemIdempotency
0 likes · 17 min read
Design, Migration, and High‑Performance Architecture of Vivo Mall Coupon System
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Aug 4, 2021 · Backend Development

Ensuring Reliable Kafka Messaging: Handling Message Loss, Producer, Broker, and Consumer Configurations

This article explains how Kafka can suffer message loss and duplication, and provides practical configurations for the producer, broker, and consumer—including acks, retries, replication factor, min.insync.replicas, and manual offset commits—to achieve reliable, idempotent message processing.

Idempotencymessage-queuereliability
0 likes · 9 min read
Ensuring Reliable Kafka Messaging: Handling Message Loss, Producer, Broker, and Consumer Configurations
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Jul 10, 2021 · Backend Development

Why Use Message Queues? Benefits, Drawbacks, High Availability, Idempotency, and Practical Tips

The article explains why message queues are essential for decoupling systems, improving latency, handling traffic spikes, ensuring high availability, maintaining order, and achieving idempotent consumption, while also discussing their disadvantages, configuration details for Kafka, RabbitMQ, RocketMQ, and practical troubleshooting strategies.

IdempotencyKafkaMQ
0 likes · 23 min read
Why Use Message Queues? Benefits, Drawbacks, High Availability, Idempotency, and Practical Tips
Selected Java Interview Questions
Selected Java Interview Questions
Jul 3, 2021 · Backend Development

Designing Idempotent APIs and Global ID Strategies

This article explains the concept of API idempotency, why it is needed for reliable retries, and presents practical designs using global unique identifiers such as UUID and Snowflake, including their advantages, drawbacks, and implementation considerations for backend services.

APIIdempotencySnowflake
0 likes · 9 min read
Designing Idempotent APIs and Global ID Strategies
Byte Quality Assurance Team
Byte Quality Assurance Team
Jun 30, 2021 · Fundamentals

Understanding Teardown and Idempotency in Pytest for Automated Testing

This article explains the concept of teardown and idempotency in automated testing, illustrates single‑thread and concurrent scenarios, and demonstrates various Pytest teardown techniques—including function, class, module, fixture yield, request.addfinalizer, and object‑oriented approaches—providing practical code examples for reliable test cleanup.

IdempotencyPythonpytest
0 likes · 9 min read
Understanding Teardown and Idempotency in Pytest for Automated Testing
Top Architect
Top Architect
Jun 24, 2021 · Backend Development

Designing Idempotent APIs and Global Unique ID Strategies

This article explains the concept of API idempotency, why it is needed, practical design approaches, and how to generate globally unique identifiers using methods such as UUID and Snowflake to ensure reliable, high‑performance backend services.

API designBackendIdempotency
0 likes · 8 min read
Designing Idempotent APIs and Global Unique ID Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Jun 21, 2021 · Backend Development

How to Prevent Message Loss, Duplicates, and Backlog in Distributed Queues

This article explains practical techniques for detecting lost messages, ensuring reliable delivery across production, storage, and consumption stages, handling duplicate deliveries with idempotent designs, managing message backlogs through performance tuning, and using transactional messages to achieve distributed transaction consistency.

IdempotencyKafkaMessage Loss
0 likes · 23 min read
How to Prevent Message Loss, Duplicates, and Backlog in Distributed Queues
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Jun 20, 2021 · Backend Development

How to Prevent Message Loss and Ensure Reliable Delivery in Distributed Systems

This article explains practical techniques for detecting lost messages, guaranteeing reliable production, storage, and consumption stages, handling duplicate deliveries with idempotent designs, managing message backlogs, and implementing distributed transactions using transactional messages in modern message queue systems.

IdempotencyKafkadistributed transaction
0 likes · 18 min read
How to Prevent Message Loss and Ensure Reliable Delivery in Distributed Systems
Architects Research Society
Architects Research Society
Jun 16, 2021 · Backend Development

Common Pitfalls in Microservice Integration and How to Mitigate Them

The article explains three frequent pitfalls when adopting microservices—complex remote communication, asynchronous processing challenges, and distributed transaction difficulties—and shows how fast‑fail, retries, timeouts, compensation, lightweight workflow engines, and idempotency can reduce complexity and improve resilience.

Distributed SystemsFault ToleranceIdempotency
0 likes · 13 min read
Common Pitfalls in Microservice Integration and How to Mitigate Them
Java Backend Technology
Java Backend Technology
Jun 4, 2021 · Backend Development

How to Prevent Duplicate Requests in Java Services with Redis and MD5

This article explains why duplicate requests—especially write operations—can cause serious issues, outlines common duplication scenarios, and presents a complete server‑side solution using unique request IDs with Redis as well as business‑parameter hashing with MD5 to achieve reliable idempotency in Java back‑end systems.

BackendIdempotencyMD5
0 likes · 9 min read
How to Prevent Duplicate Requests in Java Services with Redis and MD5
Top Architect
Top Architect
May 27, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems: Best Practices

The article explains common causes of order loss and duplicate submissions in payment workflows, distinguishes external and internal loss, and provides concrete backend strategies such as intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based deduplication to ensure reliable order processing.

BackendIdempotencyorder management
0 likes · 5 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems: Best Practices
Programmer DD
Programmer DD
May 25, 2021 · Backend Development

How to Prevent Lost Orders in Payment Systems: Proven Backend Strategies

This article explains the typical order‑payment flow, identifies common causes of lost orders—both external and internal—and provides concrete backend techniques such as intermediate payment states, timeout queries, idempotent notifications, and Redis‑based duplicate‑submission prevention to ensure reliable order processing.

IdempotencyOrder ProcessingTimeout
0 likes · 5 min read
How to Prevent Lost Orders in Payment Systems: Proven Backend Strategies
Architecture Digest
Architecture Digest
May 2, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems

This article explains the typical payment flow, identifies causes of external and internal order loss, and provides concrete backend strategies—including intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based duplicate‑submission protection—to ensure reliable order processing.

IdempotencyRetryWeChat Pay
0 likes · 4 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 25, 2021 · Backend Development

Designing Duplicate Request Filtering: Challenges, Solutions, and Best Practices

The article examines why duplicate request filtering is a complex backend problem, explores various causes, discusses client‑side and server‑side strategies such as request IDs, Redis checks, distributed locks, and request signing, and highlights practical pitfalls and security considerations.

Idempotencyduplicate requestrequest signing
0 likes · 9 min read
Designing Duplicate Request Filtering: Challenges, Solutions, and Best Practices
Intelligent Backend & Architecture
Intelligent Backend & Architecture
Apr 23, 2021 · Backend Development

Why Message Queues Are Essential: Benefits, Pitfalls, and Best Practices

This article explains the role of message queues in handling traffic spikes, decoupling services, and ensuring reliability, compares popular MQ solutions such as RabbitMQ, Kafka, RocketMQ and ActiveMQ, and discusses their architectures, advantages, drawbacks, idempotency, ordering, high‑availability and scaling strategies.

High AvailabilityIdempotencyKafka
0 likes · 38 min read
Why Message Queues Are Essential: Benefits, Pitfalls, and Best Practices
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Apr 18, 2021 · Backend Development

Idempotency: Definition, Scenarios, and Implementation Strategies

The article explains the concept of idempotency, distinguishes it from duplicate submissions, outlines typical use cases such as network retries and form resubmissions, and presents various backend solutions—including unique indexes, deduplication tables, pessimistic and optimistic locks, distributed locks, and token‑based approaches—complete with SQL examples.

IdempotencyOptimistic Lockpessimistic lock
0 likes · 11 min read
Idempotency: Definition, Scenarios, and Implementation Strategies
Wukong Talks Architecture
Wukong Talks Architecture
Apr 17, 2021 · Backend Development

Practical Techniques for Ensuring API Idempotency

This article explains the concept of API idempotency, presents common scenarios that cause duplicate data, and details eight practical solutions—including pre‑select before insert, pessimistic and optimistic locking, unique indexes, anti‑duplicate tables, state‑machine checks, distributed locks, and token‑based approaches—along with their implementation steps and caveats.

APIBackendIdempotency
0 likes · 13 min read
Practical Techniques for Ensuring API Idempotency
Java Captain
Java Captain
Apr 3, 2021 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems

This article explains common causes of order loss and duplicate submissions in payment workflows, and provides practical backend strategies such as intermediate payment states, timeout queries, idempotent handling, retry mechanisms, and Redis‑based deduplication to ensure reliable order processing.

IdempotencyRetryTransaction
0 likes · 4 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems
Top Architect
Top Architect
Mar 30, 2021 · Backend Development

Understanding Idempotency and Its Implementation in RESTful APIs

This article explains the concept of idempotency, why it is essential for HTTP interfaces, the impact on system design, and presents several practical implementation strategies—including unique primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by a complete Spring Boot example with Redis integration and test code.

IdempotencyJavaREST API
0 likes · 21 min read
Understanding Idempotency and Its Implementation in RESTful APIs
Su San Talks Tech
Su San Talks Tech
Mar 28, 2021 · Backend Development

How to Ensure API Idempotency: 8 Proven Strategies for Backend Systems

Ensuring API idempotency prevents duplicate data caused by repeated requests, timeouts, or message reprocessing, and can be achieved through techniques such as pre‑insert checks, pessimistic and optimistic locking, unique indexes, anti‑duplicate tables, state‑machine checks, distributed locks, and token‑based validation.

Idempotencydistributed-systemslocking
0 likes · 13 min read
How to Ensure API Idempotency: 8 Proven Strategies for Backend Systems
Kuaishou Tech
Kuaishou Tech
Mar 25, 2021 · Backend Development

Designing a High‑Availability Cache Consistency Solution for the Creator Red Packet System

This article explains how the creator red‑packet feature was engineered to guarantee idempotent, fault‑tolerant, and high‑throughput red‑packet claims by using multi‑level caching, empty placeholders, binlog‑driven synchronization, active cache invalidation, ordered Kafka consumption, and fallback strategies to resolve cache‑DB consistency issues.

Cache ConsistencyIdempotencyKafka
0 likes · 11 min read
Designing a High‑Availability Cache Consistency Solution for the Creator Red Packet System
ITPUB
ITPUB
Mar 25, 2021 · Backend Development

Why a TCC Framework Must Own the Spring TransactionManager

This article examines the challenges of building a generic TCC distributed‑transaction framework on Spring, explaining why every TCC service must participate in RM‑local transactions, why the framework should intercept the Spring TransactionManager, how to handle fault recovery, idempotency of Confirm/Cancel, and the pitfalls of relying on Cancel for rollback, concluding with practical recommendations.

Fault RecoveryIdempotencySpring
0 likes · 18 min read
Why a TCC Framework Must Own the Spring TransactionManager
Java Architect Essentials
Java Architect Essentials
Feb 26, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests on the Server Side

This article explains why duplicate requests—especially write operations—can cause serious issues, outlines common causes such as replay attacks and client retries, and provides a comprehensive server‑side solution using unique request IDs, Redis, and MD5‑based parameter deduplication with Java code examples.

IdempotencyJavaMD5
0 likes · 9 min read
How to Gracefully Prevent Duplicate Requests on the Server Side
Top Architect
Top Architect
Feb 15, 2021 · Backend Development

Implementing API Idempotency in SpringBoot Using Redis Token Mechanism

This tutorial explains the concept of idempotency, why it is needed for reliable APIs, the impact on system design, and provides four implementation strategies—including a detailed SpringBoot example that uses Redis tokens, Lua scripts, and unit tests—to ensure that repeated requests produce the same result without side effects.

IdempotencyJavaRESTful API
0 likes · 18 min read
Implementing API Idempotency in SpringBoot Using Redis Token Mechanism
21CTO
21CTO
Feb 14, 2021 · Backend Development

How to Gracefully Prevent Duplicate Requests with Redis and Java

This article explains why duplicate requests—especially those that modify data—can be dangerous, outlines common causes, and provides a comprehensive server‑side solution using unique request IDs, parameter hashing, and a Java utility class with Redis to reliably deduplicate incoming calls.

IdempotencyJavaRequest Handling
0 likes · 8 min read
How to Gracefully Prevent Duplicate Requests with Redis and Java
Code Ape Tech Column
Code Ape Tech Column
Feb 4, 2021 · Backend Development

Implementing API Idempotency in SpringBoot Using Token and Redis

This article explains the concept of idempotency, why it is needed for HTTP interfaces, its impact on system design, and presents four practical backend solutions—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—followed by a complete SpringBoot example with Maven dependencies, Redis configuration, token utility code, controller, application starter, and test cases.

IdempotencyJavaRESTful API
0 likes · 20 min read
Implementing API Idempotency in SpringBoot Using Token and Redis
Code Ape Tech Column
Code Ape Tech Column
Jan 25, 2021 · Backend Development

Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm, and Idempotent Strategies

This article examines how to guarantee reliable message delivery in RabbitMQ by using durable queues, the confirm callback mechanism, pre‑persisting messages with Redis or a database, scheduled compensation tasks, and idempotent processing techniques such as optimistic locking and unique‑ID fingerprinting.

BackendConfirm CallbackIdempotency
0 likes · 11 min read
Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm, and Idempotent Strategies
Selected Java Interview Questions
Selected Java Interview Questions
Jan 22, 2021 · Backend Development

Ensuring Reliable Message Delivery with RabbitMQ: Persistence, Confirm Mechanism, and Idempotency Strategies

This article explains how to guarantee reliable message delivery in RabbitMQ by using durable queues, the confirm mechanism, and supplemental strategies such as pre‑persisting messages to Redis, scheduled compensation tasks, and idempotent consumer design to prevent duplicate processing.

Idempotencyconfirmdistributed-systems
0 likes · 9 min read
Ensuring Reliable Message Delivery with RabbitMQ: Persistence, Confirm Mechanism, and Idempotency Strategies
Java Interview Crash Guide
Java Interview Crash Guide
Jan 8, 2021 · Backend Development

Mastering API Idempotency: Strategies, Code Samples, and Best Practices

Idempotency ensures that repeated API calls produce the same effect as a single call, preventing duplicate submissions, token misuse, and inconsistent data; this guide explains the concept, its importance, HTTP definitions, impact on systems, and presents four practical implementation methods—unique keys, optimistic locking, token‑based guards, and sequence numbers—with full SpringBoot and Redis code examples.

APIIdempotencyREST
0 likes · 20 min read
Mastering API Idempotency: Strategies, Code Samples, and Best Practices
Xianyu Technology
Xianyu Technology
Dec 15, 2020 · Backend Development

How Xianyu Built the ‘Resale Lottery’ and ‘Money Tree’ Marketing Engines

This article examines Xianyu's two promotional features—Resale Lottery and Money Tree—detailing their gameplay, underlying business models, and the backend technical solutions such as event collection, idempotent reward accounting, concurrency control, fatigue management, and distributed locking.

Event ProcessingIdempotencybackend development
0 likes · 11 min read
How Xianyu Built the ‘Resale Lottery’ and ‘Money Tree’ Marketing Engines
ITFLY8 Architecture Home
ITFLY8 Architecture Home
Dec 9, 2020 · Backend Development

Ensuring Idempotency in High‑Concurrency E‑Commerce APIs: Strategies & Code

This article explains the concept of idempotency and presents practical techniques—such as unique indexes, token validation, pessimistic and optimistic locking, distributed locks, and API design—to guarantee that repeated requests in a high‑traffic e‑commerce system produce a single consistent outcome.

BackendIdempotencyOptimistic Lock
0 likes · 8 min read
Ensuring Idempotency in High‑Concurrency E‑Commerce APIs: Strategies & Code
Senior Brother's Insights
Senior Brother's Insights
Nov 30, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Code Examples

The article explains why idempotent operations are essential in backend and financial systems, describes the mathematical concept, and presents practical techniques such as unique indexes, token validation, pessimistic and optimistic locking, distributed locks, state‑machine design, and API patterns with concrete SQL examples.

IdempotencyOptimistic Lockdatabase
0 likes · 8 min read
Ensuring Idempotency in Distributed Systems: Strategies and Code Examples
Java Architecture Diary
Java Architecture Diary
Nov 10, 2020 · Backend Development

Ensuring Idempotency in Spring Boot: Token-Based Approach with Redis

This article explains the concept of idempotency, its importance in distributed systems, and demonstrates a practical implementation in Spring Boot using a token-based annotation, Redis configuration, and sample code, along with testing results that show only one successful response among concurrent requests.

Idempotencyspring-boot
0 likes · 6 min read
Ensuring Idempotency in Spring Boot: Token-Based Approach with Redis
Top Architect
Top Architect
Oct 29, 2020 · Backend Development

Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism

This article explains the concept of API idempotency, presents common solutions such as unique indexes, token mechanisms, and distributed locks, and provides a complete Spring Boot implementation using Redis to generate, store, and validate tokens via custom annotations, interceptors, and service classes, including testing and performance verification.

APIIdempotencyInterceptor
0 likes · 14 min read
Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism
Tuhu Marketing Technology Team
Tuhu Marketing Technology Team
Oct 10, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Code Samples

This article explains the concept of idempotency, examines common failure scenarios such as duplicate order creation, coupon redemption, and inventory deduction, and presents practical solutions—including unique identifiers, locking, database constraints, and state‑machine approaches—accompanied by concrete SQL and pseudo‑code examples.

Code ExamplesDistributed SystemsIdempotency
0 likes · 12 min read
Ensuring Idempotency in Distributed Systems: Strategies and Code Samples
Architect's Tech Stack
Architect's Tech Stack
Sep 30, 2020 · Backend Development

Implementing API Idempotency with Redis Token Mechanism in Spring Boot

This article explains the concept of API idempotency, reviews common solutions, and provides a complete Spring Boot implementation using a Redis‑based token mechanism, custom @ApiIdempotent annotation, interceptor, and supporting services, along with testing and important concurrency considerations.

APIIdempotencyInterceptor
0 likes · 14 min read
Implementing API Idempotency with Redis Token Mechanism in Spring Boot
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Sep 20, 2020 · Backend Development

General Idempotent Implementation for Backend Services

This article explains the concepts, challenges, and practical implementations of idempotency in backend systems, covering simple database‑record checks, concurrency handling with locks, a reusable idempotent component with multi‑level storage, annotation support, automatic key generation, and sample Java code.

Idempotencyannotation
0 likes · 11 min read
General Idempotent Implementation for Backend Services
dbaplus Community
dbaplus Community
Sep 16, 2020 · Backend Development

How to Solve Distributed Transactions, Idempotency, and Async Messaging in Microservices

This article shares practical strategies for handling distributed transactions, idempotent operations, and asynchronous message ordering in microservice architectures, covering pitfalls of RPC inside transactions, compensation patterns, local message tables, and state‑driven messaging to achieve reliable consistency without sacrificing performance.

Idempotencycompensationlocal message table
0 likes · 25 min read
How to Solve Distributed Transactions, Idempotency, and Async Messaging in Microservices
Java Backend Technology
Java Backend Technology
Sep 13, 2020 · Backend Development

How to Build a Robust Idempotent Framework for Distributed Systems

This article explains why idempotency is essential, presents simple database‑based and concurrency‑safe implementations, and then details a generic, annotation‑driven idempotent framework with multi‑level storage, code examples, and deployment guidelines for Java backend services.

BackendDistributed SystemsIdempotency
0 likes · 12 min read
How to Build a Robust Idempotent Framework for Distributed Systems
Top Architect
Top Architect
Aug 16, 2020 · Backend Development

Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism

This article explains how to achieve API idempotency in a Spring Boot application by generating unique tokens, storing them in Redis, and using a custom @ApiIdempotent annotation with an interceptor to prevent duplicate requests, including code examples, configuration, and testing procedures.

APIIdempotencyInterceptor
0 likes · 14 min read
Implementing API Idempotency in Spring Boot Using Redis and Token Mechanism
macrozheng
macrozheng
Jul 20, 2020 · Backend Development

How to Prevent Duplicate Submissions in Java: Simple Backend Solutions

This article explores practical methods to prevent duplicate submissions in Java applications, starting with a simple front‑end button disabling technique and progressing through several backend strategies—including HashMap, fixed‑size array, double‑checked locking, and Apache Commons LRUMap—complete with code samples and performance considerations.

BackendIdempotencyJava
0 likes · 17 min read
How to Prevent Duplicate Submissions in Java: Simple Backend Solutions
Programmer DD
Programmer DD
Jul 11, 2020 · Backend Development

How to Build a Reliable Email Service with RabbitMQ and Spring Boot

This article walks through creating a robust email‑sending system using Spring Boot and RabbitMQ, covering message confirmation, consumer idempotency, retry mechanisms, scheduled re‑delivery, and detailed code examples to ensure reliable delivery even under failure conditions.

IdempotencyMessage RetryRabbitMQ
0 likes · 16 min read
How to Build a Reliable Email Service with RabbitMQ and Spring Boot
Top Architect
Top Architect
Jun 8, 2020 · Backend Development

Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Distributed ID Generation

The article explains why idempotency is essential for reliable services, describes how unique identifiers such as UUIDs, Snowflake IDs, and database‑generated keys can be used to achieve it, and offers practical guidance on shared storage, avoiding unnecessary queries, and handling duplicate requests in distributed systems.

IdempotencySnowflakeUnique ID
0 likes · 8 min read
Ensuring Idempotency with Unique IDs: UUID, Snowflake, and Distributed ID Generation
Architecture Digest
Architecture Digest
May 11, 2020 · Backend Development

Ensuring Idempotency in Distributed Systems: Unique ID Generation Strategies

The article explains why idempotency is essential for reliable service calls, discusses using unique identifiers such as UUIDs and Snowflake algorithms, compares centralized and client‑side ID generation, and offers practical storage and query‑optimisation techniques to prevent duplicate orders and resource waste.

Distributed SystemsIdempotencySnowflake
0 likes · 6 min read
Ensuring Idempotency in Distributed Systems: Unique ID Generation Strategies
21CTO
21CTO
May 2, 2020 · Backend Development

Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools

This article introduces Alibaba's distributed‑tools component, explaining how to configure Redis/Tair cache, implement fixed‑window rate limiting, use a high‑performance distributed lock template, and apply idempotency mechanisms with annotations and templates to ensure reliable microservice operations.

IdempotencySpringBootcaching
0 likes · 15 min read
Master Distributed Caching, Rate Limiting, Locks & Idempotency with Alibaba Tools
Full-Stack Internet Architecture
Full-Stack Internet Architecture
Mar 22, 2020 · Backend Development

API Design Specification Guidelines for Backend Development

This article provides comprehensive API design guidelines covering routing naming conventions, request methods, parameter structures, security measures, response formats, signature design, logging platform setup, and idempotency strategies to help backend developers create consistent and reliable interfaces.

API designBackendIdempotency
0 likes · 6 min read
API Design Specification Guidelines for Backend Development
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 27, 2020 · Fundamentals

Message Queue Usage, Advantages, Disadvantages, and High‑Availability Design

The article explains why message queues are used, outlines their core scenarios—decoupling, asynchronous processing, and traffic shaping—compares Kafka, ActiveMQ, RabbitMQ, and RocketMQ, and details how to ensure high availability, reliability, idempotency, ordering, and scalability in production systems.

IdempotencyKafkaMessage Queue
0 likes · 34 min read
Message Queue Usage, Advantages, Disadvantages, and High‑Availability Design
Big Data Technology & Architecture
Big Data Technology & Architecture
Feb 11, 2020 · Backend Development

Message Queue Interview Guide: Benefits, Drawbacks, High Availability, Idempotency, Ordering and Design Strategies

This article provides a comprehensive interview‑oriented overview of message queues, explaining why they are used, their core advantages and disadvantages, comparing Kafka, RabbitMQ, ActiveMQ and RocketMQ, and detailing high‑availability, reliability, idempotency, ordering, backlog handling and architectural design considerations.

IdempotencyKafkaMessage Queue
0 likes · 33 min read
Message Queue Interview Guide: Benefits, Drawbacks, High Availability, Idempotency, Ordering and Design Strategies
Architecture Digest
Architecture Digest
Jan 21, 2020 · Backend Development

Implementing Idempotent Requests with Local Locks, AOP, and Redis in Java

This article explains the concept of idempotency in web services, analyzes common causes of duplicate submissions, and presents multiple backend solutions—including frontend button disabling, PRG pattern, session flags, local locks using ConcurrentHashMap, AOP interceptors, and distributed Redis locks—accompanied by complete Java code examples.

IdempotencySpring
0 likes · 13 min read
Implementing Idempotent Requests with Local Locks, AOP, and Redis in Java
Architecture Digest
Architecture Digest
Jan 7, 2020 · Backend Development

Ensuring 100% Message Delivery with RabbitMQ: Reliability Steps and Idempotent Design

This article explains how to achieve guaranteed 100% message delivery in RabbitMQ by leveraging its acknowledgment mechanisms, implementing producer‑side confirmation steps, designing compensation and retry logic, and ensuring consumer‑side idempotency through unique identifiers and various ID‑generation strategies.

Distributed SystemsIdempotencyMessage Delivery
0 likes · 7 min read
Ensuring 100% Message Delivery with RabbitMQ: Reliability Steps and Idempotent Design
Java Captain
Java Captain
Jan 6, 2020 · Backend Development

Implementing API Idempotency with Redis Token Mechanism in Spring Boot

This article explains how to achieve interface idempotency in a Spring Boot application by generating a unique token for each request, storing it in Redis, validating the token via a custom annotation and interceptor, and provides complete code examples and testing guidance.

IdempotencyInterceptorJava
0 likes · 16 min read
Implementing API Idempotency with Redis Token Mechanism in Spring Boot
Senior Brother's Insights
Senior Brother's Insights
Dec 25, 2019 · Backend Development

Ensuring Idempotency in Distributed Systems: Strategies and Best Practices

The article explains why idempotent operations are essential in high‑traffic systems, defines idempotency, and presents a comprehensive set of techniques—including unique indexes, token validation, pessimistic and optimistic locking, distributed locks, select‑plus‑insert patterns, state‑machine design, and API safeguards—to guarantee consistent outcomes even under repeated requests.

IdempotencyOptimistic Lockdatabase
0 likes · 9 min read
Ensuring Idempotency in Distributed Systems: Strategies and Best Practices
Programmer DD
Programmer DD
Dec 9, 2019 · Backend Development

How to Ensure Idempotency in Distributed Systems: Strategies and Code Examples

This article explains the importance of idempotent operations in backend systems, defines the concept, and presents practical techniques such as unique indexes, token mechanisms, pessimistic and optimistic locking, distributed locks, state‑machine design, and API patterns, complete with code snippets and diagrams.

BackendDistributed SystemsIdempotency
0 likes · 10 min read
How to Ensure Idempotency in Distributed Systems: Strategies and Code Examples
Selected Java Interview Questions
Selected Java Interview Questions
Nov 1, 2019 · Backend Development

Implementing Idempotency for API Requests in Backend Development

The article explains how to improve system scalability through hardware and software architecture enhancements, defines idempotency and its importance for preventing duplicate processing, and describes a practical implementation using unique request identifiers to ensure consistent responses for repeated API calls.

APIIdempotencymicroservices
0 likes · 4 min read
Implementing Idempotency for API Requests in Backend Development
Programmer DD
Programmer DD
Aug 11, 2019 · Backend Development

Ensuring API Idempotency with Spring Boot, Redis, and Token Interceptor

This article explains the concept of idempotency, lists common solutions, and demonstrates a practical implementation using Spring Boot, Redis, and a token‑based mechanism with custom annotations and interceptors, including full code examples, testing steps, and important pitfalls to avoid.

APIIdempotencyInterceptor
0 likes · 11 min read
Ensuring API Idempotency with Spring Boot, Redis, and Token Interceptor
Youzan Coder
Youzan Coder
Aug 9, 2019 · Backend Development

How Youzan Built a Scalable Task Center: Architecture, Idempotency, and Dynamic Config

This article explains why a task center is essential for merchants, outlines its goals, and details the backend architecture—including atomic APIs, Apollo-driven dynamic configuration, idempotent control, workflow orchestration, caching, and asynchronous logging—while also sharing future enhancements.

Backend ArchitectureDynamic ConfigurationIdempotency
0 likes · 8 min read
How Youzan Built a Scalable Task Center: Architecture, Idempotency, and Dynamic Config
dbaplus Community
dbaplus Community
Jul 4, 2019 · Databases

How Tencent’s TDSQL Multi‑Source Sync Achieves High‑Performance, Consistent Data Distribution

This article explains the financial‑industry driven requirements for real‑time data sync, describes the TDSQL‑MULTISRCSYNC architecture—including producer, store, and consumer components—and details core designs such as row‑hash concurrency, idempotent binlog handling, and a lock‑based ordering mechanism that ensure high throughput and consistency.

Database ReplicationIdempotencyKafka
0 likes · 13 min read
How Tencent’s TDSQL Multi‑Source Sync Achieves High‑Performance, Consistent Data Distribution
Java High-Performance Architecture
Java High-Performance Architecture
May 15, 2019 · Databases

How to Achieve Distributed Transaction Consistency with Message Queues

This article explains how to handle distributed transactions in microservice architectures by using eventual consistency with message middleware, discusses the pitfalls of combining database updates and message sending in a single transaction, and presents a reliable solution involving a message table, background processing, ACK mechanisms, and deduplication.

Idempotencydistributed transactionseventual consistency
0 likes · 5 min read
How to Achieve Distributed Transaction Consistency with Message Queues
Tencent Cloud Developer
Tencent Cloud Developer
May 14, 2019 · Operations

Handling Connection Loss and Session Expiry in ZooKeeper-based Distributed Locks

When using ZooKeeper‑based distributed locks, applications must detect CONNECTIONLOSS and SESSIONEXPIRED events, verify the master znode to confirm leadership, relinquish duties on session expiry, and design idempotent tasks to avoid split‑brain or duplicate execution caused by network partitions or quorum delays.

IdempotencyLeader ElectionZooKeeper
0 likes · 10 min read
Handling Connection Loss and Session Expiry in ZooKeeper-based Distributed Locks
Java Backend Technology
Java Backend Technology
May 6, 2019 · Backend Development

Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm & Idempotency

This article explains how to guarantee that order service messages are reliably delivered to RabbitMQ by using durable queues, the confirm mechanism, early persistence with Redis and scheduled retries, and idempotent processing techniques to achieve near‑100% message safety in high‑concurrency environments.

Confirm MechanismDistributed SystemsIdempotency
0 likes · 10 min read
Ensuring Zero Message Loss in RabbitMQ: Persistence, Confirm & Idempotency
Programmer DD
Programmer DD
Jan 18, 2019 · Backend Development

Mastering Compensation: When to Rollback vs Retry in Distributed Systems

This article explains the purpose of compensation mechanisms in microservice architectures, compares rollback and retry approaches, outlines their implementation details, discusses idempotency concerns, and provides practical best‑practice recommendations for building resilient distributed systems.

Distributed SystemsIdempotencyRetry
0 likes · 12 min read
Mastering Compensation: When to Rollback vs Retry in Distributed Systems
21CTO
21CTO
Dec 31, 2018 · Backend Development

Designing Robust APIs: Principles, Practices, and Real-World Examples

This article explores core API design principles—clear mental models, simplicity, multiple implementations—and offers concrete best‑practice guidance, from documentation and resource modeling to idempotency, compatibility, batch updates, and error handling, illustrated with the classic POSIX File API.

API designIdempotencycompatibility
0 likes · 21 min read
Designing Robust APIs: Principles, Practices, and Real-World Examples
Alibaba Cloud Native
Alibaba Cloud Native
Dec 28, 2018 · Backend Development

Essential API Design Principles and Practical Guidelines

This article explores why API design is crucial for large‑scale software systems, outlines fundamental design principles, presents detailed best‑practice recommendations, and discusses compatibility, idempotency, error handling, and versioning with concrete examples such as the POSIX File API.

API designBest PracticesIdempotency
0 likes · 21 min read
Essential API Design Principles and Practical Guidelines
Architect's Tech Stack
Architect's Tech Stack
Dec 22, 2018 · Backend Development

Understanding Idempotency: Concepts, Examples, and Implementation Techniques

This article explains the mathematical and programming concept of idempotency, provides real‑world examples such as duplicate form submissions and payment requests, and details practical techniques—including query/select operations, unique indexes, token mechanisms, pessimistic and optimistic locks, distributed locks, and API design—to ensure idempotent behavior in backend systems.

Distributed SystemsIdempotencyOptimistic Lock
0 likes · 9 min read
Understanding Idempotency: Concepts, Examples, and Implementation Techniques
Hujiang Technology
Hujiang Technology
Nov 26, 2018 · Backend Development

Ensuring Distributed Final Consistency: Heavy and Light Approaches, Principles and Practices

The article explains distributed final consistency challenges, compares heavyweight transaction frameworks with lightweight techniques such as idempotency, retries, state machines, recovery logs, and async verification, and outlines CAP, BASE principles and practical implementation steps for backend systems.

BASECAP theoremConsistency
0 likes · 14 min read
Ensuring Distributed Final Consistency: Heavy and Light Approaches, Principles and Practices
360 Tech Engineering
360 Tech Engineering
Jul 19, 2018 · Backend Development

Understanding Idempotency in Software Systems and How to Ensure It

The article explains the concept of idempotency, why it is critical for data consistency in backend services, and presents practical techniques such as unique business identifiers, locking, optimistic concurrency, deduplication tables, distributed locks, token mechanisms, and payment buffering to achieve reliable idempotent operations.

Distributed SystemsIdempotency
0 likes · 5 min read
Understanding Idempotency in Software Systems and How to Ensure It