The article explains common pitfalls of using Spring's @Autowired, compares it with the standard @Resource annotation, and demonstrates various injection techniques—including field, setter, constructor, and Lombok-based constructor injection—through detailed code examples and best‑practice recommendations.
This article provides a comprehensive walkthrough of Spring Security’s authentication mechanism, detailing the filter chain, core security components, and the underlying source‑code flow—from UsernamePasswordAuthenticationFilter through AuthenticationManager, ProviderManager, and DaoAuthenticationProvider—illustrated with code examples and diagrams.
This article demonstrates how to build a unified processing module in Spring Boot by using AOP and HandlerInterceptor to centralize user login validation, standardize response formats, handle exceptions globally with @ControllerAdvice, and configure path prefixes, providing complete code examples and implementation details.
This article explains a step‑by‑step methodology for estimating capacity, selecting appropriate garbage collectors, sizing JVM memory regions, and tuning advanced parameters such as survivor ratio, tenuring threshold, and Metaspace to reliably support a login service that processes one million requests per day on a machine with 8 GB of RAM.
A detailed post‑mortem of Digg's disastrous v4 launch reveals how a Python function with a mutable default argument caused massive cache overloads, forced emergency fixes, and ultimately contributed to the company's downfall, offering crucial lessons for backend engineers on safe defaults and release planning.
This article details the Spring Boot startup sequence, including the run() method, creation of listeners, environment loading, application context initialization, and the role of @EnableAutoConfiguration and related annotations in automatically configuring beans and starter components.
This article explains several common techniques for measuring Java code execution time, including System.currentTimeMillis(), Spring's StopWatch utility, System.nanoTime(), and the use of new Date(), providing code examples and a brief overview of StopWatch's API for developers seeking precise performance metrics.
This article explains the definitions, differences, and typical usage scenarios of DTO, VO, BO, PO, DO, and POJO in Java backend development, provides code examples for each layer, and introduces an IDEA plugin that automates object conversion to improve code maintainability.
This article explains three Redis‑based rate‑limiting techniques—using SETNX, sorted sets, and a token‑bucket with lists—providing code examples, discussing their advantages and drawbacks, and showing how to integrate them into Java Spring applications to protect high‑concurrency services.
This article describes how the Inspiration Spaces (IS) platform implements an automated regression testing pipeline that uses SSIM image similarity, asynchronous rendering, and pre‑defined sample rooms to dramatically reduce manual effort, improve detection of rendering bugs, and streamline cross‑team collaboration.
Learn how Spring Boot 2.6.14 simplifies calling remote REST services using RestTemplate and WebClient, including automatic configuration with RestTemplateBuilder, customization options via RestTemplateCustomizer and WebClient.Builder, and detailed code examples for building, customizing, and selecting appropriate HTTP connectors.
This article explains why traditional crontab cannot meet second‑ or millisecond‑level scheduling requirements in PHP projects and demonstrates how to use Workerman and Swoole timers, including code examples for one‑time, recurring, and task‑based executions.
This article explains the concept and purpose of caching, compares local and centralized cache approaches, introduces Spring's cache support and various CacheManager implementations, details GuavaCacheManager configuration and expiration strategies, demonstrates @Cacheable usage, and discusses common pitfalls such as cache miss due to internal method calls.
This article explains the design of a compact RPC service that aggregates product benefit information, detailing how Sirector thread scheduling reduces CPU consumption and how abstract handlers and Spring prototype beans improve code maintainability and extensibility.
This article explains how to configure and implement request throttling in Django Rest Framework, walks through the relevant source code in throttling.py and views.py, demonstrates testing the limit, and shows how to trigger custom DingTalk alerts when the limit is exceeded.
This article explains the concepts of cache penetration, cache breakdown (stampede), and cache avalanche in Redis, and provides practical solutions such as parameter validation, null‑value caching, Bloom filters, mutex locks, hot‑data non‑expiration, and randomizing expiration times, accompanied by Java code examples.
This tutorial explains how to set up a Java SpringBoot service, install and configure the cpolar intranet‑penetration tool, create HTTP tunnels for local ports, test the public endpoints with Postman, reserve a fixed sub‑domain, and use cpolar's listener for request debugging.
An online service experienced severe latency due to massive GAP times, leading to repeated OutOfMemoryErrors; by analyzing monitoring data, JVM dumps, and SQL queries, the team uncovered a massive userId array causing a 1 GB count query, then implemented request limits and JVM flags to prevent recurrence.
The author shares a detailed recap of interview preparation, processes, technical questions, and personal reflections from recent backend engineering interviews at several top Chinese tech companies, highlighting the importance of solid fundamentals, Go knowledge, and systematic study resources.
This article explains the SnowFlake distributed ID algorithm, detailing its 64‑bit structure, bit allocation for timestamps, datacenter and worker IDs, sequence numbers, and provides a complete Java implementation along with its advantages and limitations.
This article walks through a systematic approach to sizing and configuring JVM parameters—including heap, young generation, GC algorithm, Metaspace, and safety‑point settings—for a high‑traffic login service that receives one million requests per day on a server with 8 GB of memory, providing both practical code examples and interview‑style explanations.
This article provides a detailed walkthrough of Dubbo’s remoting module, covering its overall architecture, the dubbo‑remoting‑api abstraction, key packages such as buffer, exchange and transport, core interfaces like Endpoint and Channel, the role of ChannelHandler, the Transporter facade, and a concise summary of how these components interact to enable flexible, pluggable network communication.
This article explains the concepts of synchronous vs asynchronous and blocking vs non‑blocking I/O, then details the characteristics, advantages, and drawbacks of Java’s three I/O models—BIO, NIO, and AIO—providing guidance on when to use each approach in backend development.
This article explains the limitations of REST APIs, introduces GraphQL as a flexible alternative, details its core concepts such as schema, types, queries, mutations and subscriptions, and outlines various architectural patterns and tooling for integrating GraphQL into existing backend systems.
This article walks through a real‑world Python Selenium web‑scraping issue, explains common driver configuration problems, and provides the exact code fix to help developers quickly get their web crawlers running smoothly.
This article introduces the Caffeine Java caching library, explains its flexible expiration and write policies, and provides detailed manual, synchronous, and asynchronous code examples with console output to demonstrate how to integrate and benchmark Caffeine for high‑performance backend services.
This article outlines a step‑by‑step asynchronous processing pattern—including request reception, backend handling, exception retry, failure compensation, and alerting—to prioritize functional improvements and quickly enhance system performance while aligning technical actions with business goals.
This article explains how RocketMQ creates and manages threads, covering single‑thread creation via Runnable and Thread inheritance, the ServiceThread abstract class, ThreadPoolExecutor configuration, custom thread factories, and the importance of descriptive thread names for debugging.
This article explains the core components of an RPC framework—including transport, serialization, protocol framing, compression, bootstrap integration, service discovery, connection management, and a plugin‑based microkernel architecture—while highlighting design trade‑offs and practical extensions for robust backend systems.
This article uses a playful dialogue and water‑kettle analogies to explain the differences between synchronous and asynchronous I/O, blocking and non‑blocking operations, and then details Java's three I/O models—BIO, NIO, and AIO—so readers can choose the right approach for their web projects.
This article details how a large‑scale membership platform achieves high performance and high availability by employing a dual‑center Elasticsearch cluster, traffic‑isolated ES clusters, deep ES optimizations, Redis caching with distributed locks, dual‑center MySQL partitioning, seamless data migration, and fine‑grained flow‑control and degradation strategies.
This article provides a comprehensive reference of PHP built‑in functions, covering mathematical, string, array, multibyte string, date/time, directory, and file system operations, each listed with a brief description of its purpose and usage.
This article explains the core principle of RPC using dynamic proxies, showing how interfaces are proxied at runtime, the code generation process, and compares JDK, Javassist, and Byte Buddy proxy implementations with practical examples.
The article recounts how a mutable default argument bug in a Python function caused Digg's v4 release to crash, leading to massive performance issues, costly downtime, and ultimately contributing to the company's decline, illustrating key lessons for backend developers.
This article introduces the php‑ext‑xlswriter C extension for PHP, outlines its features, shows how to install it (including Docker commands), compares its speed with PHPSpreadsheet and PHP_XLSXWriter, and provides complete sample code for generating large Excel files efficiently.
Facing chaotic usage, maintenance challenges, partition tolerance issues, and performance bottlenecks with RabbitMQ, our middleware team decided to fully migrate to Kafka, outlining reasons, comparative models, migration strategies, and verification steps to ensure a smooth, high‑availability, high‑performance transition.
This article provides a step‑by‑step guide to configuring Nginx for high‑traffic scenarios, covering increasing worker processes, adjusting worker connections, enabling keep‑alive, optimizing caching, and setting up load balancing, along with discussion of common performance bottlenecks and tuning recommendations to achieve up to 100,000 requests per minute.
This article details the design of a high‑performance, scalable call‑center system, covering business and technical architecture, a visual workflow engine, communication component modularization, flow control under traffic peaks, and future plans for a unified telephony platform, illustrating how to boost first‑call resolution and user satisfaction.
This article explains Redis eviction policies, compares strategies like allkeys‑lru, volatile‑ttl, and noeviction, and provides practical solutions for cache penetration, breakdown, and avalanche to maintain system stability under high concurrency.
This article explores common Java class naming conventions across ten categories—management, propagation, callbacks, monitoring, memory, filtering, structure, design patterns, parsing, and networking—providing clear examples and best‑practice tips to make your code more readable and professional.
This article explains how RESTful API design reduces testing complexity by using unique URIs, standard HTTP methods, and JSON data exchange, and shows how test engineers can extend their frameworks with serialization support and added PUT/DELETE operations.
This article explores three practical approaches for automatically canceling unpaid e‑commerce orders—using scheduled tasks (both local and distributed), implementing passive client‑side cancellation with server checks, and leveraging delayed message queues such as RocketMQ—detailing their advantages, drawbacks, and typical frameworks.
This article reviews essential Redis string concepts, covering typical interview questions, encoding types, the EMBSTR threshold, SDS structure, and memory allocation details to help readers solidify their understanding of Redis string implementation.
This article presents the architecture, technology choices, and practical implementation details of FairPushy—a Dart‑driven backend and Flutter dynamic‑update platform—covering server development, concurrency handling, ORM integration, automated build pipelines, and deployment strategies for seamless hot‑reloading of mobile applications.
This article explains Redis eviction policies such as allkeys‑lru, volatile‑ttl, and others, discusses how the eviction process works, and provides practical solutions for cache penetration, breakdown (stampede), and avalanche, including Bloom filters, mutex locks, and randomized TTLs.
The article explains the performance drawbacks, hidden type‑conversion bugs, and runtime errors caused by generic Java property‑copy utilities such as BeanUtils and CGLIB, and demonstrates how compile‑time‑checked tools like MapStruct can safely handle conversions.
This article compares three real‑time communication techniques—long/short polling, WebSockets, and Server‑Sent Events—by explaining their mechanisms, presenting client‑ and server‑side code examples, and discussing their advantages, drawbacks, and suitable use‑cases to help developers select the appropriate method for a dashboard application.
This article details the design, bandwidth optimization, and reliability engineering behind a custom live‑streaming danmaku service that supports up to one million simultaneous users, covering problem analysis, compression techniques, polling strategies, service splitting, and performance results from a major traffic event.
This comprehensive guide explores essential backend techniques—including lock‑free programming, zero‑copy I/O, efficient serialization, pooling, concurrency, async processing, caching strategies, sharding, storage optimizations, and queue mechanisms—to build high‑performance, scalable services while highlighting practical code examples and real‑world trade‑offs.
This article explains how to replace repetitive try‑catch blocks in Spring Boot applications with a unified exception handling mechanism that leverages @ControllerAdvice, custom Assert utilities, and enum‑based error codes to produce clean, maintainable backend code.
Since Spring Boot 2.3.0.RELEASE, graceful shutdown is supported for all embedded web servers (Jetty, Reactor Netty, Tomcat, Undertow) and both reactive and servlet‑based applications, using SmartLifecycle beans, configurable timeouts, and a JVM shutdown hook to allow in‑flight requests to finish while refusing new ones.
This article introduces the open‑source chatGPT-service backend and chatGPT-stream frontend, explains their WebSocket integration, provides Gitee mirrors, and offers step‑by‑step commands for cloning, configuring, Docker deployment, compilation, and testing the real‑time ChatGPT application.
During a high‑traffic promotion, an interface experienced frequent timeouts and Full GC pauses over 500 ms, which were traced to a misbehaving DBCP connection pool that failed to keep connections alive, causing massive old‑generation garbage and severe GC latency.
This article demonstrates how to use Apache POI's XSSFWorkbook and SXSSFWorkbook classes in Java to export data to Excel files, addresses memory overflow issues with large datasets, shows code examples, and discusses the role of ChatGPT in assisting programmers without replacing them.
This article explains the complete user login process, including mobile verification, token generation, token expiration policies, request‑rate limiting with Redis, anonymous request handling, blacklist management, and provides full Java Spring code examples for implementing these backend authentication mechanisms.
This article introduces XNote, a lightweight personal note system with rich data management, cross‑platform support, and extensible plugins, detailing its key features, system architecture, directory layout, required dependencies, and step‑by‑step installation and configuration instructions for Python environments.
This article explains how Spring 5.3.23 uses ApplicationEvent and ApplicationListener for event handling, details the standard lifecycle events, shows how to create and publish custom events, and demonstrates annotation‑based, asynchronous, and ordered listeners for robust backend development.
This article explores practical techniques for optimizing online services handling over 200,000 QPS, covering why relational databases fall short, multi‑level caching, multithreading, circuit breaking, I/O reduction, controlled retries, edge‑case handling, and efficient logging to maintain sub‑300 ms response times.
This article examines YouTube's massive backend infrastructure, detailing its use of MySQL with Vitess for horizontal scaling, caching with Memcache, coordination via Zookeeper, cloud‑native deployment on Kubernetes, CDN delivery, and the storage systems (GFS, BigTable) that enable billions of users to upload and stream petabytes of video data.
This guide explains why reading source code matters and presents 18 practical techniques—covering JDK fundamentals, design patterns, official documentation, module analysis, demo‑first approach, purposeful reading, and effective note‑taking—to help developers confidently explore Java open‑source projects like RocketMQ.
This article explains a comprehensive backend user login flow, covering token generation, expiration policies, request validation, logout handling, anonymous access strategies, rate‑limiting with authorized tokens, path‑regex filtering, blacklist management, and includes a Spring‑Redis implementation example.
This article explains the Spring AOP advice lifecycle, distinguishes shared and per‑instance advice beans, and details each advice type—around, before, throws, after‑returning, and introduction—along with practical Java code snippets for implementation.
PHP 8.2.2, a bug‑fix release, addresses numerous issues across the core engine, FPM, hash, LDAP, opcache, phar, PHPDBG, POSIX, random, standard library, and XMLWriter components, providing a more stable and secure version for developers.
Go 1.20, released six months after 1.19, brings major toolchain, runtime, and library updates—including new slice‑to‑array conversion, unsafe package functions, struct field comparison rules, comparable type enhancements, reduced binary size, build‑flag architecture support, coverage flags, and experimental RISC‑V FreeBSD support—while improving CPU performance by up to 2% and cutting memory overhead.
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.
Learn how to use Spring's Application Event mechanism to separate main and sub‑processes in Java applications, covering custom event and listener creation, publishing events, abstract base event design, singleton manager, and a real‑world order‑cancellation SMS notification case.
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.
