BestHub
Sign in
Tagged articles

idempotency

273 articles · Page 2 of 3
macrozheng
macrozheng
Sep 18, 2023 · Backend Development

Secure & Scalable API Design: Signatures, Encryption, Rate Limiting, and More

This article outlines comprehensive best‑practice guidelines for building robust API interfaces, covering signature mechanisms, data encryption, IP whitelisting, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, request limits, performance testing, asynchronous processing, data masking, and documentation standards.

API designLoggingbest practices
0 likes · 15 min read
Secure & Scalable API Design: Signatures, Encryption, Rate Limiting, and More
Shepherd Advanced Notes
Shepherd Advanced Notes
Sep 15, 2023 · Backend Development

How to Prevent Duplicate Order Submissions in Flash‑Sale Systems: An Idempotency Guide

The article explains the concept of idempotency, outlines common duplicate‑submission scenarios such as form resubmission, malicious voting, client retries, and message re‑consumption, and details three practical implementation methods—database constraints, token‑based middleware, and state‑machine logic—complete with code examples and trade‑off considerations.

Backend DevelopmentTokendatabase
0 likes · 13 min read
How to Prevent Duplicate Order Submissions in Flash‑Sale Systems: An Idempotency Guide
Senior Tony
Senior Tony
Aug 30, 2023 · Backend Development

How to Prevent Duplicate Order Submissions in High‑Traffic E‑Commerce Systems

The article examines why duplicate order submissions occur in e‑commerce, outlines four practical solutions—including button disabling, pre‑generated UUIDs, client‑side ID generation, and Redis‑based idempotency—compares their pros and cons, and explains why a Redis key approach was ultimately chosen for production.

backendduplicate-submissione-commerce
0 likes · 7 min read
How to Prevent Duplicate Order Submissions in High‑Traffic E‑Commerce Systems
Su San Talks Tech
Su San Talks Tech
Aug 17, 2023 · Backend Development

Ensuring API Idempotency with Spring, Redis, and Custom Annotations

This article explains the concept of idempotency, identifies which HTTP methods are naturally idempotent, and demonstrates a complete Java Spring solution—including custom annotations, AOP handling, token generation, and Redis storage—to guarantee safe retry and duplicate‑request protection.

AOPAnnotationJava
0 likes · 11 min read
Ensuring API Idempotency with Spring, Redis, and Custom Annotations
Java Backend Technology
Java Backend Technology
Aug 15, 2023 · Backend Development

How to Ensure Order Service Idempotency and Prevent Duplicate Orders

This article explains how to achieve idempotent order creation and updates in backend services by using unique request identifiers, database unique constraints, Redis flags, and optimistic locking with version columns, while also addressing the ABA problem with practical code examples and diagrams.

ABA problemOptimistic LockingRedis
0 likes · 10 min read
How to Ensure Order Service Idempotency and Prevent Duplicate Orders
Top Architect
Top Architect
Aug 13, 2023 · Backend Development

Implementing Idempotency in Spring Boot with Custom Annotations and Redis

This article explains the concept of idempotency, identifies naturally idempotent HTTP methods, discusses why idempotency is essential for retries, async callbacks, and message queues, and provides a complete Spring Boot implementation using a custom @Idempotent annotation, AOP, and Redis for token storage.

AnnotationJavaRedis
0 likes · 12 min read
Implementing Idempotency in Spring Boot with Custom Annotations and Redis
Top Architect
Top Architect
Jul 27, 2023 · Backend Development

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

This article explains the typical order‑payment flow, identifies external and internal causes of lost orders, and provides concrete backend strategies—such as adding a "payment‑in‑progress" state, timeout‑based query retries, idempotent handling, and Redis‑based duplicate‑submission protection—to ensure reliable order processing and avoid duplicate payments.

WeChat Paybackendbest practices
0 likes · 6 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems: Best Practices
Java Interview Crash Guide
Java Interview Crash Guide
Jul 26, 2023 · Backend Development

Ensuring API Idempotency: 4 Proven Strategies with SpringBoot & Redis

This article explains why API idempotency is crucial in real‑world systems, outlines which operations need it, discusses the trade‑offs of adding idempotency, and presents four practical implementation patterns—including unique primary keys, optimistic locking, anti‑duplicate tokens, and downstream sequence numbers—complete with SpringBoot code examples.

APIJavaRedis
0 likes · 23 min read
Ensuring API Idempotency: 4 Proven Strategies with SpringBoot & Redis
Java Architect Essentials
Java Architect Essentials
Jul 19, 2023 · Backend Development

Preventing Order Loss and Duplicate Submissions in Payment Systems

This article explains the typical order‑payment flow, identifies causes of order loss and duplicate submissions, and provides practical backend strategies such as intermediate payment states, timeout queries, idempotent handling, Redis‑based duplicate checks, and WeChat Pay best practices to ensure reliable order processing.

WeChat Payduplicate-submissionidempotency
0 likes · 5 min read
Preventing Order Loss and Duplicate Submissions in Payment Systems
ITPUB
ITPUB
Jul 1, 2023 · Fundamentals

Mastering Distributed Systems: CAP, BASE, Locks, Transactions, Paxos & Raft Explained

This article provides a comprehensive overview of core distributed‑system concepts—including the CAP theorem, BASE model, common distributed‑lock implementations, multiple distributed‑transaction patterns such as 2PC, 3PC, TCC, local‑message tables, MQ transactions and Seata, as well as consistency algorithms like Paxos and Raft, idempotency techniques, and rate‑limiting algorithms—explaining their motivations, trade‑offs, and practical usage.

BASECAP theoremPaxos
0 likes · 30 min read
Mastering Distributed Systems: CAP, BASE, Locks, Transactions, Paxos & Raft Explained
JD Retail Technology
JD Retail Technology
Jun 30, 2023 · Fundamentals

Fundamentals of Distributed Systems: CAP Theory, ACID, BASE, Idempotency, and Distributed Transaction Protocols

This article explains core distributed‑system concepts such as the CAP theorem, ACID and BASE transaction models, idempotent design, and various distributed transaction mechanisms including two‑phase and three‑phase commit, TCC/Saga compensation, message‑based transactions, and popular frameworks like JDTS and Seata.

2PC3PCACID
0 likes · 6 min read
Fundamentals of Distributed Systems: CAP Theory, ACID, BASE, Idempotency, and Distributed Transaction Protocols
政采云技术
政采云技术
Jun 8, 2023 · Backend Development

Idempotency Design Principles and Practices in Distributed Systems

This article explains the definition, importance, and practical design guidelines for achieving idempotency in distributed systems, especially in financial and payment scenarios, by detailing key elements, principles, common pitfalls, and implementation patterns with code examples.

RPCidempotency
0 likes · 12 min read
Idempotency Design Principles and Practices in Distributed Systems
DeWu Technology
DeWu Technology
Jun 7, 2023 · Backend Development

Ensuring Data Consistency Across Microservices: Strategies and Design Principles

This article examines why data consistency between microservices is critical, defines key terminology, and presents two practical approaches—business‑side final consistency and platform‑side final consistency—detailing their core ideas, design principles, workflow diagrams, and real‑world implementation considerations such as idempotency, storage choices, latency tolerance, state‑machine design, concurrency control, and observability.

Data ConsistencyMicroservicesState Machine
0 likes · 17 min read
Ensuring Data Consistency Across Microservices: Strategies and Design Principles
IT Services Circle
IT Services Circle
May 24, 2023 · Backend Development

Ensuring API Idempotency: Concepts and the “One Lock, Two Check, Three Update” Method

The article explains the concept of idempotency for APIs, distinguishes request and business idempotency, highlights the risk of idempotent breakdown under high concurrency, and presents a practical solution using a three‑step process—lock, check, and update—often implemented with Redis distributed locks and database uniqueness constraints.

APIDistributed Lockbackend
0 likes · 5 min read
Ensuring API Idempotency: Concepts and the “One Lock, Two Check, Three Update” Method
Su San Talks Tech
Su San Talks Tech
May 23, 2023 · Backend Development

How to Prevent Duplicate Payments in E‑Commerce: Proven Strategies

This article explains the e‑commerce payment flow, identifies why duplicate payments occur—such as missing idempotency, lost orders, and multi‑channel issues—and presents practical backend solutions like distributed locking, result caching, in‑progress flow cancellation, refund handling, active polling, and push/pull synchronization.

Distributed Lockduplicate paymente-commerce
0 likes · 11 min read
How to Prevent Duplicate Payments in E‑Commerce: Proven Strategies
Architecture Digest
Architecture Digest
May 6, 2023 · Backend Development

Ensuring Idempotency in Order Services: Preventing Duplicate Orders and Solving the ABA Problem

The article explains how to achieve idempotent order creation and update in distributed systems by using database transactions, unique order identifiers, Redis locks, and version columns to prevent duplicate submissions and resolve the ABA anomaly, ensuring data consistency and reliable user experience.

ABATransactionduplicate order
0 likes · 8 min read
Ensuring Idempotency in Order Services: Preventing Duplicate Orders and Solving the ABA Problem
dbaplus Community
dbaplus Community
May 1, 2023 · Fundamentals

Master Distributed Systems: CAP, Locks, Transactions, Paxos & Raft

This comprehensive guide explains the core concepts of distributed systems—including the CAP theorem, practical implementations of distributed locks, various distributed transaction patterns, consistency algorithms such as Paxos and Raft, idempotency techniques, and rate‑limiting strategies—providing clear examples, code snippets, and visual diagrams for each topic.

CAP theoremPaxosRaft
0 likes · 27 min read
Master Distributed Systems: CAP, Locks, Transactions, Paxos & Raft
Sohu Tech Products
Sohu Tech Products
Apr 26, 2023 · Backend Development

Designing Robust and Idempotent APIs: Principles and Practices

This article explores essential API design principles—idempotency, robustness, and security—by discussing practical techniques such as request locks, database unique constraints, Redis distributed locks, token‑based authentication, JWT, and defensive coding practices to ensure reliable, safe, and maintainable backend services.

API designRobustnessbackend
0 likes · 36 min read
Designing Robust and Idempotent APIs: Principles and Practices
Baidu Geek Talk
Baidu Geek Talk
Apr 17, 2023 · Operations

Baidu DuoLiXiong Platform Stability Construction: Practices and Insights

Baidu's DuoLiXiong platform, a SaaS suite for local services, achieves stability through comprehensive technical and business specifications, microservice best practices, rigorous code reviews, automated monitoring, eventual consistency, idempotency, and future automated scaling and intelligent fault tolerance for critical operations.

Microservicescode reviewdevops
0 likes · 11 min read
Baidu DuoLiXiong Platform Stability Construction: Practices and Insights
Code Ape Tech Column
Code Ape Tech Column
Mar 30, 2023 · Backend Development

How to Ensure No Message Loss in MQ Systems – Interview Guide and Practical Solutions

This article explains the common interview question of guaranteeing 100% message reliability in MQ middleware such as Kafka or RabbitMQ, outlines the three lifecycle stages of a message, discusses detection mechanisms, id generation, idempotent consumption, and handling message backlog, providing concrete design patterns and practical examples.

Message QueueReliabilitydistributed systems
0 likes · 12 min read
How to Ensure No Message Loss in MQ Systems – Interview Guide and Practical Solutions
ITPUB
ITPUB
Mar 14, 2023 · Fundamentals

Master Distributed Systems: CAP, BASE, Locks, Transactions, Paxos & Raft

This comprehensive guide explores core distributed system concepts—including the CAP theorem and its trade‑offs, BASE consistency, various distributed lock strategies, multiple transaction patterns such as 2PC, 3PC, TCC and Seata, as well as consensus algorithms Paxos and Raft, while also covering idempotency and rate‑limiting techniques.

CAP theoremconsensus algorithmsdistributed systems
0 likes · 29 min read
Master Distributed Systems: CAP, BASE, Locks, Transactions, Paxos & Raft
Architecture & Thinking
Architecture & Thinking
Dec 28, 2022 · Backend Development

Ensuring Idempotency in Message Queues: Strategies for Reliable Messaging

This article explains the concept of idempotency, illustrates why repeated operations must yield identical results, and details how RocketMQ’s components—NameServer, Broker, Producer, and Consumer—can be designed with unique message IDs and acknowledgment mechanisms to achieve reliable, duplicate‑free messaging in backend systems.

Message QueueRocketMQbackend
0 likes · 10 min read
Ensuring Idempotency in Message Queues: Strategies for Reliable Messaging
Top Architect
Top Architect
Dec 25, 2022 · Backend Development

Why Use Message Queues? Benefits, Challenges, and Practical Solutions

This article explains why message queues are essential for decoupling services, enabling asynchronous processing, and smoothing traffic spikes, then details the new challenges they introduce—such as availability, complexity, duplicate consumption, ordering, and data consistency—and offers concrete mitigation strategies for each issue.

Data Consistencyasynchronous processingdecoupling
0 likes · 15 min read
Why Use Message Queues? Benefits, Challenges, and Practical Solutions
macrozheng
macrozheng
Dec 12, 2022 · Backend Development

Designing Secure, Reliable APIs: Signatures, Encryption, Rate Limiting & More

Learn how to design robust, secure API interfaces by implementing signatures, encryption, IP whitelists, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, request size limits, load testing, asynchronous processing, data masking, and comprehensive documentation to ensure stability and safety.

API designLoggingdocumentation
0 likes · 15 min read
Designing Secure, Reliable APIs: Signatures, Encryption, Rate Limiting & More
Su San Talks Tech
Su San Talks Tech
Dec 12, 2022 · Backend Development

Designing Secure and Robust APIs: Signatures, Encryption, Rate Limiting, and More

This article outlines essential practices for building secure, reliable API interfaces—including request signing, data encryption, IP whitelisting, rate limiting, parameter validation, unified responses, exception handling, logging, idempotency, payload limits, performance testing, asynchronous processing, data masking, and comprehensive documentation—to help developers meet safety, stability, and maintainability requirements.

API designEncryptionLogging
0 likes · 15 min read
Designing Secure and Robust APIs: Signatures, Encryption, Rate Limiting, and More
Top Architect
Top Architect
Nov 20, 2022 · Backend Development

Key Topics in Backend Architecture: Product Positioning, Microservice Design, Real‑time Messaging, Idempotency, and Service Governance

The article presents a comprehensive overview of backend architecture, covering product analysis, microservice design principles, real‑time messaging evolution, load‑balancing migration from HAProxy to Nginx, request idempotency techniques using AOP and Redis, and a detailed discussion of service governance challenges and solutions.

Backend DevelopmentMicroservicesService Governance
0 likes · 5 min read
Key Topics in Backend Architecture: Product Positioning, Microservice Design, Real‑time Messaging, Idempotency, and Service Governance
Architect's Guide
Architect's Guide
Nov 19, 2022 · Backend Development

Product Analysis, Microservice Architecture Design, Real-Time Messaging Evolution, Idempotency, and Service Governance

This article outlines product analysis and positioning, microservice architecture principles, the evolution of real‑time message push technologies, strategies for ensuring request idempotency, and comprehensive service governance practices, providing practical guidelines for building robust backend systems.

Service Governancebackend-architectureidempotency
0 likes · 6 min read
Product Analysis, Microservice Architecture Design, Real-Time Messaging Evolution, Idempotency, and Service Governance
Java High-Performance Architecture
Java High-Performance Architecture
Oct 14, 2022 · Backend Development

How to Guarantee Zero Message Loss in MQ Systems – Interview Mastery

Interviewers frequently probe candidates on ensuring 100% message reliability in MQ systems like Kafka or RabbitMQ, and this guide walks through the underlying concepts, potential loss points, detection mechanisms, idempotent design, handling backlog, and practical ID generation strategies to ace such questions.

MQ reliabilityMessage Queueidempotency
0 likes · 13 min read
How to Guarantee Zero Message Loss in MQ Systems – Interview Mastery
Top Architect
Top Architect
Sep 20, 2022 · Backend Development

Ensuring No Message Loss in MQ Systems: Interview Guide and Practical Solutions

This article explains how interviewers assess candidates on MQ reliability by discussing system decoupling, traffic control, the three stages of message flow, detection of loss, id generation, idempotent consumption, handling backlog, and scaling strategies for Kafka and similar brokers.

Backend DevelopmentInterview TipsMQ reliability
0 likes · 12 min read
Ensuring No Message Loss in MQ Systems: Interview Guide and Practical Solutions
Architect
Architect
Sep 8, 2022 · Backend Development

Ensuring No Message Loss in MQ Systems: Interview Guide and Practical Solutions

This article explains how to answer interview questions about guaranteeing 100% message delivery in MQ middleware such as Kafka, RabbitMQ, or RocketMQ, covering system decoupling, message lifecycle stages, reliability mechanisms, idempotent consumption, unique ID generation, and handling message back‑pressure.

Message QueueRabbitMQReliability
0 likes · 12 min read
Ensuring No Message Loss in MQ Systems: Interview Guide and Practical Solutions
JavaEdge
JavaEdge
Sep 3, 2022 · Backend Development

How to Ensure Idempotent Order Creation and Prevent ABA Issues in Distributed Systems

This article explains why order creation and payment APIs must be idempotent, outlines practical techniques such as unique request IDs, database unique constraints, Redis flags, and version‑based optimistic locking to avoid duplicate orders and solve the ABA problem in distributed environments.

ABA problemOptimistic Lockingdatabase transaction
0 likes · 9 min read
How to Ensure Idempotent Order Creation and Prevent ABA Issues in Distributed Systems
Top Architect
Top Architect
Jul 29, 2022 · Backend Development

Implementing API Idempotency in Spring Boot Using Tokens, Database Primary Keys, Optimistic Locks, and Redis

This article explains the concept of idempotency in computing and HTTP, why it is essential for APIs, the impact on system design, which RESTful methods are idempotent, and presents four practical implementation strategies—including database primary keys, optimistic locking, anti‑repeat tokens, and downstream sequence numbers—accompanied by complete Spring Boot code examples and testing procedures.

APIJavaRedis
0 likes · 22 min read
Implementing API Idempotency in Spring Boot Using Tokens, Database Primary Keys, Optimistic Locks, and Redis
Sanyou's Java Diary
Sanyou's Java Diary
Jul 28, 2022 · Backend Development

How to Guarantee Zero Message Loss in MQ Systems – Interview‑Ready Strategies

This article explains how interview candidates can demonstrate mastery of MQ reliability by describing the three message lifecycle stages, detection mechanisms for loss, idempotent consumption techniques, and strategies to resolve backlog, providing concrete examples and design principles for robust backend systems.

Backend DevelopmentMQ reliabilityMessage Queue
0 likes · 12 min read
How to Guarantee Zero Message Loss in MQ Systems – Interview‑Ready Strategies
IT Architects Alliance
IT Architects Alliance
Jul 27, 2022 · Backend Development

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

This article explains the concept of idempotency, why it matters for HTTP APIs, compares the idempotent characteristics of RESTful methods, and presents four practical implementation strategies—including database primary keys, optimistic locking, Redis‑based tokens, and downstream sequence numbers—along with complete Spring Boot code examples and testing guidance.

APIJavaRedis
0 likes · 24 min read
Mastering API Idempotency: Strategies, Code Samples, and Best Practices
Architecture Digest
Architecture Digest
Jul 22, 2022 · Backend Development

Understanding Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Java Implementations

This article explains the principle of interface idempotency, presents practical techniques such as version‑based updates and token mechanisms, and then delves into distributed rate‑limiting dimensions, common algorithms like token‑bucket and leaky‑bucket, and concrete implementations using Guava, Nginx, Redis and Lua with full code examples.

Backend DevelopmentLeaky BucketNGINX
0 likes · 21 min read
Understanding Interface Idempotency and Distributed Rate Limiting: Concepts, Algorithms, and Java Implementations
Dada Group Technology
Dada Group Technology
Jul 16, 2022 · Backend Development

Optimizing Rider Withdrawal Payments at Dada Express: Asynchronous Concurrency, Extended Timeouts, Idempotent Retries, and Security Enhancements

This article details how Dada Express improved the efficiency of rider withdrawal payments by redesigning the clearing and disbursement workflow, introducing asynchronous thread‑pool concurrency, extending API timeouts, implementing idempotent retry logic, and adding safeguards to ensure fund security, resulting in a three‑fold reduction in processing time during peak periods.

System Designbackendconcurrency
0 likes · 9 min read
Optimizing Rider Withdrawal Payments at Dada Express: Asynchronous Concurrency, Extended Timeouts, Idempotent Retries, and Security Enhancements
Top Architect
Top Architect
Jul 12, 2022 · 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 operations using version control and token mechanisms, and provides a comprehensive guide to distributed rate limiting—including time‑window and resource‑based dimensions, token‑bucket and leaky‑bucket algorithms, and practical implementations with Guava RateLimiter, Nginx, and Redis‑Lua scripts.

backenddistributed systemsidempotency
0 likes · 21 min read
Understanding Interface Idempotency and Distributed Rate Limiting with Token Bucket, Leaky Bucket, Guava RateLimiter, Nginx, and Redis+Lua
JD Tech
JD Tech
Jul 8, 2022 · Backend Development

Designing High‑Concurrency Inventory Systems with Redis, Database Transactions, and a Task Engine

This article presents a comprehensive solution for building an e‑commerce inventory system that prevents overselling under high concurrency by combining database transactions, Redis‑based stock deduction, idempotent anti‑repeat mechanisms, pipeline optimization, and a task‑engine driven eventual‑consistency architecture.

High concurrencyInventoryRedis
0 likes · 13 min read
Designing High‑Concurrency Inventory Systems with Redis, Database Transactions, and a Task Engine
Cognitive Technology Team
Cognitive Technology Team
Jul 3, 2022 · Backend Development

Network Timeouts Do Not Imply Server Failure: Effective Retry, Backoff, and Idempotency Strategies

Network timeouts do not necessarily indicate server‑side failure; handling them with appropriate retry strategies, exponential backoff, and idempotent APIs—combined with mechanisms such as distributed locks and atomic transactions—helps maintain system stability while avoiding duplicate operations and resource exhaustion.

Backoffbackenddistributed systems
0 likes · 7 min read
Network Timeouts Do Not Imply Server Failure: Effective Retry, Backoff, and Idempotency Strategies
TAL Education Technology
TAL Education Technology
Jun 9, 2022 · Backend Development

Understanding Idempotency: Definitions, Scenarios, and Implementation Strategies

This article explains the concept of idempotency, outlines common business scenarios such as duplicate orders and payments, describes natural and required idempotent operations, and provides practical techniques—including unique keys, database constraints, and message‑queue handling—to ensure idempotent behavior in backend systems.

Transactionbackenddistributed-systems
0 likes · 6 min read
Understanding Idempotency: Definitions, Scenarios, and Implementation Strategies
Top Architect
Top Architect
May 23, 2022 · Backend Development

Idempotent Interfaces and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations

This article explains the importance of interface idempotency and presents a comprehensive guide to distributed rate limiting, covering key dimensions, token‑bucket and leaky‑bucket algorithms, and concrete implementations using Guava RateLimiter, Nginx, and Redis‑Lua with Java code examples.

Leaky BucketToken Bucketidempotency
0 likes · 19 min read
Idempotent Interfaces and Distributed Rate Limiting: Concepts, Algorithms, and Practical Implementations
macrozheng
macrozheng
May 18, 2022 · Backend Development

36 Essential Tips for Designing Robust Backend APIs

This article presents 36 practical guidelines for backend engineers covering interface parameter validation, compatibility, extensibility, idempotency, logging, error handling, security, rate limiting, caching, transaction management, and more, helping you design reliable, maintainable, and high‑performance APIs across any language.

Loggingbackendidempotency
0 likes · 30 min read
36 Essential Tips for Designing Robust Backend APIs
Top Architect
Top Architect
Apr 29, 2022 · Backend Development

Server‑Side Request Deduplication Using Redis and Java

The article explains how to prevent duplicate user requests on the server by using unique request IDs, hashing request parameters, excluding volatile fields, and implementing an atomic Redis SETNX‑with‑expiration pattern with Java code examples and a reusable deduplication helper class.

JavaRedisbackend
0 likes · 10 min read
Server‑Side Request Deduplication Using Redis and Java
Tencent Cloud Developer
Tencent Cloud Developer
Apr 26, 2022 · Backend Development

Understanding Distributed Transactions in Microservices: Challenges and Practical Solutions

The article explains why distributed transactions in micro‑service architectures are hard—due to remote failures, timeouts, and lack of atomic guarantees—and outlines practical approaches such as unique transaction IDs, audit logs, SQL/NoSQL persistence, TCC, Saga or compensation patterns to achieve reliable consistency while balancing availability.

distributed transactionsidempotencytimeout handling
0 likes · 17 min read
Understanding Distributed Transactions in Microservices: Challenges and Practical Solutions
Top Architect
Top Architect
Apr 22, 2022 · Backend Development

Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS

This article explains the mutual‑exclusion and idempotency challenges in distributed environments, analyzes multi‑thread and multi‑process solutions, introduces the principles and implementations of distributed locks (including ReentrantLock, synchronized, Zookeeper, Redis, Tair, and the Cerberus framework), and presents GTIS as a reliable idempotency guard.

Distributed LockJavaRedis
0 likes · 32 min read
Understanding Mutual Exclusion and Idempotency in Distributed Systems: Distributed Locks, ReentrantLock, Zookeeper, Redis, and GTIS
dbaplus Community
dbaplus Community
Apr 20, 2022 · Backend Development

How to Build a Robust E‑Commerce Backend: Idempotency, Snapshots, and Sharding

This article explores common e‑commerce backend challenges such as duplicate orders, order snapshots, cart storage, inventory oversell, logistics updates, account balance consistency, read‑write splitting, hot‑cold data separation, and sharding, and provides concrete design patterns and SQL examples to solve them.

Read‑Write SplittingShardingTransaction
0 likes · 17 min read
How to Build a Robust E‑Commerce Backend: Idempotency, Snapshots, and Sharding
Programmer DD
Programmer DD
Apr 9, 2022 · Backend Development

Graceful Server‑Side Request Deduplication with Redis and Java

This article explains how to prevent harmful duplicate write requests by using unique request IDs or parameter‑based signatures, leveraging Redis for atomic SETNX with expiration, computing MD5 hashes of sorted JSON payloads, and providing a reusable Java helper class for robust backend deduplication.

JavaMD5Redis
0 likes · 11 min read
Graceful Server‑Side Request Deduplication with Redis and Java
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.

LuaNGINXbackend
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.

MicroservicesService Integrationarchitecture
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.

Error handlingState Machinesconsistency
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.

Risk Managementarchitecturecoding 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.

Leaky BucketLuaNGINX
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 designMicroservicesidempotency
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.

Service Governancebackend-architectureidempotency
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.

CachingHigh concurrencyService Governance
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.

JavaRedisSpring Boot
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.

Distributed LockJavaRedis
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.

JavaRedisSpring Boot
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.

CRUDarchitecturebackend
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.

Exactly-onceJavaMessage Deduplication
0 likes · 20 min read
Message Deduplication and Exactly‑Once Semantics in RocketMQ
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 LockGTIS
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.

SnowflakeUUIDUnique 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 MechanismRabbitMQRedis
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 MechanismRabbitMQRedis
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 SystemMicroservices
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.

Reliabilityidempotencymessage-queue
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.

MQRabbitMQSystem Design
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.

APISnowflakeUUID
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.

PythonTeardownidempotency
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 designSnowflakeUUID
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.

Message LossMessage QueueRabbitMQ
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.

Reliabilitydistributed transactionidempotency
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.

MD5backendduplicate request
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.

Order Managementbackendidempotency
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.

RedisWeChat Payidempotency
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.

Order ManagementRedisWeChat 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.

duplicate requestidempotencyrequest 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 AvailabilityMQMessage Queue
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.

Tokenidempotencyoptimistic 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.

APILockingbackend
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.

Order ManagementTransactionidempotency
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.

JavaREST APIRedis
0 likes · 21 min read
Understanding Idempotency and Its Implementation in RESTful APIs