The article explains how Facebook built a stable, abstracted integration‑testing infrastructure for backend services, combining automated testing, fuzzing, record‑and‑playback, and isolation techniques to enable rapid prototyping while avoiding side effects and improving bug detection.
This article introduces the open‑source mall‑tiny rapid‑development scaffold, explains its core features and integration with the mall‑admin‑web front‑end, and provides a step‑by‑step guide to upgrading it to Spring Boot 2.7.0, covering Swagger, Spring Security, MyBatis‑Plus, circular‑dependency resolution, and CORS configuration.
This article explains how to design and implement a flexible, strategy‑pattern‑based state machine for e‑commerce after‑sale services, covering action abstraction, synchronous vs asynchronous execution, compensation via delayed MQ, and execution delay techniques to improve reliability and performance.
Facing billions of cached hotel records, Ctrip’s backend team analyzed Java object layout and HashMap memory costs, evaluated alternative structures, and applied bitmap, dictionary, run‑length and delta encodings to compress data, ultimately reducing cache size to under 2% of its original footprint.
The article explains how to address single‑point failures and capacity limits by clustering servers using replication patterns and introduces the AKF microservice splitting principle, detailing X‑axis horizontal replication, Y‑axis business‑oriented division, and Z‑axis data‑driven partitioning with diagrams.
This article explains three Redis‑based rate‑limiting methods—using SETNX for simple counters, leveraging ZSET for a sliding‑window algorithm, and implementing a token‑bucket scheme with LISTs—complete with Java code examples and discussion of their advantages and drawbacks.
This article explains how to shift authentication and authorization from the gateway to downstream Spring Cloud microservices by removing the gateway's ReactiveAuthorizationManager, defining three custom annotations (@RequiresLogin, @RequiresPermissions, @RequiresRoles), creating an AOP aspect to enforce them, and demonstrating their usage in controller methods.
This article walks through the background of a production Java service that received many performance complaints, enumerates common causes such as slow MySQL queries, complex business logic, thread‑pool misconfiguration, lock contention and machine issues, and provides concrete diagnostic steps and code‑level solutions including pagination fixes, indexing strategies, async processing, thread‑pool tuning, lock refinement and caching techniques.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic development, key characteristics, comparison with SOA, practical implementation steps, common design patterns, advantages and disadvantages, and essential considerations for successful adoption.
To handle dynamic file changes such as rule updates, configuration reloads, or log monitoring, this article compares three Java approaches—simple polling with File#lastModified, the OS‑integrated WatchService API, and the Apache Commons‑IO monitor—detailing their implementations, advantages, drawbacks, and practical usage tips.
The article compares delayed and scheduled tasks and presents five backend solutions—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, and RabbitMQ delayed queues—detailing their implementations, code examples, outputs, and pros and cons.
Spring Boot 2.7.0 introduces major enhancements such as a new @AutoConfiguration annotation, upgraded Flyway modules, H2 2.1 support, GraphQL starter, Podman integration, Cache2k auto‑configuration, and several deprecations and test annotation improvements, providing a comprehensive update for Java backend developers.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, disadvantages, and practical considerations for building scalable, reliable systems.
This article explains what rate limiting is, why it is needed, various strategies and algorithms such as leaky bucket, token bucket, fixed and sliding windows, and discusses challenges like inconsistency and race conditions in distributed systems, as well as different throttling types.
This article explains how to unify error handling between gRPC and traditional HTTP services by defining shared protobuf messages, mapping gRPC status codes to HTTP responses, and customizing response structures with additional fields like stat and msg for consistent business‑level error reporting.
This article examines how PHP stores variables internally by analyzing the zval structure defined in the C source code, detailing its fields, type flags, memory layout, and associated macros, and explains why each variable occupies 16 bytes at runtime.
This article walks through a simple Java file‑change watcher, reveals a JDK 8/9 bug where lastModified returns seconds instead of milliseconds, demonstrates the issue with test code, and presents a version‑file workaround to reliably detect updates.
The article introduces eight widely used software architecture design patterns—including single‑database, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their typical structures, suitable scenarios, and the key pros and cons of each.
After upgrading to Spring Boot 2.6, a NullPointerException occurs when integrating Swagger due to the new PathPatternParser, and the issue can be resolved by changing the path‑matching strategy to ant_path_matcher or adding a custom WebMvcEndpointHandlerMapping bean.
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.
