This article provides a collection of reusable PHP functions for checking, creating, listing, copying, and deleting files and directories, offering developers ready‑to‑use code snippets that simplify common filesystem operations in backend projects.
This article explains why caching is essential for high‑traffic services, describes the inherent consistency problems between Redis and MySQL, analyzes four cache‑update strategies with concrete concurrency scenarios, and provides practical recommendations such as using delete‑after‑update, delayed double‑delete, expiration, MQ, and binlog subscription to achieve eventual consistency.
This article explains the Spring Bean lifecycle in depth, covering IoC fundamentals, each lifecycle stage, extension points such as Aware interfaces and BeanPostProcessor, and provides a step‑by‑step code walkthrough that maps the execution flow from bean creation to destruction.
This article explains why payment orders can disappear after a successful wallet transaction, outlines the complete payment flow, distinguishes internal and external drop‑order scenarios, and provides practical server‑side and client‑side strategies—including retry mechanisms, reliable async messaging, scheduled queries, and delayed‑message approaches—to reliably prevent such issues.
This article explains the transition from monolithic to microservice architecture using an online supermarket example, highlights the problems caused by rapid, unplanned scaling, and presents systematic solutions such as service decomposition, database sharding, monitoring, tracing, gateway, service discovery, circuit breaking, testing, and service mesh adoption.
This article explains the concept of caching, compares it with buffering, outlines common scenarios such as memory, SSD, static, distributed and local caches, discusses their advantages and limitations, and provides a Java Guava Cache example for practical backend performance optimization.
A real‑world incident at Digg shows how using a mutable default argument in a Python function caused a cascade of performance problems, leading to a rushed v4 release, service outages, and ultimately the company's decline and acquisition.
The article explains how Redis Streams offers a lightweight, memory‑based alternative to Kafka, detailing its features, consumer‑group model, performance advantages, and suitable use cases while acknowledging scenarios where a full‑featured message queue remains preferable.
The article recounts Digg's disastrous v4 launch, highlighting how a seemingly harmless Python default‑argument bug combined with rushed deployment, missing rollback plans, and external pressures led to massive performance failures, costly fixes, and ultimately the company’s decline and acquisition.
The team resolved export failures caused by a deprecated cloud‑storage middleware by adding a new method that generates user‑specific sub‑paths and saves files, but recognized security, configurability, and maintainability issues, recommending configurable buckets, thorough permission reviews, and reusable design when migrating third‑party dependencies.
After a recent deployment a backend update operation became extremely slow, revealing RPC retry, thread‑pool misconfiguration, and row‑lock contention between services, which were analyzed and resolved through thread‑pool tuning and transaction separation.
This article explains how to automatically generate large volumes of realistic test data for statistics, billing, and IoT scenarios by leveraging API calls, Metersphere timers, CSV-driven scripts, and custom Kafka producers, reducing manual effort while preserving data accuracy.
This article explains the need for globally unique, trend‑increasing IDs in distributed systems, evaluates common solutions such as UUIDs, database auto‑increment, Redis counters, and presents a detailed Java implementation of Twitter's Snowflake algorithm with code examples, deployment tips, and a discussion of its advantages and drawbacks.
Bun is a modern JavaScript runtime built on WebKit’s JavaScriptCore instead of V8, backed by $7 million funding, and its creators aim to release a stable version within six months, positioning it as a potential alternative to Node and Deno.
This article provides PHP code snippets to determine the HTTP request method—such as GET, POST, PUT, DELETE, PATCH—and to check for AJAX requests, offering a quick reference for developers implementing RESTful APIs in a backend environment.
This guide explains Go's if statement syntax, including required braces, optional else‑if and else clauses, the init‑statement form, and a crucial formatting rule that the else must appear on the same line as the closing brace to avoid automatic semicolon insertion.
This article demonstrates how to create a real-time device inspection monitoring system using WebSocket, with a Vue front-end that visualizes device status and a SpringBoot back-end that pushes updates, covering project setup, code examples, configuration, and testing steps.
Baidu’s commercial front‑end team integrated an interface platform with a data‑direct capability—leveraging BFF layers, Redis‑based offline data injection, stub services, data grading, and fragment‑based batch editing—to enable true parallel front‑back end development, eliminate separate test environments, and cut average project delivery time by more than half across thousands of projects.
This article explains the complete e‑commerce payment workflow, identifies the causes of duplicate payments such as missing deduplication, order loss and multi‑channel issues, and presents practical backend solutions including distributed locking, result caching, payment‑flow cancellation, active polling, and sync‑async notification strategies to ensure order consistency and improve payment success rates.
This article compares Ruby and Python as high‑level, object‑oriented languages for web development, outlining their histories, core features, popular frameworks, performance statistics, and suitability for different project needs to help developers choose the right tool.
Learn how to replace tangled if‑else code with a visual workflow engine using CompileFlow, from setting up the designer and BPM files to binding data, methods, conditions, and executing a sample chicken‑training process, while understanding the underlying principles and practical tips.
The article explains how NetEase Media rebuilt its core services with Go, created the open‑source ngo framework to unify dependencies, health‑check, tracing, configuration and OpenID support, and provides detailed code examples and integration guidelines for backend developers.
Apache Dubbo 3.1.0 introduces native Service Mesh support, an error‑code troubleshooting guide, Fastjson2 serialization, single‑port multi‑protocol handling, and full compatibility with Dubbo 3.0, providing a lighter data‑plane and a more cohesive control‑plane for cloud‑native applications.
This article explains the origins and purpose of Spring transactions, demonstrates how to quickly set them up with code examples, explores key features and common pitfalls, and provides an in‑depth comparison of the REQUIRED, REQUIRES_NEW, and NESTED propagation types for robust backend development.
This article explains the fundamentals of reactive programming as a declarative, data‑stream‑based paradigm, describes its core concepts such as streams, events, and operators, and demonstrates how to replace traditional imperative Java code with RxJava‑based reactive implementations for a backend service that processes MQ messages, fetches data, and updates a cache while handling errors, request deduplication, and rate limiting.
This article explains the sliding window rate‑limiting algorithm, its advantages over fixed windows, and provides a detailed step‑by‑step implementation using Sentinel’s data structures, including window partitioning, bucket management, concurrency handling, and calculation of request counts within a moving time interval.
This article explains how isolating resources such as CPU, network, and disk through thread, process, cluster, and other techniques improves utilization, prevents cascading failures, and enhances stability in distributed backend architectures, illustrated with Netty, Dubbo, Tomcat, and Hystrix examples.
This article provides an in‑depth overview of microservice architecture, covering concepts such as RPC, serialization, CAP and BASE theories, distributed transaction patterns like TCC, service monitoring with Sleuth and ELK, high‑availability strategies, load balancing, configuration management, Dubbo fault‑tolerance clusters, timeout handling, service registration and discovery, communication protocols, AOP fundamentals, Spring annotations, JdbcTemplate and RestTemplate usage, transaction management, and the inner workings of Spring Boot starters.
The article analyzes the high load and low CPU utilization problems of a Java service, compares various I/O models, introduces coroutine fundamentals and the Quasar library, demonstrates practical migration steps with code examples, and evaluates the performance gains and risks of adopting coroutine‑based concurrency.
This guide explains how to obtain a client’s IP address behind proxies in Java, choose appropriate HTTP headers, and use the open‑source ip2region library to query offline databases for accurate, millisecond‑level IP geolocation, including code examples for Spring Boot integration.
This article introduces Excel fundamentals, demonstrates how to install and use the Go tealeg library to create spreadsheets, and explains how to leverage Go reflection to convert structs, slices, or arrays into Excel files with practical code examples.
Zuoyebang replaced its PHP monolith with the Go‑based Zgin framework to overcome microservice, performance, and cloud‑native limitations, delivering a modular, high‑performance backend that supports service governance, efficient logging, and seamless deployment across thousands of services.
The article systematically analyzes why backend APIs become slow—covering database slow queries, complex business logic, thread‑pool misconfiguration, lock design flaws, and machine problems—and presents practical Java‑based optimization techniques such as pagination fixes, index tuning, multithreading, proper thread‑pool sizing, lock refinement, caching, and asynchronous callbacks.
This article explains why the Controller layer is essential, identifies common pitfalls such as tangled validation and inconsistent responses, and demonstrates how to refactor Spring MVC controllers using a unified Result wrapper, ResponseBodyAdvice, proper String handling, JSR‑303 validation, custom validators, and global exception handling to produce clean, maintainable backend code.
The article argues that code review is essential for software quality, critiques common shortcomings in engineering practice, and presents principles such as simplicity, composition, transparency, and disciplined logging, illustrated with Go code examples, to guide developers toward maintainable, scalable backend systems.
This article introduces RabbitMQ as an open‑source AMQP‑based message broker written in Erlang, outlines its major advantages and drawbacks, and explains core concepts such as producers, exchanges, queues, and consumers for backend developers.
This comprehensive guide explains message‑queue fundamentals, RabbitMQ architecture, exchange types, and key performance metrics, then walks through macOS installation, Java client configuration, and detailed code examples for producers, consumers, and utility wrappers covering direct, fanout, and topic patterns, plus durability and ACK strategies.
This article explains the evolution of software complexity, introduces microservice architecture as a modern solution, and details ten essential design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—while outlining their advantages, disadvantages, and appropriate usage scenarios.
The article shares a senior architect's experience improving a legacy multi‑service web system's performance by 3000% by fixing a DB connection leak, adopting tail‑latency metrics, and investing in load testing, monitoring, logging, and dedicated SRE resources.
This article details how Ant Group's npmmirror.com handles massive traffic with a distributed backend, introduces the open‑source cnpmcore registry, explains its bug‑versions safety features, migration strategies, and how enterprises can customize the service using TypeScript, tegg and DDD principles.
This article explains Java reflection’s core concepts, how the JVM dynamically loads Class objects, and provides practical examples—including field retrieval, caching strategies, and integration with Spring—to help developers harness reflection for dynamic code manipulation while avoiding common pitfalls.
This article explains the definitions, differences, and practical usage of View Object (VO), Data Transfer Object (DTO), Domain Object (DO), and Persistent Object (PO) within a three‑layer architecture, offering design guidelines, conversion flows, and considerations for when to merge or separate these objects.
This article explains how to use Spring ApplicationEvent to decouple business logic, showing step‑by‑step code for defining custom events, creating listeners with both ApplicationListener and @EventListener, publishing events synchronously and asynchronously, enabling async processing, and verifying behavior with unit tests.
The article explains the need for delayed processing in business scenarios, compares various delayed queue solutions such as Java DelayQueue, RocketMQ, and RabbitMQ, and details a Redis-based implementation with message storage, ZSET queues, pull jobs, workers, and Zookeeper coordination for high availability.
This article outlines the latest Spring Framework 5.3.20 release, highlighting new GraphQL MIME support, SAML logout policy tweaks, numerous bug fixes—including property precedence and logging issues—and a comprehensive list of updated third‑party dependencies.
This article explains Go's context package, detailing its core interface, the four concrete implementations (emptyCtx, cancelCtx, timerCtx, valueCtx), their methods, internal cancellation propagation, and practical usage recommendations for safe and effective goroutine coordination.
This article examines why cache consistency cannot be fully guaranteed, analyzes common inconsistency scenarios between Redis and MySQL, compares four update strategies, and offers practical recommendations such as updating the database before deleting cache, using short expiration times, delayed double‑delete, MQ or binlog approaches to achieve eventual consistency.
This guide walks through integrating MyBatis-Plus with Spring Boot, covering environment setup, Maven dependencies, configuration of data sources, entity annotations, CRUD services, pagination, logical deletion, enum handling, automatic field filling, multi‑data‑source strategies, and testing with full code examples.
This article walks through practical cache designs—local page caching, object caching with Ehcache, distributed caches like Redis and Memcached, and multi‑level cache architectures—showing real‑world code, refresh policies, and pitfalls to help engineers boost performance and stability in high‑traffic applications.
This guide explains a simple method to apply custom modifications to Composer packages by copying the needed files into a patches directory and configuring the post‑autoload‑dump script to automatically overwrite the original files during installation or update, avoiding the need for external tools.
This article analyzes the challenges of data‑burst scenarios in a data‑push platform, evaluates traditional throttling methods, presents JVM‑level tuning and a custom heap‑usage based flow‑control mechanism, and validates the solution through extensive pressure testing, demonstrating significant reductions in full GC frequency and overall push latency.
This article examines the need for scheduled tasks in various business scenarios, reviews single‑machine and distributed Java scheduling frameworks such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn, and XXL‑Job, and provides a detailed comparative analysis to guide framework selection.
This article explains the fundamentals of TCP sockets, why raw TCP lacks message boundaries, how custom protocols add headers to solve the sticky‑packet problem, and compares HTTP and RPC as application‑layer protocols, highlighting their histories, use‑cases, and performance trade‑offs.
Django 4.1 has been officially released, introducing asynchronous ORM interfaces, class‑based view async handlers, database‑level model validation, and enhanced form rendering accessibility, while also marking the end of mainstream support for Django 4.0, which will receive only security fixes until April 2023; the article also provides pip and Git commands for installing the latest stable or development versions and a brief overview of Django’s core principles.
This article explains RocketMQ's push and pull consumption modes, shows how its pseudo‑push implementation uses long polling to balance real‑time delivery and consumer pressure, and walks through the core source‑code mechanisms that hold and resume pull requests.
This article examines common business scenarios that require timed tasks, explains why scheduling is essential, reviews single‑machine and distributed Java scheduling frameworks—including Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn, and xxl‑job—then provides a detailed feature comparison, deployment considerations, and practical recommendations.
This article explains how Spring Boot's default /error mapping works, how to customize error responses with ErrorController, ErrorAttributes, @ControllerAdvice, custom HTML pages, ErrorViewResolver, ErrorPageRegistrar, and how to configure CORS globally or per controller.
This article explains why oversized logs hurt system performance, presents three practical log‑shrinking strategies—printing only necessary logs, merging duplicate entries, and simplifying content—illustrates them with Java code snippets, and evaluates their impact through a real‑world case that cuts daily log volume from 5 GB to under 1 GB.
The article explains why caching is essential for high‑traffic read‑heavy services, analyzes the consistency problems that arise when data exists simultaneously in MySQL and Redis, compares four cache‑update strategies, and provides practical recommendations such as using expiration, delayed double‑delete, message queues, and binlog subscription to achieve eventual consistency.
This article explains how to obtain a user's IP address on the server side, use the Taobao IP database or the open‑source ip2region library to map the IP to province and city, and demonstrates integration in Java, PHP and Laravel with sample code and performance details.
The article analyzes why a coupon‑distribution feature can issue more coupons than available under heavy load, explains the root cause of concurrent stock deductions, and presents four practical solutions—including Java synchronized blocks, SQL row‑level locking, Redis distributed locks, and Redisson—to reliably prevent over‑issuance.
The article explains the concept of interface call idempotency in distributed micro‑service architectures, outlines scenarios that cause idempotency problems, and presents practical solutions such as token mechanisms, various lock strategies, unique constraints, deduplication tables, and global request IDs, with code examples in Java and Redis.
This article explains how Spring Application Events can decouple complex business logic, demonstrates creating custom events, listeners, and publishers, shows both synchronous and asynchronous handling with @EventListener and @Async, and provides complete code examples and test results for a Spring Boot application.
The article describes how Ctrip built and continuously improved a Trace system for its ticket‑front‑end microservices, detailing the challenges of distributed logs, the architecture of the solution, and the functional features such as friendly search, multi‑platform aggregation, page replay, and one‑click mock that together boost debugging efficiency for both developers and non‑technical operators.
This article explains why logging is essential for maintainable software, outlines best‑practice guidelines for readable, performant, and secure log output, and details Log4j components, log level hierarchy, and practical macro examples for each level.
This article explains Tomcat’s internal component architecture, walks through the request‑processing flow, and details three crucial configuration parameters—maxThreads, maxConnections, and acceptCount—offering practical formulas and tuning guidelines to improve throughput without adding hardware.
The article explains why Dubbo’s RPC model, with its serialization limits, single‑connection design, and high memory consumption, is ill‑suited for transmitting files, and compares it with HTTP and Feign approaches that handle large file uploads more efficiently, while also providing practical code examples.
This article explains why rate limiting is essential for both physical venues and online services, describes common strategies such as circuit breaking, service degradation, delay handling, and privilege handling, compares caching, degradation, and limiting, and details counter, leaky‑bucket, and token‑bucket algorithms with concrete Guava and Nginx‑Lua implementations.
This article summarizes the author's experience optimizing backend interface performance, covering common causes such as slow MySQL queries, complex business logic, thread‑pool and lock design flaws, and offers practical solutions including pagination tricks, indexing, caching, multithreading, and asynchronous callbacks.
This article compiles a comprehensive collection of regular expressions for validating numeric formats, character sets, email addresses, domain names, URLs, phone numbers, IP addresses, dates, and other special patterns, providing developers with ready‑to‑use snippets for robust input validation.
This article outlines seven major areas of Java backend performance optimization—including reuse, computation, result‑set, resource‑conflict, algorithm, efficient implementation, and JVM tuning—explaining concepts, techniques, and practical examples to help developers improve application speed and resource utilization.
This article explains five common BigDecimal traps—including constructor precision loss, equals vs compareTo, division exceptions, string conversion quirks, and operation order—provides code examples, and recommends using the JSR‑354 Money API with Maven for safer monetary calculations in Java backend development.
This article walks through three progressive implementations for handling intricate e‑commerce search filters—starting with a raw SQL approach, then optimizing with indexed queries and split statements, and finally leveraging Redis sets and sorted sets for caching, pagination, and high‑performance query execution.
Netty 5.0.0.Alpha4 has been released, removing duplicated code, cleaning up the API, adding ProtocolFamily‑based socket creation, renaming options, supporting JDK Unix Domain Sockets, improving EventLoop registration, fixing macOS disconnect, and replacing synchronized blocks with Java Locks for better Loom compatibility.
This article explains why using return inside a Java 8 forEach behaves like continue rather than breaking the loop, analyzes the underlying reasons, and presents practical solutions such as switching to a traditional foreach loop or throwing an exception to exit early.
Explore the core extension mechanisms of Spring, including FactoryBean, @Import, BeanPostProcessor, BeanFactoryPostProcessor, SPI, SpringBoot startup hooks, event handling, and custom XML namespaces, with detailed code demos and practical examples that reveal how to integrate and extend Spring in real-world applications.
By consolidating each user’s collected content into a single Redis hash, replacing per‑item SISMEMBER checks with a batch HMGET, and limiting cached IDs to the most recent 5,000, the redesign cut API latency by threefold, slashed Redis and MySQL query rates dramatically, and reduced memory and connection usage.
This article examines four strategies for handling session data in distributed backend systems—session replication, client-side storage, hash-based load balancing, and centralized storage with Redis—detailing their principles, advantages, disadvantages, and practical recommendations for different deployment scales.
This article explains the importance of proper logging in software, outlines common logging requirements such as readability, performance, disk usage, and timeliness, and details Log4j components, log level definitions, hierarchy, recommended usage, and provides concrete macro and log‑statement examples.
This article discusses practical methods for reducing log volume in backend applications, including printing only necessary logs, merging log entries, simplifying messages, and applying these techniques in a real-world Java case to shrink daily log size from several gigabytes to under one gigabyte while preserving debugging capability.
This article demonstrates four practical ways to iterate over a Java HashMap—including enhanced for loops with keySet(), iterator-based loops with keySet(), enhanced for loops with entrySet(), and iterator-based loops with entrySet()—and provides a complete example that filters employee objects by salary, complete with full source code.
This article explains how to obtain a user's IP address from an HttpServletRequest in Java, convert it to geographic location using the ip2region library, and provides detailed code examples, Maven setup, caching strategies, and performance testing procedures for backend developers.
This article explains that Spring Boot 3.0 requires Java 17 and Spring Framework 6, outlines the 14 new features of Java 17, and presents benchmark results showing Java 17's performance advantages over Java 11 and Java 16 with different garbage collectors.
The article analyzes the shortcomings of traditional ELK and distributed tracing for complex business systems, proposes a visualized full‑chain log tracing solution that organizes and dynamically links logs by business chain, and demonstrates its implementation and performance gains at Meituan’s content platform.
This article explains how to abstract repetitive data‑report tasks into a standardized workflow, describes the core capabilities of scheduling and configuration, shows how to implement DAG‑based visual editors, and compares similar platforms such as n8n and Orange, offering practical code examples and design insights.
The article outlines practical approaches to monitor and resolve performance bottlenecks in backend applications, covering database slow‑query logs, interface latency, message‑queue backlogs, segmentation timing, caching, batch calls, multithreading, and database tuning techniques such as indexing and transaction isolation.
This article chronicles the step‑by‑step evolution of a workflow engine, detailing how simple sequential approvers were expanded into hierarchical trees supporting parallel, multi‑sign, conditional, proxy, and scripted nodes, while introducing state management, rejection handling, and progress metrics.
This article details the design, evolution, and scaling strategies of a price‑increase coupon system for a C2B digital product recycling platform, covering its initial experimental phase, platformization, sharding‑JDBC implementation, intelligent coupon recommendation, Elasticsearch integration, and operational optimizations for high‑throughput stability.
This article presents a comprehensive collection of thirty Java performance‑tuning techniques—from using String.format and buffered I/O streams to avoiding large transactions, leveraging enums, and handling thread‑local resources—each illustrated with clear code examples and best‑practice recommendations for modern backend development.
This guide walks through creating a phone‑number SMS verification login system in Go using Gin, Viper, and Tencent Cloud SMS, covering service registration, configuration loading, client implementation with functional options, code generation, sending, and Redis‑based verification.
This article recounts a backend team's experience of addressing numerous slow API endpoints, detailing root causes such as MySQL slow queries, complex business logic, thread‑pool and lock misconfigurations, and offers practical solutions including pagination fixes, indexing, query refactoring, concurrency improvements, and caching strategies.
This article walks through real‑world API performance complaints, identifies root causes such as slow MySQL queries, thread‑pool misconfiguration, lock contention and machine issues, and presents practical solutions ranging from pagination rewrites and index tuning to multithreading, caching and async callbacks.
This article visually explains Kafka's core concepts—including producers, consumers, topics, partitions, consumer groups, and cluster architecture—so readers can clearly understand how messages flow, are stored, and remain fault‑tolerant within a distributed streaming system.
This tutorial introduces the lightweight Python Bottle framework, covering installation via pip or source, creating a simple HelloWorld server, using static and dynamic routes, serving files, handling POST requests and file uploads, and tips for local and network deployment.
This article explains the principles behind popular load‑balancing strategies such as round‑robin, weighted round‑robin, smooth weighted round‑robin, consistent hashing, least‑active, and best‑response, and provides clear Java code examples for each method.
This comprehensive guide presents 36 practical recommendations for backend engineers, covering parameter validation, compatibility, extensibility, idempotency, error handling, logging, performance optimization, caching, rate limiting, security, transaction management, and clear communication to help design reliable, maintainable, and scalable service interfaces.
This article analyzes the business challenges of marketing automation, introduces workflow concepts and models, compares workflow engines with state machines, presents popular open‑source engines, and details the design, core modules, interfaces, and practical considerations of a self‑built lightweight workflow engine.
This article details how Dada Express improved the efficiency of rider withdrawal payments by redesigning the clearing and disbursement workflow, introducing asynchronous thread‑pool concurrency, extending API timeouts, implementing idempotent retry logic, and adding safeguards to ensure fund security, resulting in a three‑fold reduction in processing time during peak periods.
This article traces Taobao's server‑side architecture evolution—from a single‑machine setup to distributed caching, load‑balancing, database sharding, microservices, containerization, and finally cloud‑native deployment—highlighting the technical challenges and design principles at each stage.
A backend engineer shares a step‑by‑step case study of reducing a batch‑score query API from 20 seconds to under 500 ms by analyzing the problem, adding a composite index, introducing multithreaded CompletableFuture calls, and limiting batch size with pagination and thread‑pool tuning.
