This article explains why concurrency issues like overselling occur in e‑commerce, introduces distributed lock concepts and mainstream implementations (MySQL, Redis, Zookeeper/etcd), and provides a three‑stage quality‑assurance framework with code‑review checklists, testing methods, and data‑reconciliation techniques.
The article outlines Java thread‑pool fundamentals, explains ThreadPoolExecutor parameters and Tomcat’s custom pool behavior, and provides best‑practice guidelines for creating pools directly, configuring rejection policies, and safely using ThreadLocal—including static declarations, proper cleanup, and avoiding memory‑leak pitfalls—to build stable, high‑performance backend services.
This article introduces the SpringBoot‑Super‑Scheduled starter, explains how it dynamically manages native @Scheduled tasks without code changes, shows quick integration steps, and details the underlying implementation—including configuration management, post‑processor interception, dynamic proxy chaining, and runtime task control—complete with code examples.
This article presents a comprehensive overview of cache optimization techniques, covering benefits and costs, update policies, granularity control, penetration and avalanche mitigation, hot‑key reconstruction, and distributed batch‑operation strategies, with practical examples using Redis and MySQL.
This guide explains how to configure and read Nginx access and error logs, covering log format definitions, file locations, log level settings, and practical commands for parsing log entries to troubleshoot server and application issues.
The article details the architecture, challenges, and solutions of ByteDance's wallet asset platform that unified reward issuance, display, and usage across eight applications during the 2022 Spring Festival, covering high‑traffic order processing, token‑based asynchronous settlement, budget control, stability mechanisms, and future evolution.
This article compares traditional Java IO, JDK NIO, and the Netty framework, explaining their thread models, selector mechanisms, and performance trade‑offs, while providing complete server‑client code examples that demonstrate how Netty simplifies high‑performance network programming.
This article shares a detailed, step‑by‑step account of three interview rounds at ByteDance, covering the background, technical and algorithm questions on Java, Redis, MySQL, Kafka, and more, along with personal reflections and practical tips for future candidates.
This article provides an in‑depth tutorial on Spring Validation, covering basic usage, dependency configuration, requestBody and requestParam validation, unified exception handling, advanced techniques such as group, nested, and collection validation, custom validators, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms.
This article explains various techniques for detecting and preventing duplicate backend requests—using unique request IDs, business parameter hashing, MD5 summaries, and Redis SETNX with expiration—providing Java code examples and a complete deduplication utility.
This article walks through creating a web‑based face‑recognition demo using Baidu Cloud AI, covering both front‑end video capture with HTML/JS and back‑end Java integration for user registration and login, complete with code snippets and key implementation steps.
To pre‑warm business data before a Spring web service accepts requests, the article explains two approaches—implementing the SmartLifecycle interface with proper phase ordering and using a ContextRefreshedEvent listener—while highlighting code examples, execution timing, and cautions against asynchronous overrides.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche—common Redis caching issues—provides concise definitions, shares personal interview experience, and recommends two detailed PHP‑CN articles for further online study.
This article explores three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations, enabling developers to choose and integrate the appropriate strategy for controlling request traffic without external dependencies.
This article explains how to integrate Spring Boot with MyBatis, configure a single Druid data source, implement multi‑data‑source support using Spring's AbstractRoutingDataSource, create a dynamic data source with ThreadLocal, and wire everything together with custom annotations, aspects, and transaction management for backend Java applications.
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.
This comprehensive guide explores essential backend development concepts—from system design principles like high cohesion and low coupling, through architecture patterns such as high availability and load balancing, to network communication, fault handling, monitoring, and deployment strategies, providing clear explanations for developers.
JetBrains announced that the IntelliJ platform will discontinue Log4j and adopt java.util.logging as the standard logging framework, providing migration steps, stub implementations, and security rationale for developers to update their plugins and codebases accordingly.
This page provides an extensive curated list of Groovy tutorials covering introductions, environment setup, syntax basics, GString, keywords, traversal, regular expressions, integration with Java, Gradle, JMeter, operator overloading, closures, reflection, performance comparisons, and advanced scripting techniques for backend development.
This guide explains the core principles of resource‑oriented API design, including naming resources, using standard and custom methods, modeling hierarchical collections, and adhering to stateless protocols, while drawing on REST concepts and Google’s API design guidelines.
This article explains how to replace raw PyMySQL usage with SQLAlchemy ORM in Python, covering environment setup, database connection initialization, MVC‑style project structure, model class definitions, field attributes, session handling with context managers, and practical code examples for saving and querying data.
This article introduces a curated list of notable PHP projects—including advanced machine‑learning libraries, a neural‑network framework, a natural‑language‑processing toolkit, a distributed long‑connection service, a database migration tool, a versatile filesystem abstraction, a C++ extension framework, and PHP‑FPM—highlighting their features, use‑cases, and sample code.
This article provides a comprehensive, step‑by‑step explanation of Netty’s pipeline architecture, detailing how ChannelHandlerContext wraps handlers, how inbound and outbound events are classified and propagated, and how handlers are added, removed, and initialized within the pipeline.
This guide compiles fifty practical Java performance recommendations—ranging from judicious use of singletons and static variables to efficient collection handling, memory management, and low‑level optimizations like bit‑shifts and System.arraycopy—each illustrated with concise explanations and code snippets to help developers write faster, leaner Java code.
This article introduces LiteFlow, a lightweight, fast, and stable component‑based rule engine, explains its design principles, shows step‑by‑step usage in both non‑Spring and Spring Boot environments, and dives into the core source code that drives parsing, chain execution, and node processing.
On May 14 the open‑source Fastjson library launched version 2.0.3, adding better compatibility with its 1.x line, native support for JDK 14 records, GraalVM native‑image compatibility, an improved extension mechanism, stronger JSONPath capabilities, Jackson annotation compatibility, and faster deserialization for heavily escaped JSON data.
This tutorial explains proxy fundamentals, compares forward and reverse proxies, details HTTP and HTTPS proxy header differences, and provides a complete, runnable Go implementation that listens on port 8080 and transparently forwards client requests to target servers.
This article examines a real‑world file‑watching failure caused by a JDK bug, explains how Java's WatchService works (including its polling fallback), compares it with Linux's inotify mechanism, and presents practical work‑arounds for reliable configuration reloads in backend services.
This article explores the architecture and implementation of a high‑concurrency train ticket flash‑sale system, detailing load‑balancing strategies, Nginx weighted round‑robin, Redis‑based inventory management, and Go code examples that demonstrate local and remote stock deduction, performance testing, and fault‑tolerant design.
This article explains Go's built-in error interface, distinguishes errors from exceptions, compares three common error-handling patterns, discusses wrapping errors with packages like pkg/errors, and demonstrates centralized error handling using errgroup, including usage examples and best-practice recommendations for backend Go development.
This guide explains how to set up separate configuration files for development, testing, and production in Spring Boot, modify them for each environment, and switch between environments using configuration properties, IDE settings, or command‑line arguments.
This article explains how the Python subprocess module is employed in a data construction platform, compares run and Popen methods, discusses challenges such as incomplete log capture and process termination, and presents three practical solutions to ensure reliable execution and logging.
This article explains how Spring's BeanFactory creates and caches beans, details the three‑level cache mechanism (singleton, early‑singleton, and singleton‑factory) used to resolve circular dependencies, and walks through the relevant source code and lifecycle methods.
This article outlines thirteen practical Redis performance‑optimization rules, covering command complexity, key expiration, data‑structure selection, persistence settings, hardware choices, clustering, and memory‑fragmentation monitoring to help developers maximize throughput and reduce latency in production environments.
This article explains Elasticsearch pagination mechanisms—including from/size, deep paging drawbacks, scroll, scroll‑scan, sliced scroll, search_after and point‑in‑time—detailing their inner workings, performance trade‑offs, configuration limits, and practical recommendations for handling large result sets.
This article explains why traditional select/poll struggle with massive connections, how epoll's event-driven design using a red‑black tree and ready‑list dramatically improves scalability, details its two trigger modes, and provides a complete C demo illustrating a high‑performance reactor model.
Microsoft's development team released a two‑year, user‑driven overhaul of the VS Code PowerShell extension, redesigning the PowerShell Editor Services engine, introducing a new thread model, adding 6,000 lines of code, removing 12,000, and improving stability, performance, and developer feedback mechanisms.
This article introduces the Go programming language, showcases several high‑traffic production projects built with Go at Autohome, and explains the major Go 1.18 enhancements such as generics, workspaces, and fuzzing, while providing performance comparisons, code samples, and practical optimization tips.
This article analyzes the challenges of aggregating multiple RPC calls in e‑commerce app backends, explains simple and complex concurrency scenarios, introduces grouped concurrency scheduling, and presents a self‑driven concurrency model that automates dependency handling to improve response latency and maintainability.
This article explains the fundamentals of JSON, its syntax rules, and demonstrates how PHP's json_encode and json_decode functions convert between arrays and JSON strings, including examples of sequential, non‑sequential, and multidimensional arrays, and the effect of the associative‑array option.
This guide explains how Nacos 2.1.0 introduces built‑in configuration encryption, how to add encryption plugins on the server, and how to mark configuration entries with a special prefix so that they are automatically stored and transmitted as ciphertext.
Learn how to install Node.js, set up the open‑source NginxConfig visual tool, generate Nginx configuration files for static and dynamic proxies, and deploy them on a Linux server, all with step‑by‑step commands, code snippets, and practical examples.
This article explains the core concepts of low‑code platforms, why visual editing requires declarative programming, compares declarative and imperative approaches, and details practical front‑end (using JSON‑to‑React via the open‑source AMIS framework) and back‑end storage and logic implementations with code examples.
The article explains the AKF principle for microservice design, detailing how X‑axis horizontal replication, Y‑axis functional splitting, and Z‑axis data‑centric partitioning address single‑point failures, capacity limits, and performance bottlenecks by employing master‑master, master‑slave, and master‑backup replication patterns.
This article walks through setting up the Go environment, defining protobuf files, generating code, and implementing both server and client sides of a gRPC service, complete with runnable examples, common pitfalls, and output verification to help developers quickly adopt Go‑based gRPC testing.
This article provides a comprehensive guide to Go's net/url package, covering import methods, key functions like PathEscape, PathUnescape, QueryEscape, QueryUnescape, as well as the URL type fields and methods such as Parse, ResolveReference, and utilities for query manipulation, all illustrated with practical code examples.
This article explains Java's Service Provider Interface (SPI) mechanism, its purpose, advantages, limitations, differences from APIs, and provides detailed code examples and real-world use cases such as JDBC, ShardingSphere, Spring, and SLF4J to illustrate how SPI enables pluggable, decoupled backend development.
This article explains the core concepts of low‑code platforms, emphasizing visual editing as a mandatory feature, comparing declarative and imperative approaches, and detailing various front‑end (JSON‑to‑React via amis) and back‑end storage and logic implementations along with future trends.
This article explains the core principles of low‑code platforms, showing how visual (declarative) editing distinguishes low‑code from traditional code, and reviews various frontend and backend implementation schemes—including JSON‑to‑React rendering, storage strategies, JavaScript logic, and workflow engines—while highlighting their advantages and limitations.
This article shares a real‑world case study of a company operating fifteen web applications, describing how a hidden DB‑connection leak in a pod liveness probe caused severe latency, how the issue was diagnosed and fixed, and the four key take‑aways for reliable performance engineering.
This article provides a comprehensive guide for startup founders on selecting languages, components, processes, and tools to design and implement a complete backend technology stack, covering everything from project management and DNS to databases, monitoring, and deployment.
This article narrates the step‑by‑step design of a workflow engine, starting with a linear approval chain and progressively adding parallel, conditional, nested, proxy, timing, and scripting capabilities, illustrating how each new requirement reshapes the underlying tree‑structured state machine.
This comprehensive guide explains how Python can interface with C dynamic libraries using ctypes, covering installation, data types, pointer manipulation, buffer creation, DLL loading methods, Windows API calls, and advanced techniques such as structures, unions, arrays, and process control.
The article explains why high‑traffic systems store data in databases but use fast caches like Redis, outlines the inherent consistency problems between cache and database, evaluates four update‑delete strategies with concurrency scenarios, and recommends practical solutions such as post‑update cache eviction, delayed double deletion, expiration policies, message queues, and binlog listeners to achieve eventual consistency.
This article explains why caching is essential for high‑read workloads, describes the consistency challenges when data resides in both MySQL and Redis, compares four cache‑update strategies, and offers practical recommendations such as using expiration, delayed double‑delete, message queues, and binlog subscription to achieve eventual consistency.
This article presents five practical performance‑optimization principles—pooling, sequential I/O, batching, reduction, and concurrency—explaining their rationale, real‑world examples such as object pools, ordered reads, batch APIs in MySQL/Redis/Kafka, sharding strategies, read/write separation, and common concurrency anomalies, while highlighting trade‑offs and implementation tips.
After deploying a project, a 500 Server Error appears the next day due to MySQL closing idle connections after the default 8‑hour wait_timeout, and the article explains how to verify the issue, adjust wait_timeout, use autoReconnect, and properly configure the HikariCP connection pool to prevent the failure.
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.
This article explains common inventory deduction scenarios, compares three solutions—single‑record MySQL, multi‑record MySQL, and Redis with Lua scripting—analyzes their drawbacks, and provides a complete Java implementation including a StockService, Redis lock, and controller for managing stock safely under high concurrency.
This article explains the technical distinctions between HTTP GET and POST requests, covering how parameters are transmitted, practical limitations imposed by browsers and servers, differences in caching, security, and packet flow, and why both methods ultimately rely on the same TCP/IP transport.
The 2022 Java ecosystem report reveals Java 11 surpassing Java 8 as the dominant runtime, highlights the modest adoption of non‑LTS releases like Java 14, shows Oracle’s market share shrinking while Amazon rises, and examines how container‑based deployments affect CPU, memory, and garbage‑collector choices.
This article explains how NetEase Cloud Communication leverages the QUIC protocol—detailing its transport‑layer advantages over TCP, protocol‑level differences, and specific optimization practices such as multiplexing, unreliable DATAGRAM frames, compression, and dynamic redundancy—to dramatically improve audio‑video signaling latency, loss tolerance, and bandwidth utilization in challenging network conditions.
This article explains how to design Redis cache for relational list data such as user timelines or news feeds, covering fixed-length caching, consistency, resource utilization, using ZSET structures, handling additions, deletions, queries, and strategies like preloading, retry mechanisms, and asynchronous rebuilding.
This article examines performance bottlenecks in a high‑traffic e‑commerce product service and proposes data‑centric optimizations—including read‑only focus, field‑level selection via bit‑masking, and Redis hash storage—to reduce payload size, lower GC pressure, and improve latency while maintaining scalability.
This article details the five‑year evolution of a commercial advertising platform, the performance and architectural challenges it faced, the step‑by‑step Go‑based microservice reconstruction, and the resulting tenfold improvements in capacity, latency, and cost efficiency.
Baidu’s ToB Account Permission Platform provides a unified, configurable login and permission service—including multi‑tenant account management, SSO, OAuth, and the GD‑RBAC model—delivering secure, high‑performance access for over ten million enterprise accounts across multiple product lines.
This article explains how to use Python to convert hundreds of long URLs into short ones and later restore them, covering the rationale for short links, free and paid service options, and providing complete code examples for both shortening and expanding URLs.
This article explains the fundamental concepts, design requirements, and modeling approaches for payment account systems in e‑commerce, covering the distinction between payment and login accounts, transaction needs, accounting structures, entity and account models, and the detailed transaction model.
In a shared Elasticsearch cluster, the team used slow‑log analysis to pinpoint costly queries caused by unnecessary fuzzy matches and integer‑mapped low‑cardinality fields, then optimized them by converting matches to filters and remapping those fields to keyword, re‑indexing, which cut latency from over 100 ms to under 10 ms and eliminated slow‑query alerts.
Yearning is a lightweight, self‑contained MySQL SQL audit platform that offers query auditing, SQL review, permission management, and automated rollback, with simple installation steps and no reliance on third‑party tools, making it ideal for small and medium enterprises.
This article lists and explains twenty indispensable third‑party Java libraries—from logging and JSON parsing to HTTP clients, PDF generation, and embedded databases—helping developers boost productivity, avoid reinventing the wheel, and write more robust code.
This article examines various approaches to implementing delayed (scheduled) messages in distributed message queue systems, comparing external storage, RocksDB, Redis, and open‑source MQ solutions, and discusses their advantages, drawbacks, and practical considerations.
This article details the architecture, challenges, and solutions behind a high‑traffic Spring Festival shake‑and‑red‑packet system, covering prototype design, bandwidth and request‑rate handling, access clusters, overload protection, and iterative versions that achieved up to 110 billion shakes with peak loads of 14 million requests per second.
The article recounts a real‑world incident where a Java message‑queue system stalled for over ten minutes because an HTTP client call lacked a timeout, walks through the step‑by‑step debugging process, shows the problematic code, and provides proper timeout configurations for different HttpClient versions to prevent such blocks.
This guide explains how to launch a Java server in blocking debug mode using specific JVM options and then attach a remote debugger from an IDE, illustrated with command examples and screenshots of the connection setup.
This article outlines the step‑by‑step evolution of a high‑traffic e‑commerce backend—from a single‑machine setup to cloud‑native microservices—illustrating the technologies and design principles needed to scale from hundreds to tens of millions of concurrent users.
The JD Retail Technical Salon held on April 8, 2022 brought together internal and external experts to share experiences on open‑source projects, cloud‑native messaging, frontend and backend frameworks, and compliance, fostering sustainable open‑source ecosystems and encouraging community participation across JD’s engineering teams.
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.
This article examines the challenges faced by a transaction middleware platform, introduces a finite‑state‑machine (FSM) solution for order state flows, and compares traditional serial processing with future‑based staged concurrency and event‑driven concurrency models, highlighting their benefits and trade‑offs.
This article explains the concept of distributed locks, compares three common implementation schemes—database unique indexes, Redis SETNX, and Zookeeper temporary sequential nodes—and provides complete Java code examples for each, along with analysis of re‑entrancy, lock release timing, and single‑point failures.
This guide outlines comprehensive backend API design recommendations, covering appropriate HTTP status codes, JSON request bodies, unique resource identifiers, timestamp formats, consistent URL structures, nested relationships, error message schemas, caching, pagination, versioning, security, and clear documentation with executable examples.
This article presents a Python solution that parses Tencent video URLs, retrieves encrypted TS video segments through a third‑party VIP service, downloads them concurrently, and merges the segments into a playable MP4 file, detailing the required environment, workflow, and complete source code.
This article analyzes the performance bottlenecks of Baidu mini‑program package installation, proposes a streaming download approach that parallelizes network I/O with signature verification and decompression, and provides detailed Java implementation using a MultiPipe pipeline to achieve a 21% reduction in download time.
This article explains how to globally handle LocalDate, LocalDateTime, and LocalTime parameters in Spring Boot 2.x by creating custom Converter beans, configuring Jackson's ObjectMapper, using @DateTimeFormat, ControllerAdvice, and understanding the underlying parameter resolution mechanisms to avoid common pitfalls such as lambda‑based converter registration failures.
This article explains how Spring's three‑level cache (singleton, early‑singleton, and singleton‑factory caches) works together with bean post‑processors to break circular dependencies and correctly create AOP proxies, while also showing how to disable circular references when needed.
This tutorial walks a JavaScript‑savvy developer through creating a Rust‑based Apollo Federation GraphQL API, covering project setup with Cargo, required dependencies, async main function, schema and type definitions, federation extensions, and how to run the user and dog sub‑services on separate ports.
This article narrates the step‑by‑step evolution of a custom workflow engine, detailing how simple sequential approvers were transformed into a tree‑structured system supporting parallel, multi‑sign, conditional, delegation, and nested nodes, complete with status management and progress metrics.
This tutorial presents a complete Python + Django e‑commerce mini‑project, outlining its main features, required environment, step‑by‑step installation commands, configuration changes, database setup, and how to run the application locally for self‑learners.
The article explains why Java applications often experience high latency during the first few requests after startup, describes the role of the JVM interpreter and JIT compilation in creating hotspot code, and offers practical solutions such as JIT warm‑up techniques and traffic pre‑warming to improve performance.
This article introduces FastMyBatis, a zero‑configuration MyBatis extension that simplifies CRUD operations in Spring Boot projects, provides code examples for quick start, outlines service and mapper implementations, lists available mapper methods, and shows how to build query objects for flexible data access.
This article chronicles how 于雨 transformed Dubbogo—from a one‑person Go implementation of the Dubbo RPC framework into a large, cloud‑native open‑source community—detailing technical challenges, community building, personal sacrifices, and future goals for sustainable growth.
This article provides a comprehensive guide on selecting and structuring a backend technology stack for startups, covering language choices, core components, processes, system integration, and practical recommendations for cloud services, databases, RPC frameworks, monitoring, and deployment pipelines.
This article explains three request‑collapsing approaches—Hystrix Collapser, a custom BatchCollapser, and Guava's ConcurrentHashMultiset—detailing their design, configuration, Java implementations, and suitable scenarios for reducing downstream load and improving system throughput.
This article describes how a company replaced manual host‑file based test environment access with DNS wildcard domain resolution, detailing the evolution from fixed to dynamic environments, the configuration steps on the Zhuanzhuan DNS platform, and the resulting improvements in operational efficiency and deployment simplicity.
The article analyzes Alibaba's business middle platform strategy, exposing its inefficiencies caused by deep coupling, high collaboration, cognitive, and stability costs, and proposes practical solutions such as thinning business capabilities, strengthening platform services, decoupling via service-oriented architecture, and adopting Platform-as-Code with componentization.
This article describes the end‑to‑end design, architecture, code implementation, and deployment steps for an internal intelligent QA chatbot named “Jarvis”, covering its V1.0 browser‑based prototype, V2.0 AI‑enhanced version, DingTalk integration, automation features, and future roadmap.
This article introduces Spring Retry's @Retryable annotation, explains its purpose, shows how to add the Maven dependency, enable retry support, annotate methods with retry settings, handle failures with @Recover, and outlines important considerations for reliable retry mechanisms in Java backend development.
To keep community feeds smooth despite network or backend failures, the system employs multiple fallback mechanisms—including Redis‑cached recommendation pools, CDN‑mirrored response files, asynchronous content caching, specialized follow‑feed and outfit‑selection caches, detail‑page preloading, and fine‑grained monitoring with alerts—ensuring continuous scrolling and a better user experience.
This article explains Nginx's multi‑process design, detailing how the master process handles socket binding and listening while each worker creates its own epoll instance, registers events, and processes connections through a well‑structured event loop with code examples from the source tree.
This article explains Java's CompletableFuture—its purpose, key features like thenCompose, thenCombine, thenAccept, thenRun, thenApply, and provides a detailed walkthrough of its internal implementation, including code examples and the mechanics of task dependency handling.
