This article demonstrates how to invoke external services from a Spring Boot application by using raw HttpClient, the RestTemplate utility, and Feign client, providing complete code examples, configuration steps, and tips for handling headers and tokens.
The phpBB forum software released version 3.3.11 on October 22, raising the minimum PHP requirement to 7.2 for better PHP 8 compatibility, adding search index progress bars, improving deprecated function handling, and strengthening security with CAPTCHA attempt limits.
This tutorial explains how to build a PHP‑based ChatGPT chatbot, covering environment setup, API key acquisition, library installation, core code implementation, a simple web interface, and steps to run and extend the application.
To overcome storage, compute, and I/O bottlenecks in Bilibili’s risk‑control engine, the team combined pre‑fetching with Redis caching, batch retrieval, asynchronous writes via Railgun, aggressive log compression, and a multi‑level cache plus Bloom filter, cutting latency to sub‑100 ms, reducing Redis QPS by over 90 % and storage by ~38 %, while supporting million‑level query throughput.
The article explains the architecture of an online advertising system, detailing the roles of ad placement and playback, the design of coarse ranking modules, budget pacing mechanisms, and pricing algorithms that aim to maximize ROI while controlling costs.
This article explains the importance of timezones in PHP date and time processing, demonstrates how to use date_default_timezone_get() and date_default_timezone_set() with code examples, and outlines practical scenarios for retrieving and managing the default timezone.
This article explains Java's Error and Exception hierarchy, differentiates compile-time and runtime exceptions, demonstrates standard try‑catch handling, shows how to throw custom exceptions, and introduces custom assertion interfaces that combine readable assertions with tailored exception types for cleaner backend code.
This article explains PHP 8’s new Attributes feature, describing what attributes are, how to attach custom attributes such as @Table and @Route to classes and methods, and demonstrates retrieving attribute values via reflection, providing clear code examples for backend developers.
This article explains the thundering herd effect, walks through Nginx's master‑worker architecture and its use of epoll, and compares three practical solutions—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—to eliminate wasted wake‑ups in high‑concurrency servers.
This article explains how to extract a particular key from each JSON object in a list, optionally filter out unwanted entries, and download images from URLs using Python's requests and os modules, providing complete example code for both tasks.
This article explains why excessive try‑catch blocks hurt readability, introduces Spring's @ControllerAdvice and custom Assert utilities combined with enums to create a clean, centralized exception handling framework, and demonstrates the approach with full code examples and practical test scenarios.
Rate limiting controls request flow to protect system stability, covering its definition, motivations, common algorithms such as token bucket, leaky bucket, fixed and sliding windows, their pros and cons, single‑machine vs distributed implementations, and practical component choices for backend services.
This article introduces PHP 8’s new Stringable interface, explains its purpose, shows how to implement it with example code, and demonstrates its seamless integration with common string functions such as str_replace, strlen, and substr for more concise string handling.
This article explains the thundering herd phenomenon in multi‑process servers, walks through Nginx’s master‑worker architecture and its use of epoll, and compares three practical mitigation techniques—accept_mutex, EPOLLEXCLUSIVE, and SO_REUSEPORT—complete with code excerpts and configuration examples.
This tutorial provides an in‑depth guide to Spring Boot covering core concepts such as project setup, configuration files, logging frameworks, MVC architecture, CRUD examples, error handling, embedded servlet containers, Docker integration, JDBC/MyBatis/JPA data access, startup process, and how to create custom starter modules.
This article introduces a simplified Seckill (flash‑sale) system built with SpringBoot, detailing its overall architecture, key backend techniques such as distributed sessions, Redis caching, RabbitMQ asynchronous ordering, security measures, oversell prevention, rate limiting, and provides essential code snippets and deployment screenshots.
This guide explains the distinction between exceptions and errors in PHP, shows how to install the Tinywan exception‑handler package, configure it for Webman, use built‑in and custom exception classes, customize JSON responses, and extend the handler for advanced scenarios such as DingTalk notifications.
This article explores multiple strategies for enabling fuzzy search on encrypted phone numbers, including in‑memory caching, database decryption functions, segment‑wise storage, and dedicated fuzzy‑search fields, comparing their trade‑offs in performance, memory usage, and data consistency.
This article explains the fundamentals and types of MySQL indexes, provides guidelines for selecting appropriate indexes based on query frequency, uniqueness and complexity, and presents PHP code examples for adding and using indexes, along with optimization strategies such as proper schema design, data types, and index maintenance.
This guide explains the concepts of ZooKeeper cluster roles and provides step‑by‑step instructions, including configuration file edits and command‑line operations, to set up a pseudo‑cluster on a single machine for testing and learning purposes.
The article examines various delayed‑task solutions for order timeout handling in Java, including database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted‑set and key‑space notifications, and RabbitMQ delayed queues, analyzing their implementation steps, advantages, and drawbacks.
This article demonstrates how to implement a statistical query on a student_score table using three ORM frameworks—Fluent Mybatis, native Mybatis, and Mybatis‑Plus—showing code examples, configuration steps, and a side‑by‑side comparison of their ease of use and generated code.
This article explains how to use Redis BitMap to build a memory‑efficient sign‑in feature and continuous‑sign‑in statistics in a Spring Boot microservice, covering basic BitMap commands, key design, core Java code, testing steps, and a bitmap‑based solution for cache‑penetration protection.
The article recounts a developer's painful experience with un‑preheated Redis cache that caused severe latency spikes, then outlines practical cache warm‑up techniques such as gray‑release traffic, database scanning, and ETL‑driven data pipelines to prevent performance degradation and cache snowball effects.
This article explains Java annotations, their purposes such as providing compiler metadata, generating code, runtime processing, and documentation, introduces built‑in and meta‑annotations, and demonstrates how to create and use custom annotations both via reflection and with Spring AOP for logging, including full code examples.
This article explains why upgrading from JDK 8 to JDK 11 is worthwhile, details performance gains, new language and API features, garbage‑collector improvements, modularization concepts, step‑by‑step migration procedures, common pitfalls, and practical verification methods.
This article reviews the most important PHP 8.3 enhancements—including typed class constants, dynamic class constant access, a native json_validate() function, improved unserialize() error handling, read‑only property cloning support, and typed constants—showing code examples and practical usage tips.
This article explains what logs are, why they are crucial for debugging, monitoring and auditing, when to record them, the fundamental principles and level conventions, and provides concrete best‑practice recommendations and code examples to help Java developers implement robust, secure, and efficient logging.
The article explains why high‑frequency disk reads can become a performance bottleneck, introduces common caching patterns such as Cache‑Aside, Read‑Through, Write‑Through and Write‑Behind, discusses consistency problems, cache penetration and avalanche, and presents practical solutions like null‑caching, Bloom filters, distributed locks, staggered TTLs, Redis‑Cluster and Hystrix.
This article provides a comprehensive overview of Spring Framework utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AopUtils—explaining their purpose, key methods, and usage examples with code snippets for backend developers.
This article examines the evolution of Trip.com’s ticket product structure, detailing its transition from low to high‑level schema, the technical challenges faced across user, merchant, platform and R&D perspectives, and the systematic solutions—including structure integration, sales‑attribute standardization, and description‑attribute layering—that improved efficiency, data quality, and internationalization.
This article explains what ZooKeeper is, describes its data model and four znode types, introduces the watch mechanism, and provides step‑by‑step commands for installing ZooKeeper, creating nodes, and verifying the service on a Java‑enabled machine.
This article explains how Volcano Engine identified the tangled authorization, data‑fetching, and performance problems of its advertising AB‑testing platform and refactored it by splitting services, redesigning the data model with MySQL and ClickHouse, applying DAG scheduling, time‑wheel algorithms, Domain‑Driven Design, and rigorous unit testing to achieve a more stable, extensible backend solution.
This tutorial demonstrates how to use Redis' GEO data structure together with Docker, RedisInsight, and a NestJS backend to store location data, perform distance calculations and radius searches, and finally display nearby points on a web map using AMap and Axios.
This article explains the fundamental asynchronous messaging patterns, compares RabbitMQ and Apache Kafka in terms of architecture, queue and pub/sub models, and provides guidance on selecting the appropriate technology for different backend scenarios.
This article compares Java-WebSocket and Netty-WebSocket implementations by examining their thread models, running single‑connection and high‑connection benchmarks (including a Go WebSocket server), and summarizing the performance and resource‑usage differences observed.
This article presents a complete Netty TCP long‑connection demo built with Spring Boot 2.2.0 and Redis, explains the project architecture, module layout, business flow using a local BlockingQueue instead of RocketMQ, and provides detailed source code for the queue holder, processing logic, client implementation, handler, and test controllers.
This article outlines the goals, evolutionary stages, functional and non‑functional requirements, and detailed component design of a unified enterprise notification system that supports multiple channels, high performance, scalability, and seamless integration for modern distributed applications.
This article details how to dramatically improve the performance of a million‑level QPS Java service by reusing a singleton HttpClient, enabling keep‑alive connection pooling, and handling responses efficiently, cutting average request time from 250 ms to about 80 ms.
This article explains why rate limiting is essential for high‑traffic Java services, compares common strategies such as Hystrix, Sentinel, token‑bucket algorithms, and Redis‑based counters, and provides concrete Spring‑Boot code examples for implementing both local and distributed throttling.
This article demonstrates how to implement a captcha‑based login mechanism in a Spring Boot application with a front‑end/back‑end separation, detailing the traditional session‑based approach, the new Redis‑backed token solution, and providing complete code examples for configuration, service, controller, and data objects.
This article presents a self‑developed automated testing platform for backend services that achieves full test‑case coverage with low maintenance cost by unifying HTTP and RPC access, introducing a parameter‑pool, integrating JSON Schema and JSONPath validation, and leveraging traffic‑driven test‑case generation and scheduling.
This article explains the various scheduled tasks in RocketMQ, covering architecture overview, producer and consumer periodic operations, broker maintenance jobs, and NameServer housekeeping, while providing concrete Java code examples to illustrate how each task contributes to message handling, monitoring, and system reliability.
This article explains the concept, advantages, and drawbacks of request merging, and provides a complete Java implementation using ScheduledExecutorService, a memory queue, and generic batch handling interfaces, along with usage examples and sample code.
This article explains the initialization order of Java classes, the pitfalls of using @Autowired for dependency injection, compares it with @Resource, and demonstrates setter, constructor, and Lombok-based injection methods with code examples to help avoid null‑pointer exceptions and improve coupling.
This article explains why MySQL LIKE queries struggle with large datasets, introduces Elasticsearch and Sphinx as powerful PHP search engine alternatives, and provides step‑by‑step PHP code examples for setting up indices, adding documents, and performing full‑text searches.
This article explains how Nginx's ip_hash directive implements session affinity by routing all requests from the same client IP to a single backend server, demonstrates configuration examples, analyzes behavior when servers go down, and discusses the method's limitations such as load imbalance and dynamic IP issues.
This article introduces several widely used PHP web frameworks—ThinkPHP, Laravel, Yii, CodeIgniter, Webman, and Hyperf—detailing their design philosophies, key features, performance characteristics, and typical use cases for modern backend development.
This article explains how to dramatically improve the performance of a high‑traffic Java service by reusing a singleton HttpClient, enabling connection pooling and keep‑alive, tuning timeout and retry settings, and adding an idle‑connection monitor to reduce average request latency from 250 ms to about 80 ms.
This article explains the fundamentals of database transactions, introduces Spring's @Transactional annotation, and enumerates nine typical situations—such as incorrect method visibility, final methods, self‑invocation, unmanaged beans, multithreading, wrong propagation, swallowed exceptions, unsupported exception types, and non‑transactional storage engines—where transactions may not work as expected, offering guidance to prevent these pitfalls.
This article demonstrates two PHP approaches—manual looping and functional array utilities—to group and count records in a two‑dimensional array based on identical name and age fields, showing the full source code and expected output.
This article explains the fundamentals of finite state machines, illustrates their concepts and diagramming, and provides a comprehensive guide on using Spring Statemachine in Java—including schema design, configuration, event handling, persistence strategies, testing, and common pitfalls with solutions.
This article explains how to design and implement a basic online recruitment platform using PHP, covering requirement analysis, system architecture, database schema, front‑end layout, back‑end logic, and provides a complete code example for user registration, illustrating the core functionalities of such a system.
This article details the architectural evolution, high‑availability strategies, fault‑monitoring mechanisms, and performance optimizations of AutoHome's enterprise SMS platform, covering its migration from .Net to Java, service decomposition with Kafka, multi‑datacenter deployment, and operational safeguards for large‑scale events.
This article provides a detailed overview of Spring MVC and Spring Boot annotations such as @RequestMapping, @GetMapping, @PostMapping, @RequestBody, @ControllerAdvice, @Component, @Bean, @Scope, @Autowired, and others, explaining their purposes, attributes, usage patterns, and offering practical code examples for each.
This article demonstrates how to implement a statistical query on a student_score table—calculating count, min, max, and average scores per term and subject—using Fluent Mybatis, native Mybatis, and Mybatis‑Plus, compares their code complexity, and provides code generation settings for each framework.
This article explains why long if‑else chains in Java OOP are problematic and demonstrates how to use a strategy enum to encapsulate conditional logic, improving readability, extensibility, and reducing boilerplate code in backend applications.
This article explains how to create a basic PHP-based question‑and‑answer web application, covering functional requirements, environment setup, MySQL schema design, and providing complete code snippets for user registration, login, posting, answering, listing, and searching questions.
This article explains how to achieve session affinity using Nginx's ip_hash directive, covering the concept, configuration syntax, practical examples, common pitfalls, and test results for handling client IP‑based load balancing across backend servers.
A Java date‑formatting bug occurs when the week‑based year pattern 'YYYY' is used instead of the calendar year 'yyyy', causing dates near year‑end to display the next year, and this article explains the cause, demonstrates it with code, and shows how to avoid it.
The article explains the concept of idempotency, its significance in preventing duplicate operations such as double payments, and outlines various backend techniques—including MVCC, deduplication tables, token mechanisms, and distributed locks—to ensure consistent system behavior across retries and network failures.
This article demonstrates how to implement a data merging feature by creating MySQL tables, building a PHP API that retrieves and combines records from two tables, and developing a Vue.js front‑end that fetches and displays the merged data, complete with full code examples.
This article explains how to replace repetitive try‑catch blocks with a unified exception handling framework in Spring Boot, using @ControllerAdvice, custom Assert utilities, and enum‑based error codes, while showing concrete code examples, configuration steps, and runtime results.
This article explains how to use the SOLID design principles—SRP, OCP, LSP, ISP, and DIP—in PHP, providing clear bad and good code examples for each principle to help developers write more reliable, extensible, and maintainable backend applications.
This guide introduces a curated list of ready-to-use website generators—including Mall, WordPress, Docsify, Dumi, Img Cook, Ant Design Landing, Tencent Rabbit Nest, Baidu Analytics, One Nav, Discuz, and popular admin templates—showcasing their key features, deployment methods, and how they enable rapid site creation without deep coding.
This article introduces Python's ConfigObj library for parsing INI files, demonstrating how to read configuration values, write new settings, update existing entries, handle multiple files, and dynamically generate sections and options, with five practical code examples for interface automation tasks.
This article explains how Java's try‑catch and throw statements affect the execution of subsequent code, detailing six different scenarios to show which lines run, which are skipped, and how finally blocks can change the outcome.
This article provides a comprehensive overview of API gateways, covering their basic concepts, design considerations, key features such as routing, load balancing, resilience and security, and compares popular implementations like OpenResty, Kong, Zuul, and Spring Cloud Gateway.
This article reviews the leading PHP frameworks expected to thrive in 2023, including Laravel, Symfony, CodeIgniter, Laminas, Yii, Phalcon, CakePHP, Slim, and others, helping developers choose the most suitable backend solution based on project size, performance needs, and team expertise.
The article details the comprehensive redesign of QQ Browser's content ingestion platform, highlighting the shortcomings of the legacy micro‑service architecture, the migration to a single‑process monolithic design with a plugin framework, fault‑tolerant Kafka integration, thread separation, memory‑allocator improvements, and the resulting dramatic gains in throughput, latency, CPU utilization, and development efficiency.
This article introduces Spring 6's new HTTP Interface feature, walks through building a Spring Boot demo with a User entity, a controller, an HTTP Interface annotated with @GetExchange, and a test using WebClient and HttpServiceProxyFactory, and explains related annotations and reactive dependencies.
This article explores the challenges of designing a flash‑sale (秒杀) system—such as overselling, high concurrency, URL protection, and database bottlenecks—and presents a comprehensive backend architecture using Redis clustering, dynamic URLs, static pages, Nginx, rate‑limiting, asynchronous order processing, and service degradation strategies, complete with code examples.
This tutorial explains how to use PHP to connect to Midjourney's AI painting API, covering preparation, request construction, cURL transmission, response handling, and a complete example that enables developers to generate and manage AI‑created artwork.
The article traces the historical development of backend architectural styles—from early N‑layered designs through Domain‑Driven Design, Hexagonal (Ports and Adapters), Onion, and finally Clean Architecture—explaining their motivations, key principles, layer responsibilities, and practical trade‑offs for modern developers.
This guide walks through creating a Rust project that uses the Tonic library to implement gRPC streaming, covering project setup, protobuf definitions, server and client code, testing with grpcurl, and enabling the reflection API for service introspection.
This article provides a step‑by‑step guide for backend developers to replace Shiro with jCasbin in a Spring Boot application, covering Maven dependencies, configuration files, Enforcer initialization, custom filter implementation, and runtime permission add/remove APIs, all with complete code examples.
This article explains how Tomcat starts by running the startup script, invoking the BootStrap main method, initializing Catalina, loading configuration, and managing component lifecycles through the Lifecycle interface, while also detailing default implementations, endpoint types, and protocol handlers.
This article documents a comprehensive migration from JDK 8 to JDK 17, detailing new language and JVM features, step‑by‑step upgrade procedures, Maven and SpringBoot version changes, performance benchmarking, and ZGC‑based garbage‑collection tuning to dramatically reduce pause times.
This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling mechanism that leverages @ControllerAdvice, custom Assert utilities, enum‑based error codes, and standardized response objects to improve code readability, maintainability, and internationalization.
This article introduces three advanced PHP features—Closures, Generators, and Reflection—explaining their concepts, advantages, and providing detailed code examples that demonstrate how closures enable access to outer scope variables, generators reduce memory usage by yielding data lazily, and reflection allows runtime inspection and modification of classes and methods.
This article provides an in‑depth overview of the most frequently used Spring Boot annotations, categorizing them into Spring MVC, Spring Data JPA, Spring Security, and other essential annotations, and demonstrates their practical usage with concise examples.
This article introduces microservices as a lightweight, autonomous architecture, compares it with monolithic and SOA approaches, outlines the complexities it brings, and reviews the most common open‑source solutions, registration and configuration centers, remote‑call mechanisms, resilience patterns, load‑balancing algorithms, tracing, and monitoring tools.
This guide demonstrates how to leverage Spring Cloud Gateway's ProxyExchange utility in both Spring MVC and WebFlux applications, showing code examples for proxying requests, extracting path variables, adding headers, handling responses, and configuring sensitive headers.
From the early days of ActiveMQ and RabbitMQ to the high‑throughput designs of Kafka, RocketMQ, and Pulsar, this article traces the development stages of message queues, explains core concepts such as topics, producers, consumers, and partitions, and compares their architectural and storage designs.
This guide explains how to embed Dataway—a DataQL‑based API configuration tool—into a Spring Boot application, covering dependency setup, property configuration, datasource integration, Hasor module wiring, enabling Hasor, launching the app, accessing the UI, creating and publishing APIs using SQL or DataQL, and verifying the results.
This article introduces Switchquery, a high‑performance mobile configuration platform that achieves second‑level real‑time delivery through a novel architecture involving a CMS, unified gateway, header‑based version signaling, and SDKs for Android and iOS, and demonstrates its optimization, multi‑app support, and successful large‑scale deployment in major promotional events.
The article explains common pitfalls in Java backend interface design, proposes a unified ResultBean response format, outlines controller coding standards, and demonstrates how to use Spring AOP for logging and exception handling, providing complete code examples and configuration snippets.
This article presents a comprehensive case study of Trip.com’s train ticket service global expansion, detailing the business background, challenges such as multi‑region deployment, performance, data compliance and scalability, and the step‑by‑step architectural evolution across region selection, network, data, infrastructure, and business layers to achieve a resilient, low‑latency, and compliant worldwide service.
This article explains why public APIs need protection, outlines anti‑tampering and anti‑replay strategies using timestamps and nonces, and provides complete SpringBoot code—including request signing, filter implementation, and Redis utilities—to safeguard API calls from manipulation and replay attacks.
This article explains why using Redis List for a message queue is limited, introduces Redis Stream as a purpose‑built MQ with consumer groups, ACKs, and persistence, and dives into its internal Radix‑Tree and listpack structures, command usage, and memory‑saving techniques.
This article details the complete redesign of a large‑scale content ingestion platform, explaining why the original microservice‑heavy architecture suffered from low development efficiency and poor performance, how a monolithic‑plus‑plugin approach solved these issues, and the resulting 13‑fold speedup, 10‑fold batch improvement, and 70% latency reduction.
This article breaks down real‑world high‑concurrency strategies—horizontal scaling, caching, Elasticsearch, sharding, message‑queue smoothing, and cellization—explaining when each applies, their trade‑offs, and practical tips for building scalable, reliable backend services.
This article explains how Java 8's Optional class and its methods—of, ofNullable, empty, orElse, orElseGet, orElseThrow, map, flatMap, isPresent, ifPresent, and filter—can replace verbose null‑checks, making code more concise and safer while providing concrete examples and source code.
During a load test of a Java 1.6 application on a CentOS server, memory usage climbed from 20% to 100% after an hour of 300‑concurrent requests, prompting a detailed investigation that identified off‑heap leaks caused by GZIP compression in a JimDB client and led to fixes such as upgrading the JDK and avoiding unnecessary compression.
This article demonstrates practical ways to leverage Java's ShutdownHook API for task statistics, connection cleanup, handling JVM abnormal exits, and persisting state during performance testing, providing code examples, pitfalls of daemon threads, and strategies for reliable resource management in backend applications.
This article demonstrates how to refactor coupon‑type dispatch logic by using the Strategy design pattern and a Map of Java 8 lambda expressions, showing code examples, trade‑offs, and a concise implementation that improves readability and maintainability.
This article explains how to use HTTP Server-Sent Events (SSE) as an alternative to WebSocket for one‑way data push, demonstrating a NestJS backend implementation with @Sse decorator and Observable streams, and a React frontend using EventSource to receive real‑time JSON messages, including handling logs and binary data.
Ximalaya’s cache guidelines define four Redis‑based types (master‑slave, Codis‑Redis, Cloud Database Redis, XCache) with cache or store modes, prescribe using Cloud Redis for clusters and XCache for large KV, enforce short readable keys, TTLs, limited batch sizes, safe commands, isolated clusters, and compression to ensure stability and performance.
The article explains PHP's strtolower() function, detailing its syntax, parameters, return value, and providing multiple code examples—including full string conversion, partial conversion, word-level manipulation, and multibyte handling—while also noting important considerations for case sensitivity and non‑alphabetic characters.
This article explains how to design a classification‑information system that handles 100 billion rows, ten‑thousand dynamic attributes, and hundreds of thousands of QPS by using vertical partitioning, unified metadata services, and an external search layer for scalable storage and retrieval.
