This article introduces PHP 8's major enhancements—including the JIT compiler, union types, named arguments, attributes, and match expressions—explaining their benefits and providing concrete code examples that demonstrate improved performance, flexibility, readability, and maintainability for backend developers.
This article explains the two primary PHP functions for displaying arrays—print_r() for readable output and var_dump() for detailed type and value information—provides syntax examples, and shows the resulting output of each function.
This article explains why rate limiting is needed in high‑traffic backend services, outlines common methods such as token‑bucket with Guava, Redis‑based counters, Nginx configuration, and thread‑pool limits, and provides complete Java code examples for implementing each approach.
This article explains how to convert a positive integer to a negative one in PHP by using either the multiplication operator (*) or the multiplication‑assignment operator (*=), and provides clear code examples for both methods.
This article explains how to prevent duplicate form submissions in web applications by disabling the submit button on the Vue3 front end and using a server‑generated token in ThinkPHP6 to verify request uniqueness, providing full code examples for both sides.
This article explains the purpose of loops in programming and provides detailed PHP examples of while and do...while constructs, including syntax, step‑by‑step code samples, and important behavior notes such as condition evaluation timing.
This article explains how to integrate IP geolocation into a Spring Boot application by using the ip2region library for offline lookups and an online API for real‑time address resolution, providing code samples, dependency setup, caching strategies, and an interceptor to attach IP information to every request.
This tutorial explains how to use a PHP for loop to iteratively add the numbers from 1 to 100, shows the complete code example, and clarifies the loop syntax and the meaning of the $sum += $x expression for beginners.
This article presents the background, design, architecture, core functionalities, practical challenges, and solutions of MetrAutoAPI, a metric automation API that separates metric data from application layers, supports flexible SQL modeling, rule engine integration, and unified query services to meet evolving data demands.
This article explains how PHP's substr() and mb_substr() functions work, detailing their syntax, parameter behavior for positive and negative start and length values, and provides multiple code examples demonstrating string extraction for both English and multibyte Chinese characters.
This article provides a complete Nginx configuration example that proxies requests to an Alibaba Cloud OSS domain, adds the client’s real IP via the X-Real-IP header, enables gzip compression, and includes detailed comments and logging settings.
A Java backend service suffered a massive first‑request latency because the MD5 hashing library loaded heavy cryptographic algorithms on first use, and the author traced, diagnosed, and solved the issue by replacing the library and sharing lessons on performance debugging.
This article explains how to start a new project using Domain‑Driven Design (DDD), covering service terminology, architectural evolution from monolith to microservices, bounded contexts, the four DDD boundaries, clean layered, hexagonal, and onion architectures, and their practical benefits for backend systems.
This article details a real‑world incident of severe pagination slow queries, walks through the timeline of detection, diagnosis, and mitigation steps, and presents multiple MySQL optimization techniques—including ID‑based queries, sub‑queries, scroll queries, and join‑based solutions—to resolve deep pagination performance issues.
This article presents six different PHP code snippets that demonstrate how to obtain a visitor's IP address using various server variables and environment functions, covering common scenarios such as proxies, CDN headers, and direct connections.
This article explains the concept of data pagination, compares server‑side and client‑side approaches, outlines their implementation details, advantages and disadvantages, and discusses testing strategies and common issues to consider when handling large data sets in web applications.
The article describes how Bilibili tackled exploding fan‑out reads on its video detail page by introducing a Redis‑backed business‑association index and a generic Data Aggregation Gateway, which together cut downstream service traffic and load by over 90% while simplifying aggregation across multiple terminals and scenarios.
This article outlines seven practical applications of PHP’s header() function, including page redirection, content‑type declaration, HTTP status codes, timed redirects, cache control, authentication prompts, and file download handling, providing code examples for each use case.
This article walks through the design and implementation of the order module in the Mall project, covering both backend administration and frontend shopping flow, database schema, API design, and available video tutorials for a comprehensive e‑commerce solution.
This article shares a detailed account of a Tencent testing engineer interview, covering self‑introduction, Go knowledge, Redis performance, distributed lock implementation, semaphore mechanics, RPC vs HTTP, concurrency usage, Git security practices, Linux commands, and a few brain‑teaser and algorithm questions.
This article explains PHP's static keyword, covering static properties and methods, memory management, common use cases such as utility functions and the singleton pattern, and important considerations for visibility and inheritance, accompanied by clear code examples.
This tutorial demonstrates how to install the Tesseract OCR library via Composer, set up a PHP script to load an image, create a TesseractOCR instance, run the OCR process, and output the extracted text, providing complete sample code for each step.
This article explains how to use Redis sets, sorted sets, lists, bitmaps, and HyperLogLog to perform aggregation, ordered queries, binary state tracking, and cardinality estimation for large‑scale applications such as sign‑in systems, e‑commerce comments, and social‑network friend lists.
This article explains how to implement a high‑performance Go coroutine pool by adapting key features of Java’s ThreadPoolExecutor, covering core parameters, task queue design, dynamic scaling, worker management, timeout handling, and provides complete code examples and self‑test results.
This article describes a practical approach to automatically extract and visualize business system knowledge from code by abstracting workflow control logic into a generalized design pattern using the FSM‑X state‑machine framework, discussing its background, methodology, implementation details, and current limitations.
This article explores three practical solutions for exposing APIs only to internal services—microservice isolation, a Redis‑based whitelist via the gateway, and a gateway‑plus‑AOP approach—detailing their trade‑offs and providing complete Java code examples for the chosen method.
MyPerf4J is a Java‑agent based, low‑overhead monitoring solution that provides real‑time method, memory, GC and class metrics, enabling developers to quickly locate performance bottlenecks and assess service capacity in both development and production environments.
This article explains five different techniques for performing page redirects in PHP, including a one‑line header redirect, conditional redirects based on cookies, JavaScript‑based redirects, META refresh tags, and explicit HTTP header redirects with status codes.
This article thoroughly explains PHP's foreach loop syntax, demonstrates its use with indexed, associative, and multidimensional arrays, and provides complete code examples showing how to access values and keys in each scenario.
The article explains why using the '+' operator for string concatenation in Java creates many temporary objects, how the StringBuilder class and compile‑time optimizations can avoid this overhead, and demonstrates object‑creation counts for two typical interview questions using javap bytecode inspection.
This article explains how the Codeape chronic disease cloud management system implements role‑based access control (RBAC), detailing the underlying data models, permission types, Spring Security annotations, department/ward permission handling for both web/PAD clients, and the associated Java code snippets.
This article explains the roles of load balancers and API gateways, compares their layer focus, features, and performance, and outlines when to use each in microservice architectures, API management, and high‑throughput network entry points.
This article presents a comprehensive backend automated testing framework that unifies HTTP and RPC access, introduces a parameter‑pool concept, leverages JSON Schema and JSONPath for validation, and outlines coverage metrics, test case generation, discovery, and continuous improvement to achieve near‑100% API test coverage.
Explore the design and mechanics of Bloom filters, understand their role in preventing cache penetration, learn how to calculate optimal parameters, and see practical Java implementations using Google Guava and Redisson, including code snippets, performance considerations, and strategies for handling deletions.
This article explains the fundamentals of Spring WebFlux, its reactive programming model with Mono and Flux, compares it to Spring MVC, and provides practical code examples for building non‑blocking backend services using Spring Boot.
This article shares detailed 2024 summer internship interview experiences, including the application process, interview timelines, and a comprehensive list of technical and scenario questions asked by Meituan, Baidu, and Perfect World, offering valuable insights for backend development candidates.
This article describes how the ZhiZhuan B2C backend team built a standardized logging, custom Apollo‑based log agent, Prometheus‑driven alerting service, and first‑responsible‑person mechanism to quickly locate and resolve service timeouts, exceptions, and other production issues, even when working off‑site.
This article introduces eight practical approaches for achieving asynchronous execution in Java—including raw threads, Future, CompletableFuture, Spring @Async, ApplicationEvent, message queues, Hutool ThreadUtil, and Guava ListenableFuture—providing code samples, configuration tips, and discussion of each method's advantages and drawbacks.
This article explains how to install the php-dfa-sensitive Composer package, create a SensitiveWords service in a Laravel‑style PHP application, and use its static methods to detect, replace, mark, or retrieve illegal words from user‑generated content.
This guide explains why Java services in containers suffer OOM issues when the JVM heap is mis‑configured, and provides recommended JVM flags, parameter explanations, common FAQs, and tuning tips to reliably limit heap usage and avoid unexpected container restarts.
This tutorial explains how to install and configure Redis, add the PHP Redis extension, and modify PHP settings to store session data in Redis, covering session start, expiration, prefixing, and common session functions to improve performance and stability of PHP applications.
The article explores how an architect’s cognitive upgrade—through systematic thinking, model-driven analysis, and practical design methods—drives effective system architecture, business modeling, and trade‑off decisions, illustrated by a multithreading interview example and a suite of methodological tools.
Learn how to implement RFC 7807 Problem Details in Spring Boot 3, covering the JSON format, Spring’s built‑in support, configuration steps, custom extensions, and practical code examples for handling errors with ProblemDetail, ErrorResponse, and ResponseEntityExceptionHandler.
This article explains the fundamental differences between RPC and HTTP interfaces, their underlying protocols, component architectures, popular frameworks, performance characteristics, and provides guidance on when to use each approach in backend service development.
This article explains the fundamental differences between RPC and HTTP interfaces, describes their underlying client‑server architectures, compares performance, transport protocols, load balancing and service governance, and provides guidance on when to choose each approach in modern backend development.
This article walks through the complete design and implementation of a reusable permission module for a Java e‑commerce backend, covering functional design, database schema, API contracts, and key technical points such as Spring Security, JWT authentication, and Redis‑based performance optimizations.
Vivo’s account platform, serving 270 million users and over 100 billion daily requests, achieves high‑performance stability through disciplined service splitting, hierarchical dependency control, layered caching and sharding strategies, and comprehensive multi‑layer monitoring that together ensure scalability, availability, and rapid fault diagnosis.
This guide introduces Seata Saga’s distributed transaction model, explains its advantages and drawbacks, walks through deployment, JSON state‑machine design, unit‑test exploration, and best‑practice recommendations for reliable microservice orchestration, including compensation strategies, isolation handling, and performance tuning tips.
This article shares a step‑by‑step experience of refactoring a finance‑BFF aggregation service from tightly coupled synchronous calls to a loosely coupled, fully asynchronous architecture, covering problem background, redesign goals, implementation details, Hystrix integration, monitoring, and practical usage examples.
Eclipse Vert.x 4.4.3 introduces a series of updates across core components—including JDBC client tracing fixes, GraphQL-Java upgrade, enhanced gRPC support, Netty and Hazelcast upgrades, new Consul ACL API, Infinispan lock handling, SSL option improvements, Groovy 4.0.12, and various bug fixes—strengthening its lightweight, high‑performance, asynchronous backend framework.
This article explains five common methods for storing authentication tokens during API automated testing—embedding in scripts, using environment variables, configuration files, databases, and secret management systems—and provides complete Python code samples for each approach.
This article provides a comprehensive overview of Redis's ten data types—including strings, hashes, lists, sets, sorted sets, streams, hyperloglog, geospatial, bitmap, and bitfield—detailing their structures, encoding mechanisms, application scenarios, and underlying implementation details with code examples.
This article provides a comprehensive guide to MyBatis dynamic SQL, demonstrating how to use if, choose, trim, foreach, and bind tags for conditional queries, updates, inserts, batch operations, and database‑agnostic expressions, complete with Maven project setup, SQL scripts, and test cases.
This article presents a detailed practice report on the JSF 1.7.6 preheat strategy applied to JD's VOP platform, describing the background, test scenarios, deployment process, monitoring results with and without preheat, and concluding that dynamic preheat significantly reduces performance spikes during service rollout.
The article explains when adding consumers can reduce RocketMQ backlog, the reasons for delayed message pulling, handling slow external services, and details six different MessageQueue allocation strategies—including average, round‑robin, custom, machine‑room, nearby, and consistent‑hash—accompanied by Java code examples.
This article introduces MyBatis streaming query using the Cursor interface, explains its core methods, demonstrates implementation with code examples, discusses suitable application scenarios, and outlines important considerations for efficient and safe large‑scale data processing in Java backend development.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, details the configuration steps, compares their performance and memory usage through benchmark results, and concludes that Undertow offers superior efficiency for high‑concurrency Java backend applications.
This article explores the design of a promotion middle platform that abstracts discount rules, componentizes promotion elements, and introduces a schema-driven configuration approach to enable reusable, extensible, and business‑agnostic promotion activities across multiple product lines.
The article presents a comprehensive overview of JD Tech’s “Magic Flute” activity platform, analyzing traditional high‑code and configuration‑driven development models, proposing a unified low‑code SaaS/PAAS solution, detailing its functional architecture, component management, workflow orchestration, and operational workflows to improve productivity across business teams.
This article details a comprehensive investigation of an out‑of‑memory crash in a critical Elasticsearch cluster, explains how GC logs and heap dumps revealed a to‑space‑exhausted condition, and describes the G1GC tuning parameters that eliminated the nightly spikes and stabilized performance.
This article provides a comprehensive overview of Kafka, covering its core value for decoupling and asynchronous processing, fundamental concepts such as producers, consumers, topics, partitions and replication, high‑performance mechanisms like zero‑copy and OS cache, detailed resource evaluation for CPU, memory, disk and network, operational tools, consumer‑group rebalance strategies, LEO/HW offsets, controller management, and delayed‑task scheduling.
This article walks through the root causes of CORS errors when a front‑end site on port 8080 calls a back‑end service on port 59200, explains the four essential CORS response headers, demonstrates common error scenarios, and provides complete Nginx configuration snippets—including handling pre‑flight OPTIONS requests, custom headers, and method allowances—to reliably eliminate cross‑origin problems.
This step‑by‑step tutorial explains how to install and configure Nginx for free, create a simple website, start the server, and use a free tunneling service to expose the site to the internet without paying for hosting or a domain.
This article explains how Redis List can be used as a FIFO message queue, covering core concepts, command usage, reliability techniques, and Java integration with Redisson for building a practical backend messaging solution.
This article explains how to invoke external APIs in a SpringBoot application using three approaches—raw HttpClient, RestTemplate, and Feign—detailing configuration, code examples for GET and POST requests, token handling, and header interception.
This article explains PHP exception handling, describing what exceptions are, how the try‑throw‑catch mechanism works, and provides code examples that illustrate throwing, catching, and converting system errors into exceptions for robust backend development.
This article explains three PHP techniques—get_headers, cURL, and apache_request_headers—to fetch HTTP header information of remote images, providing step‑by‑step code examples and sample outputs for developers needing header data in web applications.
This article explains how Domain‑Driven Design (DDD) can be applied to a complex pricing system, covering business understanding, strategic and tactical design, context integration, layered architecture, code organization, and concrete Java examples that illustrate evaluation and pricing algorithms.
This article explains cache avalanche, breakdown, and penetration, describes why they occur, and provides practical strategies such as pre‑warming, staggered expiration, mutex/queue protection, double‑layer caching, Bloom filters, and consistent update patterns to keep backend systems stable and data consistent.
This article explains MySQL's binlog, its role in master‑slave replication, and how businesses can harness it for data heterogeneity, cache synchronization, and task dispatch, illustrating practical middleware designs that transform raw changes into valuable services.
This article provides a detailed overview of Java backend utilities, covering Spring's Assert class for logical checks, common ObjectUtils and StringUtils methods, collection helpers, file and stream utilities, as well as reflection and AOP tools with practical code examples.
This article describes the background, design goals, core technical solution, versioned implementation process, and performance improvements of a real‑time final‑price calculation module that integrates product price, coupons, and promotions to deliver up‑to‑date pricing for e‑commerce users.
This article explains the inner workings of Redis Hashes, covering the dict and listpack storage mechanisms, memory‑optimizing conditions, rehashing strategies, and the underlying C structures that enable fast O(1) field lookups and efficient memory usage.
This article demonstrates how to use PHP's execution functions—exec, system, passthru, popen, proc_open, and shell_exec—to run shell commands, capture output, and handle process streams, providing example code snippets for each function in PHP scripts.
This article explains what logging is, why it matters, when to log, the principles and level conventions, common log formats, and a comprehensive set of mandatory and recommended best‑practice rules for writing robust, secure, and maintainable backend logs.
This article introduces the URule rule engine, explains its background and features, walks through installation and usage in a Spring Boot project, details core concepts such as variable, constant, parameter, and action libraries, and provides complete code examples for rule sets and decision tables.
This article explains Tomcat's component architecture, describes the three critical parameters (maxThreads, maxConnections, acceptCount) that affect request handling, and provides practical tuning recommendations to improve backend performance without additional hardware costs.
This article explains how to design clear, consistent API error codes and messages by referencing HTTP status code segmentation, defining code‑message pairs, customizing user‑friendly messages, and centralizing handling to improve communication, debugging, and monitoring for backend services.
This article analyzes the challenges of distributed transactions in a micro‑service order system, compares XA, TCC, and SAGA patterns, and details how the open‑source DTM framework is applied to achieve reliable order creation while handling crashes, rollbacks, idempotency, and network anomalies.
This article explains the background, key scenarios, functional components, third‑party payment capabilities, implementation logic, rule‑engine usage, and large‑scale data handling strategies of a checkout system, providing a comprehensive view of its backend architecture and operational considerations.
Facing a 50‑million‑row financial transaction table, the team implemented horizontal sharding with sharding‑jdbc, designed migration and pagination strategies, tackled multi‑datasource transaction issues, and outlined a phased rollout, providing practical insights for large‑scale MySQL table splitting and backend system stability.
The article showcases several advanced IntelliJ IDEA debugger features—non‑suspend, exception, and dependent breakpoints, breakpoint restoration, custom object and list renderers, object marking, and reference/async stack trace tools—that enable backend developers to diagnose and resolve issues far more quickly and precisely than with basic debugging operations alone.
This article explains how to restrict the number of concurrent browser logins for a user account by storing login details in a database or Redis, comparing browser agent strings, and returning appropriate error messages, with full PHP code examples.
This article explains the causes of Redis cache penetration, avalanche, and thundering herd, and provides practical mitigation strategies such as caching null values, using white‑lists, Bloom filters, pre‑warming hot keys, staggered expirations, multi‑level caching, and lock mechanisms.
This article introduces seven relatively obscure but highly useful PHP built‑in functions—highlight_string, str_word_count, levenshtein, get_defined_vars, escapeshellcmd, checkdate, and php_strip_whitespace—explaining their purpose and providing clear code examples for each.
This article explains how to enable fuzzy search on encrypted sensitive fields such as phone numbers and ID numbers in a MySQL database by using Spring Boot, AOP, tokenized ciphertext mapping tables, and encrypted keyword queries to balance security and query performance.
This article explains how to create a reusable Spring Boot starter for enterprise‑level object storage services by leveraging the Amazon S3 protocol, covering OSS fundamentals, dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing with code examples.
Bilibili redesigned its fragmented account system into a unified, multi-tenant architecture using DDD and a four-layer design, consolidating all business lines into one codebase with configurable data isolation, logic, and dependencies, split into four micro-services, and migrated safely via gray-release and bidirectional sync.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering database strategies, tenant isolation, dynamic routing, and deployment scenarios for SaaS applications.
The article explains why synchronous protocols should be avoided in microservice communication, describes how to use RabbitMQ as an asynchronous message broker with various exchange types and routing patterns, provides step‑by‑step C# examples for sender and receiver services, and shows how NServiceBus can further decouple and manage long‑running requests.
This article explains three progressively finer-grained approaches to caching paginated lists in Java—directly caching whole pages, caching individual objects after retrieving their IDs, and caching both ID lists and object entries using Redis structures—along with code examples and performance considerations.
A senior Tencent Cloud backend engineer outlines practical best‑practice guidelines—applying DRY and SOLID principles, leveraging common design patterns, designing high‑availability architectures, automating workflows, prioritizing value‑driven development, fostering clear communication, ensuring reliability, and encouraging continuous learning—to write clean, maintainable, and resilient backend systems.
This article explains how JD.com’s retail shopping‑cart team tackled growing business complexity by redesigning the cart with a full asynchronous architecture, detailing the overall solution, implementation challenges such as fine‑grained retries and monitoring, and the resulting performance gains.
The article explains the concept of idempotency for APIs, distinguishes request and business idempotency, highlights the risk of idempotent breakdown under high concurrency, and presents a practical solution using a three‑step process—lock, check, and update—often implemented with Redis distributed locks and database uniqueness constraints.
This article presents a comprehensive technical overview of the Transaction Fulfillment Product Center, detailing its background, system architecture based on DDD and micro‑services, key features such as unified product management, template‑driven form generation, metadata handling, complex search capabilities, and a custom ID generator, while also providing code examples of extension points.
This article introduces Sa-Token, a lightweight Java permission authentication framework, explains why it was chosen over Spring Security and Shiro, details its core login and permission APIs, demonstrates integration with Spring Boot and WebFlux, and lists its extensive feature set for modern backend development.
RocketMQ 5.1.0 introduces a tiered storage module that offloads messages from local disks to cheaper storage, enabling longer retention without impacting hot data performance, and the article explains its design, implementation details, configuration steps, and current challenges.
The article explains Tubi's migration from PHP and Node.js to Elixir, detailing how the functional language improved the performance of their policy engine and other backend services, while sharing engineers' experiences and addressing concerns about using a niche technology.
This article explains the three major Redis cache issues—penetration, avalanche, and breakdown—detailing their causes, real‑world examples, and practical mitigation strategies such as caching null values, using Bloom filters, staggering TTLs, multi‑level caching, and lock mechanisms to protect database stability.
This article introduces the MyBatis‑Plus‑Join library that adds join capabilities to MyBatis‑Plus, explains how to install it via Maven or Gradle, shows how to extend mapper and service interfaces, and provides detailed code examples for simple three‑table queries, pagination, and advanced custom SQL usage.
