The article details Bilibili’s thumb‑up service architecture, covering required business and platform capabilities, handling high read/write traffic and hot‑spot pressures, a three‑tier storage design using TiDB, Redis cache and local heap cache, disaster‑recovery mechanisms, asynchronous jobs, and future modularization plans.
This article analyzes the overselling problem in high‑concurrency flash‑sale scenarios, demonstrates seven concrete solutions—including improved locks, AOP locks, pessimistic and optimistic database locks, and queue‑based approaches using BlockingQueue and Disruptor—provides full SpringBoot code, JMeter test results, and practical recommendations for reliable stock reduction.
This article examines common business scenarios that require timed execution, introduces single‑machine and distributed scheduling frameworks such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, Elastic‑Job, Saturn and XXL‑Job, and provides a detailed feature‑by‑feature comparison to help choose the most suitable solution.
This guide explains how to install the overtrue/pinyin Composer package and demonstrates various PHP methods for converting Chinese text to pinyin, including tone styles, array output, permalink generation, abbreviation extraction, handling polyphones, and using the command‑line tool.
This article examines the design of a Weibo‑style feed system, detailing storage tables, the trade‑offs between push (write‑fan‑out) and pull (read‑fan‑out) delivery models, their scalability challenges, and hybrid solutions using caching to achieve low latency and manageable storage costs.
The article examines common business scenarios requiring timed actions and reviews both single‑machine and distributed scheduling solutions, detailing frameworks such as Timer, ScheduledExecutorService, Spring, Quartz, TBSchedule, elastic‑job, Saturn and xxl‑job, then provides a side‑by‑side comparison and practical recommendations.
This article explains how to replace tightly‑coupled if‑else or switch‑case logic for selecting file parsers (JSON, CSV, XML) with a Service Locator Pattern using Spring's ServiceLocatorFactoryBean, demonstrating a clean, extensible solution that follows the Open/Closed principle.
This article explains two sliding‑window rate‑limiting methods for SMS sending—one based on IP address and another on phone number—and provides a complete PHP implementation using Redis sorted sets to enforce per‑minute, per‑10‑minute, and per‑hour limits.
This article explains the Java SPI mechanism, demonstrates how to create service interfaces and implementations, shows how to configure META-INF/services and spring.factories files, and compares Java's built‑in SPI with Spring's optimized SPI approach, providing complete code samples and analysis.
This article explains why the default Apache Commons‑Pool2 APIs cannot limit idle objects per key, and demonstrates three practical techniques—scheduled cleanup, factory modification, and priority‑based eviction—to enforce per‑key idle limits in a GenericKeyedObjectPool implementation.
This comprehensive guide walks you through Nginx fundamentals, from installing and configuring load balancing, static asset handling, compression, buffering, caching, IP access control, cross‑origin support, anti‑hotlinking, large file handling, SSL setup, high‑availability with Keepalived, and performance tuning techniques for robust backend services.
This article walks through building a robust Spring Boot controller layer by standardizing parameter binding, status codes, response wrapping, validation, and exception handling using annotations, enums, ResultVo, ResponseBodyAdvice, and custom exception advice to deliver consistent API responses.
This article provides a detailed overview of the essential backend technology stack for startups, covering language choices, components, processes, systems, and cloud services, and offers practical recommendations for selecting databases, messaging, monitoring, CI/CD, and deployment tools to build a robust, scalable infrastructure.
This guide outlines how to prepare for technical interviews by reviewing algorithms, core computer science fundamentals, essential backend technologies such as MySQL, Redis, and Docker, and provides a collection of real interview questions and tips for each interview round.
This article explains why high availability is crucial for backend services and outlines ten practical design principles—including dependency control, avoiding single points, load balancing, isolation, rate limiting, circuit breaking, async processing, degradation, gray release, and chaos engineering—to help developers create resilient APIs.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous vs asynchronous calls, popular RPC frameworks, and when to choose each approach for enterprise applications.
This article outlines fifteen practical techniques—including horizontal scaling, microservice decomposition, database sharding, connection pooling, caching, CDN, message queues, circuit breaking, rate limiting, and load testing—to help engineers design backend systems that remain reliable and performant under extreme traffic spikes.
Spring Boot 3.0.2 is now available from repo.spring.io and Maven Central, bringing 66 bug fixes, numerous dependency upgrades, and no new features, providing developers with a more stable and up‑to‑date backend framework.
This article explains how to start a new project using Domain‑Driven Design, covering terminology, the evolution from SaaS to IaaS, bounded‑context concepts and division rules, the four DDD boundaries, and how clean, hexagonal, and onion architectures realize these principles for scalable backend systems.
This article details the end‑to‑end design and implementation of Baidu App’s personal wallet, covering background, business flow, system architecture, data synchronization, multi‑level caching, read‑write separation, consistency mechanisms, configuration management, and database sharding to achieve high availability for billions of users.
This tutorial demonstrates how to leverage Spring 6’s new HTTP Interface feature to define REST calls as annotated Java interfaces, walks through creating a simple Spring Boot service, shows code for the entity, controller, proxy interface, test method, and explains related annotations and dependencies.
The article investigates a SocketTimeoutException caused by a circular dependency between two SpringBoot microservices, explains how the deadlock occurs, demonstrates a reproducible test setup with Eureka, FeignClient and JMeter, and provides a concrete code‑level fix to break the loop.
This article details the design, bandwidth optimization, and reliability strategies of a custom bullet‑chat system for Southeast Asian live streaming, covering background challenges, problem analysis, compression, request throttling, long‑polling versus WebSocket trade‑offs, and a short‑polling solution that successfully supported 700 k concurrent users.
This article introduces the EasyMock platform, explains its role in providing JSF and HTTP mock services for development and testing, outlines its architecture and capabilities, and details the step‑by‑step technical implementation of JSF Mock including jar downloading, JVM class loading, dynamic proxy creation, registration, client invocation, parameter matching, and response deserialization.
This article explains Java exception handling in depth, covering definitions, classification of errors and exceptions, the key keywords (try, catch, finally, throw, throws), practical code examples for try‑catch, try‑catch‑finally, try‑finally, try‑with‑resources, and a set of best‑practice recommendations for writing robust backend code.
This article explains the purpose, architecture, modules, and detailed design steps of a payment reconciliation system, covering internal and channel reconciliation, data acquisition, file parsing, storage, transaction matching, error handling, and settlement processes for robust backend payment operations.
This article explains the basic concepts of transactions, distinguishes local and distributed transactions, introduces the CAP and BASE theories, and compares major distributed‑transaction solutions such as 2PC, XA, Seata, TCC, reliable‑messaging and maximum‑effort notification, highlighting their trade‑offs.
This article explores strategies for batch scaling Kafka replicas with minimal data migration, presenting two design ideas, detailed calculations of broker lists, partition counts, start indexes, and replica shifts, and provides step‑by‑step algorithms and code snippets to compute optimal replica assignments for both expansion and contraction scenarios.
The article explains how the Backend for Frontend (BFF) pattern creates dedicated, lightweight server‑side APIs for each UI type—desktop web, mobile, or third‑party—allowing teams to tailor functionality, reduce coupling, aggregate micro‑service calls, and improve autonomy while addressing performance, scaling, and organizational concerns.
This article describes the design, challenges, and optimization strategies of a custom live‑streaming danmaku system for Southeast Asian markets, covering bandwidth constraints, latency issues, long‑polling versus WebSocket approaches, service splitting, caching, and a ring‑buffer implementation that supported 700 k concurrent users during a major sales event.
This article introduces PowerJob, a third‑generation distributed task scheduling and computation framework for Java, compares it with Quartz and XXL‑Job, outlines its rich features, shows how to set up the server and worker, and demonstrates creating and running sample jobs.
This article presents a comprehensive analysis of flash‑sale (seckill) business characteristics, technical challenges such as traffic spikes, database overload, and order handling, and offers detailed architectural solutions spanning frontend static pages, CDN caching, request throttling, queue‑based processing, optimistic locking, database sharding, high‑availability designs, and anti‑cheat mechanisms to ensure correctness and scalability under extreme concurrency.
This guide walks through installing Supervisor from source, resolving dependencies, creating configuration files, defining custom program entries, starting the service, reloading configurations, and using supervisorctl to monitor and control processes on a Linux server.
This article explains how to quickly add a secure login page to a simple SpringBoot application using the Sa-Token-Quick-Login plugin, covering Maven dependencies, configuration parameters, controller implementation, and testing steps with code examples.
This article introduces Java 11's built-in HttpClient, compares it with legacy HttpURLConnection and third-party libraries, and provides detailed code examples for creating and configuring HttpRequest objects, sending synchronous and asynchronous requests, handling headers, timeouts, bodies, and demonstrates a custom mica-http wrapper for practical use.
This article details vivo's low‑code platform experience, covering a front‑end/back‑end separated low‑code solution, a self‑built high‑performance rendering engine, efficient visual configuration methods, billion‑scale content delivery, and how low‑code coexists with traditional development to boost productivity and scalability.
This article explains how to use RabbitMQ's delayed message plugin, covering its features, installation on multiple platforms, configuration steps, and complete Java Spring Boot code examples for producing and consuming delayed messages in a backend system.
This guide explains how to integrate the Jersey RESTful framework with Spring Boot, covering its relationship to JAX‑RS, configuration steps, essential annotations, code examples, and advanced customizations such as ResourceConfig, filters, servlets, and application path settings.
The article explains how to improve large file upload experiences by using instant (MD5‑based) upload, chunked upload, and resumable upload techniques, and provides complete Java backend implementations with Redis tracking, RandomAccessFile and MappedByteBuffer, plus practical deployment recommendations.
This article explains why a custom business rate‑limiting (risk‑control) component is needed for AI‑driven services, compares open‑source solutions, and provides a complete implementation using Redis+Lua scripts, Kotlin code, and Spring AOP annotations, including testing and deployment tips.
To support Southeast Asian live streaming with up to a million concurrent users per room, we replaced Tencent Cloud’s inadequate danmaku service with a custom solution that optimizes bandwidth via HTTP compression, response simplification, ordering, frequency control, and a short‑polling delivery mechanism, while ensuring reliability through service splitting, caching, and lock‑free ring buffers.
This article explains why a business needs its own risk‑control (rate‑limit) component, compares open‑source options, and provides a complete Kotlin/Spring implementation using Redis Lua scripts, annotations, and AOP to enforce real‑time adjustable limits.
The article shares a senior architect's insights on why engineers and leaders must perform code reviews, how to avoid common pitfalls such as duplicated code, premature optimization, over‑encapsulation, and lack of design, and provides concrete best‑practice guidelines and Go code examples to improve software quality.
The article explains Baidu's Janus gateway—its motivations, three‑level routing design, variable and condition expression language, plugin implementations for disaster recovery and caching, and performance benchmarks—showing how it supports millions of QPS while remaining flexible and efficient.
The article explains how a sudden Go service memory‑usage alert was traced with go tool pprof to a massive allocation in the quantile.newStream function, uncovered a Prometheus metric‑label explosion caused by the START_POINT label, and resolved the leak by disabling that label, while also reviewing typical Go memory‑leak patterns.
This article examines YouTube’s massive backend infrastructure, detailing how the platform stores billions of videos using MySQL, Vitess for horizontal scaling, sharding, replication, disaster management, cloud‑native deployment on Kubernetes, and the supporting storage systems such as GFS and BigTable.
This article explains four techniques—including manual setting, TaskDecorator, InheritableThreadLocal, and TransmittableThreadLocal—to reliably transfer user context and other thread‑local data from parent to child threads in Spring Boot asynchronous execution, with complete code samples and best‑practice recommendations.
This article explains Java's reflection mechanism, its underlying principles involving the Class object, how to obtain Class instances, provides code examples, outlines common use cases such as dynamic loading, frameworks, and middleware, and concludes with a promotional note for an architecture learning collection.
The article presents a comprehensive guide to software performance optimization, covering time‑space trade‑offs and practical techniques such as indexing, caching, compression, prefetching, load‑shedding, batch processing, parallelism, and hardware‑aware tuning for modern backend systems.
This guide explains how to create an Nginx block file, use AWK to identify IPs that exceed 60 requests per minute, write a shell script to generate deny rules, and schedule the script with crontab to automatically block abusive IPs and return a 403 response.
This article explains the concept of distributed locks, illustrates real‑world scenarios such as concurrent ATM transactions, and details how to implement reliable distributed locking with Redis using TTL keys, SETNX, Lua scripts, lock renewal, high‑availability considerations, and the RedLock algorithm.
This article describes how a data‑architecture team tackled the complexity of a large‑scale telephone‑robot system by adopting Domain‑Driven Design, detailing the challenges faced, the reasons for choosing DDD, the concrete rollout steps, and the resulting improvements in architecture, communication, documentation, and code quality.
This article examines a business requirement to filter up to 100 000 records from a pool of tens of millions, presenting and evaluating four backend solutions—multithreaded ClickHouse pagination, Elasticsearch scroll‑scan, an ES‑HBase hybrid, and RediSearch + RedisJSON—along with performance data and implementation details.
This article explains the concept of idempotency, illustrates why repeated operations must yield identical results, and details how RocketMQ’s components—NameServer, Broker, Producer, and Consumer—can be designed with unique message IDs and acknowledgment mechanisms to achieve reliable, duplicate‑free messaging in backend systems.
Starting with Nacos 2.2.0, this guide shows how to create a custom DM8 database plugin via the SPI mechanism, add Maven dependencies, import the required scripts, configure connection settings and set the platform property, enabling Nacos to persist data in a DM8 database.
This article walks through the design and implementation of a friend‑follow microservice using MySQL for persistence, Redis Sets for fast set operations, and Spring Boot, covering requirement analysis, data modeling, dependency setup, configuration, service logic, and testing with concrete code examples and performance insights.
This article details the private‑deployment architecture of Volcano Engine A/B Testing (DataTester), outlines three major challenges—version management, performance optimization, and stability—and explains the branch‑logic, release pipeline, model‑optimization, and pre‑aggregation solutions implemented to enable reliable, low‑resource SaaS‑like operation in on‑premise clusters.
This article provides a thorough overview of backend development, covering system design principles such as high cohesion and low coupling, architectural patterns for high concurrency and availability, network communication techniques, common fault scenarios, monitoring and alerting strategies, service governance practices, and deployment workflows.
This article explains how to work with absolute and relative file paths in PHP, demonstrates extracting path components with pathinfo(), and provides practical examples of directory and file manipulation functions such as opendir, readdir, scandir, fopen, fread, fwrite, unlink, copy, and rename.
This article explains the Chain of Responsibility design pattern, demonstrates its use in multi‑step product creation validation and expense‑approval workflows with concrete Java/Spring code, and discusses configuration, dynamic composition, advantages, drawbacks, and testing scenarios.
This article examines ten common traps when implementing Redis distributed locks—ranging from non‑atomic setnx/expire operations and missing expirations to lock release ordering, re‑entrancy, master‑slave replication issues, and the Redlock algorithm—providing concrete code examples, explanations, and best‑practice solutions.
This article explains how to prevent duplicate write requests on the server side by using unique request identifiers, Redis SETNX with expiration, and MD5 hashing of request parameters (excluding time fields), providing a complete Java implementation and testing examples.
This article explains why private controller methods in Spring Boot fail when AOP logging is enabled, revealing that CGLIB proxies cannot intercept private methods, which leads to null service injection, and provides code examples and a final conclusion.
cURL 7.87 has been officially released, introducing new command‑line options such as -url-query, enhancements like quick‑exit and CA cache timeout, expanded version‑info feature names, and a long list of bug fixes covering base64 handling, locale‑independent parsing, FTP, WebSocket, TLS‑proxy support, and more.
The article presents a comprehensive overview of the JinDao settlement platform, detailing its background, pain points, architectural design, domain modeling, sharding task component, sequential settlement mechanisms, configuration models, billing and allocation rules, and real‑world business case studies, illustrating how it enables accurate, fast, cost‑effective online financial settlement for JD Tech.
The article explains why Java applications typically use traditional database connection pools instead of IO multiplexing, covering JDBC’s blocking design, session management, ecosystem maturity, and the complexity of integrating non‑blocking I/O with existing frameworks, while noting that a non‑blocking implementation is technically feasible.
This comprehensive guide walks you through RabbitMQ fundamentals, deployment on macOS, core concepts such as exchanges and routing, detailed code examples for producers and consumers in Java, and advanced features like TTL, dead‑letter queues, and manual acknowledgments, helping you bridge theory and practice in message‑queue systems.
The Nacos 2.2.0 GA release introduces several new plugins—including rate‑limiting, custom environment variable, and datasource plugins—removes legacy redundant code, enhances tracing and batch registration, and delivers extensive refactoring and bug fixes to improve stability and extensibility for cloud‑native service discovery and configuration management.
This tutorial explains why message queues are essential, compares popular MQ products, details RocketMQ's core components, and provides step‑by‑step instructions—including environment setup, broker configuration, firewall rules, and monitoring—to deploy a fault‑tolerant RocketMQ cluster on CentOS 7.
This article explains why distributed ID generation is needed in micro‑service architectures, outlines business requirements such as global uniqueness and monotonicity, and surveys common generation schemes—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID – with code examples and pros/cons.
This article explains cache penetration scenarios, outlines Redis memory eviction strategies, introduces RedisBloom's Bloom filter and Cuckoo filter for detecting illegal requests, provides configuration details, and demonstrates practical commands to mitigate cache penetration in backend systems.
This article explains how to design a high‑availability SMS system by identifying stability bottlenecks, defining reliability goals, implementing failover strategies for Redis, MySQL and external services, establishing a comprehensive observability framework, and measuring key quality metrics to ensure 99.99% uptime.
This article explains how e‑commerce systems handle sudden traffic spikes by applying caching, various rate‑limiting algorithms (leaky bucket, token bucket, sliding window), Nginx ingress controls, Java Semaphore concurrency limits, distributed queue buffering, service degradation tactics, and cache‑consistency techniques for high‑availability backend services.
This article explains how to replace numerous static Feign client interfaces with a single dynamic Feign client in Spring, showing the generic service definition, a client factory, and usage examples that streamline inter‑service HTTP calls while keeping code reusable and maintainable.
This article provides a comprehensive analysis of Nacos as a service registry, covering its core concepts, architecture diagram, registration and discovery principles, detailed source‑code walkthroughs, and practical debugging examples for Spring Cloud microservice environments.
This article describes a step‑by‑step migration of a large monolithic Java application into vertically‑split micro‑services, covering database sharding into nine business databases, multi‑datasource and custom transaction implementations, application splitting, routing, RPC generation, and the measures taken to ensure data safety and low‑risk rollout.
The article explains how to handle sudden traffic spikes in e‑commerce systems by applying rate‑limiting algorithms, Nginx and Java semaphore controls, distributed queue buffering, service degradation tactics, and multi‑layer caching techniques to maintain high availability and data consistency.
This guide explains Spring 5.3’s built‑in servlet filters—including FormContentFilter for handling form data in PUT/PATCH/DELETE, ForwardedHeaderFilter for adjusting request URLs behind proxies, ShallowEtagHeaderFilter for lightweight caching, the CORS filter for cross‑origin requests, and CharacterEncodingFilter for enforcing request/response encoding—along with configuration tips and security considerations.
By eliminating unnecessary reverse‑geocode calls, aggregating nearby coordinates with GeoHash, and employing a multi‑layer LRU‑K cache with time‑ and access‑count eviction, the Hellobike map team cut daily requests from 200‑300 million to 20‑30 million while adding fallback and monitoring mechanisms.
The Nacos 2.2.0 release introduces major changes including removal of redundant 1.x code, new rate‑limiting, custom environment, and datasource plugins, enhanced batch registration, v2 OpenAPI, LDAP authentication, extensive refactoring, numerous bug fixes, and updated UI dependencies.
This article explains the fundamentals of caching, why caches (especially Redis) are essential for high‑performance and high‑concurrency scenarios, compares local, distributed, and multi‑level caches, and outlines their advantages, disadvantages, and typical implementation approaches.
Nginx 1.23.3, the lightweight web and reverse‑proxy server developed by Igor Sysoev, introduces several bug fixes and a hostname‑resolution workaround while continuing to offer low‑memory, high‑concurrency performance across multiple operating systems.
This article examines the ZCube rule engine, detailing its architecture, visual rule modeling tools, DSL and ANTLR integration, RETE algorithm implementation, knowledge package deployment, AB testing, and runtime execution flow, illustrating how it enables flexible, high‑performance business rule management.
This article explains how to generate all possible product SKU combinations for an e‑commerce system by computing the Cartesian product of specification arrays, and provides two PHP implementations—one that returns SKU strings and another that returns nested arrays—along with sample output.
This article compares popular and niche technologies, explains why .NET remains relatively unknown in China's internet industry, and introduces its evolution, the Blazor web framework (both WebAssembly and Server models), and the capabilities of Flutter Web for cross‑platform development.
This article introduces the concept of rate limiting, explains three core algorithms—fixed window, sliding window, and leaky bucket—along with the token bucket approach, provides Java code examples for each, discusses their principles, advantages, and pitfalls, and outlines practical implementation considerations.
The article outlines the release of PHP 8.2, detailing its major additions such as readonly classes, DNF types, new standalone types (null, false, true), the Random extension, trait constants, and the deprecation of dynamic properties, while providing code examples and migration guidance.
This article explains the fundamental concepts of rate limiting, reviews popular algorithms such as token bucket, leaky bucket, and sliding window, and details practical implementation methods across single‑machine and distributed environments using tools like Guava, Nginx, Redis, and Sentinel.
InfoWorld's 2022 Best Open Source Software Awards showcase a curated list of influential open‑source projects—including AlmaLinux, Podman, Play with Docker, Vaadin, JHipster, SolidJS, Redwood, Next.js, Wasmtime, PyScript, Hardhat, OpenFGA, Sentry, Appsmith, Spinnaker, Hypertrace, Gravitee, OpenTelemetry, Grafana, Dapr, Redpanda, Iceberg, Druid, JAX, nbdev, Accelerate, Stable Diffusion, and EleutherAI—covering backend, cloud‑native, AI, and data‑centric technologies.
This article explains how Domain-Driven Design can be used to split monolithic systems into manageable microservices, covering DDD fundamentals, strategic domain modeling, tactical design patterns, and a concrete Go implementation with a four‑layer architecture.
The article explains why Baidu built the high‑performance Janus gateway, its architecture and deployment topology, the three routing modes, the three‑level rule system with variable and condition expressions, plugin extensibility, performance benchmarks, and how the design can be generalized to other use cases.
This article demonstrates how to replace Shiro with jCasbin for fine‑grained permission control in a Spring Boot 1.5.10 project, covering Maven dependencies, configuration files, Enforcer initialization, a custom servlet filter, and dynamic policy add/remove APIs.
This article describes how combining Redis and RabbitMQ to implement an asynchronous cache refresh mechanism significantly improves interface performance and stability for a high‑traffic used‑car platform, meeting strict tp99 latency requirements while maintaining data freshness.
This article provides an in‑depth tutorial on configuring and using the Caffeine caching library in Java, covering cache creation, property settings such as initial capacity, maximum size, weight, expiration policies, statistics collection, custom listeners, and advanced features like removal listeners and cache writers.
This article defines process engines, distinguishes workflow from BPM, explores various process designer types, outlines core components such as organization, resources, forms, and interfaces, and presents practical architecture and implementation details—including code examples, permission handling, and reporting—illustrated with diagrams.
Learn how to integrate Bean Validation with Spring 5.2.23, configure the validator, inject it, create custom constraints, and enable method‑level validation using MethodValidationPostProcessor, with complete code examples and execution results, including handling of constraint violations and bean registration steps.
This guide introduces the open‑source nginx‑gui tool, explains its configuration and performance‑monitoring features, and provides step‑by‑step instructions for downloading, setting up, and running the GUI on Linux, including code snippets and screenshots.
This article provides a comprehensive overview of microservice architecture, outlining the four main technology dimensions—microservice management, storage, business support, and DevOps—and lists the most relevant tools and platforms for each area to help architects choose optimal solutions.
The article explains why traditional auto‑increment primary keys are unsuitable for distributed systems, outlines the key requirements for a distributed identifier, and reviews several practical generation schemes—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Didi TinyID—along with their advantages, drawbacks, and sample implementations.
This article details the architectural decisions, network protocol choices, message framing strategies, and server‑level optimizations—including Netty adoption, TCP handling, token management, load balancing, NIC queue configuration, and CPU affinity—that enable a scalable, low‑latency instant messaging service supporting millions of concurrent connections.
