The article explains PHP's floor() function, describing its signature, parameter, return type, and provides example code showing how it truncates floating‑point numbers to the nearest lower integer, with sample outputs for positive and negative values.
This article explains how the Java Virtual Machine loads .class files into memory, detailing the three-stage process of loading, linking (verification, preparation, resolution), and initialization, while also covering array loading, custom class loaders, and common pitfalls such as deprecated APIs and verification options.
The PHP expm1() function returns the value of exp(number) − 1, providing accurate results even when the argument is close to zero, and includes details on its syntax, parameters, return value, example usage, and sample output.
This article walks through using Socket.IO to test whiteboard pixel data transmission, presenting a Java test script, sample console logs, and an explanation of the joinRoom interface that pushes full board state to connected clients.
This article provides a detailed walkthrough of how ThinkPHP instantiates controllers after route detection, explains the role of the Dispatch module, and compares the behavior of ArrayAccess versus the magic __get method for accessing container services, illustrating each step with code examples.
This article presents a collection of practical Laravel Eloquent model techniques, including selecting specific attributes with find, cloning models via replicate, comparing models with is, refreshing and reloading records, updating related models with push, customizing soft‑delete columns, and detecting attribute changes using getChanges, getDirty, and getOriginal.
This article explains the PHP exp() function, detailing its signature, parameter description, return value, and providing example code that demonstrates how to calculate e raised to a specified exponent, along with the resulting output.
The article explains PHP’s deg2rad() function, detailing its signature, parameter, return value, and provides example code that demonstrates converting 45 degrees to radians and verifying the result against the constant M_PI_4 in PHP.
This article explains the evolution and inter‑relationships of Java logging libraries such as Log4j, JUL, JCL, SLF4J and Logback, shows how to configure adapters to unify logging across frameworks, addresses common runtime issues, and provides coding‑style recommendations for consistent log output.
This article explains the PHP decoct function, which returns the octal representation of a given decimal integer, details its parameter and return value, and provides example code demonstrating conversions such as 15 → 17 and 264 → 410.
This article explains how to export massive amounts of data from Python to Excel by installing openpyxl, providing complete code examples for reading and writing both .xlsx and .xls files, comparing xlrd/xlwt with openpyxl, and recommending the best approach for large‑scale data export.
The article explains PHP's dechex() function, detailing its purpose of converting a decimal integer to a hexadecimal string, describing the valid input range, parameter definition, return value, and providing example code with expected output.
This article surveys major RPC frameworks—including Dubbo, Motan, Spring Cloud, gRPC, and Thrift—detailing their architectures, communication protocols, serialization formats, cross‑language support, and ecosystem components, and offers guidance on selecting the most suitable framework based on language requirements, performance, and feature completeness.
This comprehensive guide explains the evolution, core concepts, advantages, drawbacks, and practical usage scenarios of microservice architecture, then details ten critical design patterns—including database per service, event sourcing, CQRS, Saga, BFF, API gateway, Strangler, circuit breaker, externalized configuration, and consumer‑driven contract testing—providing concrete examples, pros, cons, and technology recommendations.
The article explains PHP’s decbin() function, detailing its purpose of converting a decimal integer (0‑4294967295) to a 32‑bit binary string, describing its parameter and return value, and providing a complete code example with expected output.
This article explains how mistakenly using the == operator for Java object comparison, especially with enums and boxed types, can cause runtime failures after framework changes, and also shows how unchecked log growth can fill disks, degrade performance, and how to resolve both issues.
This article explains how to design a unified API response format in a Spring backend by defining a JSON result structure, using standardized status codes, creating a @ResponseResult annotation, and implementing interceptors and ResponseBodyAdvice to automatically wrap controller outputs for cleaner, more maintainable code.
This article explains how to modify a Java search API and write custom performance‑testing scripts that embed unique request marks, enabling precise measurement of each request's response time when header‑based marking is unavailable.
This article explains PHP’s ceil() function, describing how it rounds a floating‑point number up to the smallest integer not less than the given value, details its parameter and return type, and provides example code with expected outputs.
The libp2p‑rs update introduces beta‑value termination for Kad‑DHT queries, timeout mechanisms, routing table refresh, node keep‑alive, identify event handling, outbound sub‑stream reuse, query statistics, a debuggable CLI, and adds experimental floodsub, mdns, parallel dialing, Prometheus exporter, and other enhancements.
This article details how Vivo transformed its monolithic v1.0 online‑store into a service‑oriented order system by separating the order module, applying data archiving, caching, read‑write splitting, sharding‑sphere based database sharding, synchronizing MySQL changes to Elasticsearch, handling distributed transactions, and safely migrating to a new database cluster.
This article explains how REST’s coarse‑grained, redundant interfaces hinder front‑end efficiency, then introduces GraphQL as a flexible, declarative alternative that automatically adapts to changing data requirements, reduces API proliferation, and streamlines backend‑frontend communication.
This article explains how Spring transaction management works, details its declarative and programmatic integration methods, examines core implementation classes and AOP proxies, and highlights frequent pitfalls such as ineffective transactions, rollback failures, and timeout issues, providing code examples and solutions for Java backend developers.
This article explains the Same Origin Policy, introduces the CORS standard, details simple and preflight request handling, lists essential response headers, and provides three practical Spring Boot solutions—including global configuration, a servlet filter, and the @CrossOrigin annotation—to resolve cross‑origin issues.
This article explains how to protect front‑end/back‑end separated interfaces by designing an API signature scheme that includes appId, appSecret, timestamp, nonce and signature, detailing the generation process, request validation, anti‑replay measures and implementation using a custom filter in Java.
This article explains how the PHP bindec() function converts binary strings to their decimal equivalents, describes its parameters and return values, and provides example code with expected output for developers working on backend applications.
The article introduces three single sign‑on mechanisms—stateless HTTP, session‑based, and login state—and compares three practical implementations: using a parent‑domain cookie, deploying an authentication centre, and sharing tokens via LocalStorage with iframe and postMessage, providing code examples and diagrams.
This article demonstrates how to replace cumbersome if‑else or switch statements in Java backend receipt processing by applying the Strategy pattern with a Map dictionary, a simple factory, and the Chain of Responsibility pattern, while also showing reflective class loading for extensibility.
This tutorial demonstrates how to build a Spring Boot Maven project that fetches random sentences from an online API, configures JavaMail with POP3/SMTP credentials, and uses a scheduled task to automatically send emails, including deployment tips for Linux and Windows.
A detailed post explains how a mis‑configured HttpClient caused thread explosion and OOM on four servers, walks through the investigation using APM metrics, clarifies keep‑alive mechanics, and presents the fix of using a singleton HttpClient with proper connection eviction.
This article explains RabbitMQ’s origins, core components, message publishing and consumption patterns, routing modes, persistence mechanisms, delivery guarantees, RPC support, clustering and mirrored‑queue designs, as well as its flow‑control strategy, providing a comprehensive overview for backend developers.
This article introduces mock testing for Spring MVC controllers, explains why mocks are useful, describes the main MockMvc components, shows required Maven dependencies, and provides complete example test cases for both view‑returning and JSON‑returning endpoints using JUnit and MockMvc.
This compilation presents Qunar's 2020 technical articles covering domain‑driven design, API standardization, backend services, Linux I/O, Redis distributed locks, GraphQL, JVM internals, and performance optimizations, offering detailed insights and practical guidance for engineers seeking to improve system architecture and operational efficiency.
This article traces the evolution of software architecture from monolithic to microservice models, explains the motivations behind each stage, and enumerates the essential technologies—including service communication, API gateways, authentication, logging, containerization, orchestration, and CI/CD—that enable modern cloud‑native microservice systems.
This article explains the concept of streaming queries in MyBatis, describes the Cursor interface and its methods, demonstrates common pitfalls that cause cursor closure errors, and provides three practical solutions—using SqlSessionFactory, TransactionTemplate, or @Transactional—to keep the database connection open during iteration.
This article walks through three progressively better implementations for a complex e‑commerce search API—starting with a monolithic SQL query, then splitting the query and adding indexes, and finally using Redis sets and sorted sets to cache filter results, handle pagination, and achieve production‑grade performance.
This article explains the concepts of streaming output and reactive programming, describes the underlying HTTP chunked transfer, SSE, WebSocket and RSocket protocols, provides code examples, and outlines practical scenarios where end‑to‑end streaming improves performance and user experience.
The article explains PHP’s atanh() function, which computes the inverse hyperbolic tangent of a float argument, detailing its signature, parameter, return value, and providing sample code with expected outputs for various inputs.
This article explains how Tengine logs request timing, why the server‑side request_time_msec can appear short while clients experience longer delays, and provides practical methods to analyze access_log entries, understand upload/download latency differences, minimum download speeds, and special status codes such as 400, 408, and 499.
A seasoned backend tech manager shares his journey from .NET to Java, exposing common interview traps—from misleading resumes and weak fundamentals to fierce market competition—and offers practical advice to help developers navigate career transitions successfully.
This article demonstrates how to replace cumbersome if‑else statements with a clean, extensible design using an abstract rule class, concrete channel implementations, and an enum that binds channel identifiers to their processing logic, thereby adhering to the open‑closed principle.
This article explains why REST APIs have become cumbersome, introduces GraphQL as a more flexible alternative, describes its core concepts such as schema, types and modifiers, and outlines various server‑side and client‑side integration patterns and tooling options.
This article explains PHP’s atan2() function, detailing its signature, parameter meanings, return value, and provides multiple code examples that demonstrate how different x‑and y‑coordinate pairs produce specific radian results, helping developers correctly compute angles in backend applications.
This article presents an interview scenario where a candidate is asked about Redis cache avalanche, explains the phenomenon, and offers four practical mitigation strategies—including cache pre‑warming, mutex locking, staggered expiration, and high‑availability designs—to keep backend databases from being overwhelmed.
In this detailed case study, a team describes how they successfully refactored a 30,000‑line advertising engine within a month, covering the system's legacy challenges, preparation steps, execution tactics, testing strategies, and the seven critical takeaways that ensured a smooth, low‑risk rollout.
The PHP asinh() function returns the inverse hyperbolic sine of a given float argument, with a simple signature, description of its single parameter, return value, and example code demonstrating its usage and output values.
This article provides a comprehensive overview of RabbitMQ, covering AMQP core concepts, exchange and queue types, message reliability techniques such as confirms and returns, consumer flow‑control, TTL and dead‑letter handling, as well as clustering, federation, and HAProxy/Keepalived high‑availability solutions.
This article provides a comprehensive guide to the Spring framework, covering its core modules, the concepts of Inversion of Control and Aspect‑Oriented Programming, various container implementations, proxy mechanisms, bean lifecycle, design patterns, MVC architecture, Spring Boot, Spring Cloud, and common annotations for Java backend development.
This article walks backend developers through the challenges of implementing a multi‑criteria search interface, demonstrates three progressive solutions—from a monolithic SQL query to indexed sub‑queries and finally a Redis‑based caching strategy—while addressing performance, pagination, and data‑update concerns.
This article explains how Spring resolves circular dependencies for singleton beans using a three‑level cache, contrasts it with prototype limitations, provides a minimal container implementation that mimics the mechanism, and draws an analogy to the classic two‑sum algorithm to illustrate the core caching principle.
This article explains how to standardize backend API responses by defining a JSON result structure, categorizing status codes, and using a custom @ResponseResult annotation with Spring's ResponseBodyAdvice to automatically wrap controller outputs, improving readability and error handling for front‑end developers.
This article explains the PHP acosh() function, describing its purpose, parameter and return value, and provides example code demonstrating how to compute the inverse hyperbolic cosine of various numbers with the resulting outputs.
The article explains how the rapid growth of API endpoints and data fields in complex business scenarios can be mitigated by introducing a GraphQL middle‑layer built with Node.js, detailing schema design, resolvers, performance considerations, tooling, custom scalars, response formatting, caching, and security measures.
This article compares three Nacos cluster deployment patterns—direct connection, VIP (Virtual IP), and address server—detailing their configurations, advantages, and trade‑offs for high availability, scalability, and operational complexity in production environments.
The PHP acos() function returns the arccosine of a given float argument in radians, detailing its signature, parameter description, return value, and providing example code with expected outputs for various inputs.
This article explains common Redis cache problems—penetration, breakdown, and avalanche—detailing their causes, practical mitigation techniques such as request validation, caching empty results, Bloom filters, mutex locks, high‑availability setups, and provides Java code examples for implementing these solutions.
This article explains PHP's abs() function, describing its numeric parameter, the type‑preserving return of the absolute value, and provides clear example code demonstrating usage with both integer and float inputs.
The article explains PHP's usort() function, detailing its purpose, parameters, return values, and providing a complete example with code and output to demonstrate how to sort an array using a custom comparison callback.
This guide shows how to install the Python requests library and use it to perform GET and POST HTTP requests, explaining required parameters, headers, and providing complete code examples for calling remote APIs.
The article explains PHP's uksort() function, which sorts an array by its keys using a custom comparison function, details its signature, parameters, return values, provides a complete example with code and shows the resulting output after reordering the keys.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, illustrates each problem with real‑world analogies, and presents practical mitigation techniques such as null caching, Bloom filters, mutex locks, asynchronous refresh, varied TTLs, and clustering to ensure robust backend performance.
An in‑depth look at the latest Java Top‑200 project rankings reveals Spring’s ecosystem as the de‑facto standard, while contrasting tools such as Gradle versus Maven, Kafka versus Pulsar, Spring Security versus Shiro, and many others, highlighting performance, adoption and community strength across the backend landscape.
This article explains PHP's uasort() function, detailing its purpose of sorting associative arrays while preserving keys, describing its parameters, providing a custom comparison function example, and demonstrating the resulting sorted array output.
An in‑depth comparison of Python and PHP evaluates performance, complexity, flexibility, security, frameworks, and community support, helping developers decide which language better suits their web development projects based on project requirements, scalability, and ecosystem strengths.
This article breaks down Kafka’s network communication layer, detailing the roles of SocketServer, the Acceptor thread, Processor threads, and related classes such as RequestChannel, KafkaRequestHandlerPool, and key configuration parameters, while illustrating their interactions with diagrams.
This guide walks through practical Nginx optimizations—including custom 404 error pages, enabling and reading the stub_status page, increasing worker processes and connections, expanding header buffers, and configuring client-side caching for static assets—complete with command‑line examples and configuration snippets.
This article shares a senior architect’s decade‑long journey with caching, covering page‑level and object caches, refresh mechanisms, distributed solutions like Redis and Memcached, pagination caching techniques, and multi‑level cache architectures, while highlighting practical pitfalls and performance gains.
This article explains the PHP sort() function, its signature, optional sorting flags, parameters, return values, and provides a complete example demonstrating how to sort an array of strings in ascending order and display the sorted results.
The article explains how to replace a traditional Spring MVC‑based REST RPC framework with a transparent RPC model by extending DispatcherServlet, HandlerMapping, and HandlerAdapter, providing implicit service contracts, simplified client interfaces, and code examples for registration and request handling.
This article explains the PHP shuffle() function, describing its purpose of randomly reordering array elements, the required array parameter, the boolean return value, and provides a complete example with sample output to illustrate its usage.
This article dissects MyBatis 3.5.5’s internal workflow, explaining how mapper interfaces bind to XML files, the step‑by‑step SQL execution process, custom typeHandler creation for parameter and result mapping, and the underlying proxy and configuration mechanisms that drive query handling.
This article describes Qunar's comprehensive API standardization effort, detailing the evolution of their API tools, the motivations behind adopting DDD and API governance, the theoretical foundations, the QDoc annotation framework, implementation steps, challenges faced, achieved outcomes, and future plans for continuous improvement.
This article explains how to design a consistent JSON response format for micro‑service APIs, introduces a Result wrapper class with status code, message and data, and shows how to use a custom @ResponseResult annotation together with Spring's ResponseBodyAdvice to automatically wrap controller outputs while addressing common pitfalls and optimization opportunities.
This article explains the concepts of cache penetration, cache breakdown, and cache avalanche in Redis, presents common mitigation techniques such as request validation, empty‑value caching, Bloom filters, mutex locks, and high‑availability strategies, and includes Java code examples for practical implementation.
This article explains the concepts and practical implementations of distributed locks, comparing local JVM locks with Redis‑based locks (including atomic SETNX/SETEX and Lua scripts), Redisson's high‑level API, and Zookeeper's sequential‑node approach, and provides Java code examples for each solution.
The PHP range() function generates an array of sequential values based on a start, end, and optional step, allowing numeric and character sequences, with examples demonstrating default steps, custom steps, and reverse ordering.
The PHP prev() function moves an array’s internal pointer one step backward, returning the previous element’s value or FALSE when no more elements exist, and is demonstrated with a complete example showing how to iterate and retrieve values using prev, next, and current.
This article explains how Netty's boss and worker NioEventLoop threads collaborate to accept socket connections, register selectors, and transition to read operations, detailing the underlying selector polling, OP_ACCEPT handling, and the code paths that trigger channel activation.
This article explains how to install and use the Arthas Java diagnostic tool to perform hot‑code updates in the dble middleware, covering environment preparation, decompiling classes, modifying source, recompiling with memory‑compile, and applying the changes via both interactive and non‑interactive commands.
This article walks through the design and implementation of a custom JsonPath validation library using Groovy operator overloading, detailing the core enums, verification bean, arithmetic handling, and practical demo code, while providing repository links for Gitee and GitHub.
The PHP next() function moves an array's internal pointer forward by one position, returning the value of the next element or FALSE when no more elements exist, and is demonstrated with sample code showing how to retrieve successive items from an array.
The article examines two ways to define Feign interfaces in a microservice architecture—having the service producer define the Feign client (SPI) versus letting the service consumer define it (API)—and compares their constraints, flexibility, dependency management, and impact on development workflow.
The article details WeChat’s three‑in‑one strategy of precise product, agile projects, and robust technical support, explaining how the team achieves massive scalability, high availability, extensible protocols, resilient disaster recovery, and embedded monitoring through practices like small‑system‑big‑scale, gray‑release, and foundational components.
Spring Cloud 2020.0 GA launched on December 22, 2020, aligning with Spring Boot 2.4.1 and introducing numerous module updates, configuration changes, and dependency version upgrades, while deprecating outdated components and offering guidance for a smooth migration.
This article explains PHP's natsort() function, which performs natural order sorting on arrays while preserving key/value associations, describes its parameters and return values, and provides a complete example comparing standard sorting with natural sorting to illustrate the differences in output.
This article explains the PHP natcasesort() function, which performs a case‑insensitive natural order sort on arrays while preserving key/value associations, details its parameters and return value, and provides a complete example with code and expected output.
This article introduces the highly starred ‘developer‑roadmap’ repository, outlines its comprehensive learning paths—including frontend, backend, DevOps, Android, React, and PostgreSQL DBA—and provides a detailed breakdown of the backend learning roadmap, encouraging readers to use it as a key reference for their backend career development.
This article explains how Netty creates and uses the main thread, boss thread, and worker threads through NioEventLoopGroup and selectors, detailing the initialization of ServerSocketChannel, event registration, and the transition from OP_ACCEPT registration to active listening.
This article discusses common null‑value pitfalls in Java services, compares returning null collections versus empty collections, introduces the Null‑Object pattern and JDK 8/Guava Optional, and provides practical guidelines using JSR‑303/JSR‑305 annotations to make APIs safer and more expressive.
This tutorial explains how to configure a WeChat public account, set up a Spring Boot backend with the wechat-spring-boot-starter, implement GET and POST endpoints for message verification and handling, and integrate an image‑moderation service to automatically reply to picture messages.
This article explains why short URLs are used in SMS and other platforms, outlines their benefits, describes the basic workflow of mapping long URLs to short ones, and dives into backend design choices such as incremental ID generation, storage strategies, caching, batch allocation, and distributed generation using Redis and Java.
This article presents a performance comparison of Dubbo 2, Dubbo 3 interface‑level, and Dubbo 3 application‑level address discovery models under a million‑instance scenario, showing significant reductions in memory usage and GC frequency for the newer models.
This article explains the PHP list() language construct, its syntax and return value, and provides detailed examples showing how to unpack array elements into variables, handle partial assignments, skip elements, and demonstrates that list() cannot operate on strings.
Super‑Jacoco is a one‑stop Java code‑coverage platform built on JaCoCo and Git that non‑intrusively gathers both full‑stack and incremental (diff) coverage for unit and manual tests, visualizes results, scales across distributed nodes, and provides REST APIs for triggering and retrieving coverage data.
The article demonstrates how to replace cumbersome if‑else statements with a clean enum‑based design in Java, showing abstract rule classes, concrete channel implementations, and a matching method that adheres to the Open‑Closed Principle for scalable data processing across multiple channels.
This article explains how to generate URLs in Laravel using the url helper, retrieve the current or full URL, work with request methods, create named route URLs with parameters, and obtain controller URLs via the action function, providing code examples for each case.
This article explains how to integrate MyBatis Generator into a Spring Boot project, configure it to generate entity classes, mapper XML and CRUD methods, and extend its capabilities with custom comment generators, advanced queries, and one‑to‑many/one‑to‑one mappings, reducing manual coding effort.
This article presents thirteen practical Redis performance‑optimization rules—covering command complexity, key expiration, data structures, persistence, hardware choices, clustering, memory fragmentation, and client‑side techniques—to help developers identify bottlenecks and boost throughput and latency in production environments.
This article explains the PHP ksort() function, which sorts an associative array by its keys while preserving key‑value relationships, describes its parameters and return values, and provides a complete example with code and expected output.
This tutorial walks through configuring a WeChat public account, setting up a Spring Boot backend with the wechat‑spring‑boot‑starter, implementing verification and message‑receiving endpoints, handling image messages, and adding content‑moderation logic to create a functional subscription‑account robot.
