This article explains how to replace thread‑heavy WebSocket or Socket.IO clients with a Netty‑based Java WebSocket client, covering Maven dependencies, connection setup, event‑loop management, message sending, and a custom channel handler for high‑concurrency scenarios.
This tutorial demonstrates how to use PHP to create a backup directory, export MySQL tables to text files, and restore them by reading the files and executing INSERT statements, providing complete code examples for both backup and recovery processes.
This article introduces Alibaba's JetCache Java caching framework, explains how to combine local and Redis remote caches for multi‑level caching, provides Maven dependencies, configuration examples, three usage patterns (AOP, API, advanced API), testing steps, and common troubleshooting tips for Spring Boot projects.
This article explains why asynchronous methods improve response speed in SpringBoot, demonstrates how to enable @Async, implement service and controller code, configure custom thread pools, handle exceptions, and retrieve results, showing measurable performance gains through non‑blocking execution.
Spring Boot 3.1.3, now on Maven Central, brings 82 bug fixes, extensive documentation updates, and a comprehensive set of dependency upgrades, while the PIG platform adds compatibility with this version, offering developers a ready‑to‑use micro‑service starter kit.
This guide explains how to use @ControllerAdvice and @RestControllerAdvice for unified exception handling in Spring, compares their behavior, demonstrates local versus global handling, and shows advanced filtering by annotation, controller class, or package with practical code examples.
This article details the evolution and design of Vivo’s e‑commerce inventory platform, covering its layered architecture, multiple inventory types, deduction workflows, idempotent APIs, anti‑oversell mechanisms, high‑concurrency strategies, hotspot mitigation, and synchronization techniques, while explaining the reasoning behind each technical choice.
This article explains how Java's foreach loop iterates over arrays and collections, demonstrates why removing or reassigning elements within a foreach causes ConcurrentModificationException or has no effect, and shows the correct ways to delete or modify elements using traditional for loops or iterator methods, complete with code examples.
This article explains how to create Redis‑based distributed locks, discusses common pitfalls such as deadlocks and accidental deletions, and provides practical solutions including atomic expiration commands, Lua scripts, and a complete Redisson Java example for acquiring and releasing locks safely.
This article analyzes several bugs discovered in a Go goroutine pool implementation—incorrect active count, mismatched execution counters, slow scaling during QPS spikes, and inefficient recycling—and presents detailed code fixes and redesigns to achieve accurate metrics and faster, more graceful worker management.
This article explains the concept, practical applications, version evolution, and deployment strategy of a virtual phone number service, detailing XB and AXB binding modes, asynchronous retry mechanisms, concurrency handling, and monitoring to ensure reliable integration with third‑party PSTN providers.
This tutorial explains how to create a basic online quiz platform by designing a MySQL database, writing PHP code to connect, retrieve, display questions, and process user answers to calculate scores, providing a foundation for further feature expansion.
The article explains a real‑world issue where the first invocation of a MD5 hash in a Java backend took dozens of seconds, describes how the problem was traced using the Arthas diagnostic tool, reveals that the delay stemmed from BouncyCastle algorithm loading, and shows how replacing the library resolved the performance bottleneck.
This article introduces Spring WebFlux as a reactive, non‑blocking web framework built on Reactor, explains the concepts of reactive programming, compares it with traditional Spring MVC, and provides practical code examples for building and running a WebFlux application with Spring Boot.
This guide summarizes JD.com’s extensive JDK8 garbage‑collector optimization experience, covering version requirements, how to select the right GC, core and collector‑specific parameter settings, logging configuration, and concrete methods to assess GC health for latency‑sensitive and throughput‑oriented workloads.
This article provides a systematic overview of Domain-Driven Design, explaining its origins, core concepts, modeling principles, strategic and tactical design steps, service decomposition patterns, and practical recommendations for applying DDD in complex backend systems.
This article details how a legacy Dubbo service built on Spring 3.2.x with many integrated components suffered a ten‑minute startup, and how using JProfile to pinpoint costly reflection checks, disabling unnecessary Spring annotations, and fixing RabbitMQ connection issues reduced the deployment time to under two minutes.
The article examines the concept of a "distributed monolith," explains why superficial microservice migrations often degrade stability and productivity, and outlines the root causes and best‑practice strategies to avoid these common architectural mistakes.
This article presents 34 practical Java performance optimization guidelines—ranging from proper use of singletons and static variables to avoiding excessive object creation, leveraging final modifiers, preferring primitives, minimizing synchronization, and employing efficient collections—to help developers write faster, more memory‑efficient code.
This guide walks you through setting up Spring Boot Admin, covering server and client configuration, essential monitoring features, security setup, custom notification code, and integration with microservices and Nacos for comprehensive application health management.
Spring Framework 6.1 Milestone 4 brings a host of backend enhancements such as the new JdbcClient, JMS observability, @HttpExchange support, CompletableFuture caching, refined bean configuration, expanded test property sources, and full compatibility with Virtual Threads and JDK 21, while previewing the upcoming Spring Boot 3.2 milestone.
This article documents a month‑long JVM garbage‑collection tuning effort that lowered FullGC from around 40 daily occurrences to one every ten days, halved YoungGC time, identified and fixed a memory‑leak caused by anonymous inner‑class listeners, and refined heap and metaspace settings to improve overall server throughput.
This article introduces Hutool, a Java utility library that consolidates common enterprise‑level tools such as file handling, encryption, date manipulation, and data conversion, explains its main modules, shows how to add it via Maven, and provides practical code examples for quick integration.
This article explains the basic concepts of GET and POST, debunks common interview answers, reveals that both methods are fundamentally TCP connections, discusses browser and server limits, and highlights the practical impact of their packet‑level differences.
This article explains how to leverage Redis data structures such as Set, Sorted Set, Bitmap, and HyperLogLog to perform aggregation, sorted, binary‑state, and cardinality statistics efficiently in large‑scale applications, while addressing performance considerations and practical implementation details.
This article details Bilibili's transition from a purchased customer‑service platform to a self‑developed system, describing the background, architectural design, core modules such as intelligent QA, seat scheduling, workbench, permission management, the use of Faiss for vector search, and future explorations with large language models, highlighting the technical challenges and solutions across backend development and AI integration.
This tutorial walks through building a face‑registration and face‑login system using Baidu Cloud AI, covering requirement analysis, front‑end video capture, base64 image handling, back‑end Java Spring endpoints, and integration of the Baidu AipFace SDK to achieve secure biometric authentication.
This article explains the three main configuration parameters—fastcgi_read_timeout, max_execution_time, and request_terminate_timeout—that affect PIE service interface timeout, demonstrates how each influences HTTP response codes and PHP execution, and provides step‑by‑step debugging and fixes for Nginx, PHP, and PHP‑FPM settings.
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.
The article examines how Spring Boot handles circular reference serialization with Jackson and Fastjson, demonstrates the role of @ControllerAdvice for global exception capture, explains why Jackson may emit both 200 and 500 responses, and provides practical solutions using annotations and configuration.
This article explains the roles of Alipay's asynchronous and synchronous callbacks in PHP integration, outlines step‑by‑step processing procedures, and provides complete example code for verifying signatures, updating order status, and handling both server‑side notifications and front‑end return pages.
This article walks through building a mind‑map application by combining PHP backend and Vue frontend, covering environment setup with XAMPP/WAMP and Vue CLI, data exchange via PDO and axios, component‑based development, and lessons learned from the project.
This article shares a Tencent backend engineer's extensive experience with code review, outlining why engineers and leaders should practice it, identifying common pitfalls such as duplicated code and premature optimization, and presenting concrete principles, model design advice, and Go code examples to improve software quality.
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.
This article explains why JVM memory tuning is essential for high‑pay roles, outlines six practical steps—including GC monitoring, heap dump generation, analysis, and parameter adjustments—and provides detailed guidance on heap size, generation ratios, GC types, and thread stack settings to reduce Full GC frequency and improve application performance.
This article explains how to securely encrypt and decrypt user‑submitted form data in PHP using the AES‑256‑CBC algorithm, providing step‑by‑step code examples for creating encryption/decryption functions, applying them to form inputs, and emphasizing key safety and HTTPS.
This article explains how to redesign Spring MVC controllers by introducing a unified response structure, leveraging ResponseBodyAdvice for automatic wrapping, handling String conversion issues, applying JSR‑303 validation, creating custom validators, and centralizing exception handling to produce cleaner, more maintainable backend code.
Bilibili’s railgun platform transforms its high‑traffic like service into a scalable, fault‑tolerant system by moving writes to an asynchronous, Kafka‑driven pipeline, applying CQRS, partitioned processing, idempotency, hot‑key isolation, rate‑limiting, and unified SDKs, dramatically reducing database load and achieving ten‑fold throughput gains.
The article explains that Redis achieves exceptional performance through four main factors—its in‑memory storage, optimized data structures, a single‑threaded architecture, and non‑blocking I/O—detailing how each contributes to speed and efficiency.
This article explains the differences and proper usage of Java validation annotations such as @NotNull, @NotBlank, @NotEmpty, and compares @Valid with @Validated in Spring Boot applications, providing code examples and import details for effective data validation.
The article compares JPA and MyBatis in Chinese software projects, argues that JPA excels when solid OOP design and domain modeling are prioritized while MyBatis shines in data‑driven or fast‑delivery scenarios, and illustrates the discussion with Java code examples and design‑pattern reminders.
Didi upgraded its self‑developed Elasticsearch from JDK 11/G1 to JDK 17, adopting ZGC for latency‑critical clusters and tuned G1 for throughput, which eliminated long GC pauses, reduced query latency by up to 96%, cut CPU usage, and dramatically improved stability across multiple production clusters.
This article introduces a MyBatis‑based SQL analysis component that detects and prevents slow queries before they impact production by performing real‑time EXPLAIN analysis, offering optimization suggestions, and enabling dynamic SQL replacement, while detailing its design, configuration, performance testing, and practical advantages.
Learn how Python's metaprogramming lets you dynamically create, modify, and control classes and functions at runtime, covering metaclasses for singleton patterns and class registration, decorators for caching, timing, and logging, and property accessors for validation and computed attributes, each illustrated with concrete code examples.
This article describes the design, high‑availability solutions, traffic isolation, deep performance optimizations, caching strategies, dual‑center MySQL partitioning, seamless migration, and future fine‑grained flow‑control and degradation techniques employed to keep a billion‑user membership system stable and performant under extreme load.
This article examines the design of a flexible multi‑account authentication system, covering native phone‑code login, optimized password‑optional flows, third‑party OAuth integration, database schema separation, and one‑click carrier‑based login to improve extensibility and user experience.
This article walks through the problem of scattered try‑catch blocks in Java back‑ends, explains the use of Spring's @ControllerAdvice together with a custom Assert‑based validation and error‑code enum, and demonstrates a complete unified exception handling solution with production‑ready response formatting and extensive code examples.
Learn how to set up a Spring Boot 3.0.9 environment, define entities, repositories, services, and a GraphQL schema, then expose a GraphQL endpoint with sample queries, illustrating complete backend API development using GraphQL and JPA.
This article explains three typical pitfalls of Go slices—ignoring the slice returned by append, unintentionally sharing the underlying array which can cause memory leaks, and the value‑copy behavior of for‑range loops—while also showing how to inspect slice internals using unsafe pointers.
This article explains how Dubbo3’s new observability starter provides visual cluster metrics, full‑link tracing, multi‑dimensional monitoring, Prometheus/Grafana integration, and log management, offering practical steps and configurations for building a robust cloud‑native microservice observability platform.
The article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling mechanism that leverages @ControllerAdvice, custom BaseException, Assert utilities, and enum‑based error codes to produce consistent, environment‑aware error responses.
This article introduces the fundamentals of state machines, explains the four core concepts, explores domain‑specific languages (DSL) and their classifications, and provides practical Java examples using Spring Statemachine and the COLA framework, ending with a comparison and adoption guidance.
This article presents the design, implementation, and operational experience of AREX, a Java‑agent based record‑and‑replay testing platform that captures real production traffic and data to enable fast, cost‑effective automated regression testing for complex backend services.
This guide explains why Elasticsearch X-Pack reports a license‑expired error and provides step‑by‑step instructions to obtain a new license, place it as license.json, and apply it with a curl command to restore authentication functionality.
This article explains how to use a timing wheel to efficiently handle RPC timeout processing, startup timeouts, and heartbeat tasks, reducing thread proliferation and CPU waste by organizing timed tasks into hierarchical time slots.
This article explains how to achieve API idempotency in high‑concurrency scenarios by creating a custom @RepeatSubmit annotation, using AOP interception, Redis setNx for locking, and a request‑wrapper to allow repeated reading of request parameters in Spring applications.
This tutorial explains how to design and implement refund and after‑sale service management features in a PHP‑based e‑commerce system, covering database schema creation, request handling, and record display with complete code examples.
This article provides a step‑by‑step guide on integrating Spring Batch with Spring Boot, covering configuration, job and step setup, ItemReader/Processor/Writer implementations, database interactions, handling CSV and database sources, and troubleshooting common issues such as connection‑pool compatibility.
This article explains how PHP's http_build_query() function converts associative arrays or objects into properly encoded URL query strings, covering basic usage, handling of multidimensional arrays, objects, and special characters with clear code examples.
This tutorial explains how to design request/response structures, configure routing, implement controllers, perform parameter validation, and handle exceptions when building robust API endpoints using the ThinkPHP6 framework, complete with practical code examples.
This article provides a detailed collection of architecture diagrams covering Java classloader, JVM, Java technology stack, threading, compilation, JMS, JMX, Spring, Hibernate, iBATIS, Struts, EJB, portal, J2EE, SmartClient Ajax, Oracle, MySQL, Android, cloud computing, Linux kernel, VMware, SAP, portal blueprint, SOA, MIS, APUSIC ESB, GIS ESB, CRM, and OA, offering valuable insights for backend developers and architects.
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.
The article explains cache penetration, describes how to prevent it using a Redis‑based mutex lock and a logical expiration strategy, provides complete Java code examples for both approaches, compares their trade‑offs, and shows performance testing results under high concurrency.
This article explains how Gaode's Information Business team tackled fragmented portal implementations across multiple industries by adopting the Gaode Business Framework (GBF) and domain‑driven design, achieving unified architecture, reduced duplication, improved reusability, and enhanced system stability and maintainability.
This article explains the limitations of Java Future, introduces CompletableFuture's asynchronous and compositional capabilities, and demonstrates how to refactor a store detail page service using CompletableFuture, custom thread pools, and design patterns to achieve parallel execution, reduced latency, and better code maintainability.
This article reviews the performance challenges of the logistics pricing engine, explains the limitations of the previous 1.0 optimizations, and details the design and implementation of a new 2.0 cache strategy using Tair and local caches, key‑value modeling, pre‑heating, updates, and bottleneck mitigation, achieving the required QPS.
This article explains the NullPointerException problem, shows traditional null‑checking code, introduces Java 8's Optional class with its constructors and key methods such as of, ofNullable, orElse, orElseGet, orElseThrow, map, flatMap, isPresent, ifPresent, and filter, and provides several real‑world examples illustrating how to replace verbose null checks with elegant Optional‑based code.
This article explains how the Promise time‑control system replaces a naïve exponential rule‑matching approach with a column‑wise inverted index and bitmap bitwise operations, reducing computational complexity from 2ⁿ to n while also addressing space efficiency through RoaringBitmap compression.
This article explains how positioning a try‑catch block inside or outside a Java for‑loop affects exception handling, loop termination, performance, memory usage, and provides practical guidance for choosing the appropriate placement based on business requirements.
This article details how Bilibili’s relationship‑chain service evolved from a MySQL‑based design to a KV‑store with asynchronous writes, introduced multi‑layer caching with memcached, Redis hash and KV, added bloom‑filter optimization, and implemented hotspot mitigation to support millions of QPS.
This article explains what JSON API is, outlines its key advantages such as compound documents, sparse fieldsets, optional features, pagination and caching, compares it with GraphQL, and illustrates its practical use through a FitBit case study, helping readers decide if it fits their API design needs.
This article shares eighteen practical techniques—including batch database operations, asynchronous processing, caching, prefetching, pooling, event callbacks, parallel remote calls, lock granularity, file‑based storage, indexing, SQL tuning, transaction management, deep pagination fixes, compression, NoSQL alternatives, thread‑pool design, and machine‑level optimizations—to dramatically reduce API latency from seconds to milliseconds.
This tutorial explains how Go developers can generate Tars RPC code from IDL, implement server and client logic, configure server and client settings, use various call patterns such as context, one‑way, mod‑hash and consistent‑hash, and quickly scaffold projects with the tarsgo tool.
This article examines how JD Logistics’ Contract Center manages millions of daily contract queries by analyzing call patterns, identifying high rates of empty results, and implementing a three‑layer protection strategy using Bloom filters, Redis caching, and database safeguards to ensure high‑availability and data consistency.
This article provides an in‑depth overview of the Caffeine local cache library for Java, covering its concepts, configuration options, loading strategies, eviction policies, asynchronous usage, statistics collection, and step‑by‑step integration with Spring Boot including annotations and practical code examples.
The article explains why Java exception stack traces can disappear during high‑traffic events due to the JIT‑based Fast Throw optimization, describes its conditions, shows performance measurements with and without the feature, and provides practical guidance for locating and diagnosing related production issues.
This article examines the various Python web frameworks, libraries, and standards—such as Django, Flask, Django REST Framework, Requests, Swagger/OpenAPI, Marshmallow, Pydantic, Starlette, and Uvicorn—that inspired FastAPI's design, highlighting their key features and how they contributed to FastAPI's capabilities.
This article provides a detailed interview recap covering Redis in‑memory database concepts, MySQL transaction and indexing fundamentals, OSI network layers, operating‑system memory layout, Java versus Go differences, and key takeaways for future study, all aimed at backend developers.
This article shares a hands‑on journey of solving cross‑origin issues in a multi‑domain education product, covering CORS fundamentals, simple and preflight requests, Nginx and SpringBoot configurations, response‑code choices, and Chrome’s insecure private‑network restrictions, with practical solutions and lessons learned.
The article explains that the core of the programmer's 35‑year crisis is the rapid pace of technological change outstripping learning speed, illustrated with backend sharding, frontend toolchain shifts, and AI advances, and offers practical advice to broaden skills beyond narrow tech stacks.
This article traces the development of message queues from early decoupling solutions like ActiveMQ and RabbitMQ, through high‑throughput designs such as Kafka and RocketMQ, to modern platform‑centric systems like Pulsar, while detailing core concepts, architecture diagrams, storage mechanisms and trade‑offs.
The article recounts a recent Golang interview, highlighting the candidate’s background, the specific technical questions asked—such as payment channel encryption, image‑search implementation, HTTP vs gRPC, pointer versus value passing, and slice behavior—and provides the interviewer’s feedback and advice for improving interview performance.
This article explains how to improve Oracle database performance by creating archive tables and triggers, and demonstrates step‑by‑step PHP code for connecting to Oracle, moving old records, and querying archived data.
This article introduces the Laravel‑XlsWriter package, explains its high‑performance PHP‑C extension features for writing and reading Excel files, and provides step‑by‑step installation, configuration, and usage instructions including service provider registration, facade aliasing, publishing, and mode options.
This article discusses the evolution from MVC‑based backend‑centric development to modern frontend‑backend separation, explains the benefits of clear responsibility division, outlines the SPA era with Ajax, and provides a detailed V1.0.0 API specification including request/response formats, pagination, and special field conventions.
This article provides PHP code examples for recursively removing files and folders, explains the use of unlink() and rmdir() functions, and demonstrates how to delete all ".svn" directories along with their contents.
To prevent storing duplicate remote images on a PHP server, this guide explains two techniques—generating a unique filename from the image URL or from the image content using MD5 hashing—along with complete PHP code examples that check for existing files before saving.
The article explains that database connection pools remain based on blocking I/O because JDBC was designed for BIO, managing session state per connection, and the ecosystem lacks a unified non‑blocking driver, making IO multiplexing technically possible but practically complex and rarely needed.
This article explains how to implement a random Double Color Ball (Shuangseqiu) lottery number generator using PHP arrays, detailing the definition of red and blue ball arrays, random selection with array_rand(), and outputting the results via foreach loops, along with the complete source code.
A high‑traffic Go service suffered intermittent availability drops below 99.9% due to timeouts, and after extensive profiling, tracing, and heap analysis the root cause was identified as a memory‑leak bug in the third‑party gcache LFU implementation, which was fixed by upgrading the library.
This article explains how to use the python-decouple library to isolate configuration from code, demonstrating five practical examples for loading sensitive information, default values, booleans, integers, and list settings in Python-based API automation.
This article explains the importance of clear application layering, describes Alibaba's recommended layer structure, proposes an optimized layering model, discusses domain model conversions across layers, and summarizes how proper layering improves code maintainability and reuse in backend systems.
This article outlines a comprehensive approach to building a scalable multi‑account login system that supports phone‑number/password, phone‑number/verification‑code, and various third‑party OAuth providers, detailing workflow steps, database schema, advantages, drawbacks, and a one‑click login integration.
The article examines Meta’s Threads app, comparing its features and user experience with Twitter, and dives deep into the backend technologies—including Python 3.10, a custom Cinder JIT, Django customizations, and supporting services—that power the rapidly growing platform.
This article explains what JSON is and demonstrates how to encode and decode JSON data in PHP using json_encode() and json_decode(), including examples with associative arrays, indexed arrays, JSON_FORCE_OBJECT, and iteration over decoded structures.
This article explains several common techniques for embedding HTML within PHP code, including echo statements, mixing PHP inside HTML files, using heredoc syntax, and including external HTML files via the include() function, each illustrated with clear code examples.
This article explains how to use @ControllerAdvice and @RestControllerAdvice for both local and global exception handling in Spring, demonstrates limiting handlers by annotation, controller class, or package, and clarifies the precedence rules between local and global handlers.
This article reviews the ten most popular backend frameworks for 2023—including Spring Boot, Django, Express.js, ASP.NET Core, Laravel, Ruby on Rails, Fiber, CakePHP, Flask, and Play—explaining their key features, language ecosystems, and recommended learning resources for developers of all levels.
This article explains common reasons why PHP-FPM processes may terminate unexpectedly and provides step‑by‑step instructions for configuring systemd and Supervisor to supervise PHP‑FPM, ensuring continuous and reliable operation on Linux servers.
This article explains PHP 8.2’s readonly classes, describing their purpose, advantages such as maintainability, security and performance, and provides a complete code example that demonstrates defining a class with readonly properties and the resulting behavior when attempting modifications.
