This article explains the Lombok @Accessors annotation, detailing its source code, the meaning of its fluent, chain, and prefix attributes, and demonstrates how these settings affect generated getter and setter methods, while also providing usage examples and related promotional links.
Discover a comprehensive set of practical techniques—including batch processing, asynchronous handling, caching, pre‑processing, pooling, parallel execution, indexing, transaction optimization, code refactoring, pagination, and lock granularity—to dramatically reduce API latency and improve backend efficiency, illustrated with Java code examples and diagrams.
This article introduces Java Agent technology, explains the differences between premain and agentmain modes, demonstrates how to build, package, and attach agents using Maven and the Attach API, and shows practical bytecode manipulation techniques with Instrumentation and Javassist, complete with code examples.
This article demonstrates how to integrate account username and WeChat web‑authorization login into a Spring Security application by configuring custom authentication providers, filters, tokens, and handlers, allowing users to log in without a password while leveraging WeChat OpenID verification.
This tutorial walks through enabling Docker remote connections on Linux and Windows, installing and configuring the IntelliJ IDEA Docker plugin, adding a docker‑maven‑plugin to a Spring Boot Eureka project, building Docker images, creating containers with port mapping, and setting up one‑click deployment for rapid backend development.
This guide explains how to transform a PHP array with non‑sequential keys into a zero‑based sequential array by using the built‑in array_values function, the array_merge function, and a manual foreach loop, providing code examples and output for each method.
This article explains how to configure Nginx to split access logs by day using the $time_iso8601 variable, align log timestamps with the local timezone via Docker‑Compose or Dockerfile settings, and introduces the GoAccess tool for visual log analysis.
This guide explains how to create Spring Boot scheduled tasks whose execution intervals can be changed at runtime using configurable cron expressions or periodic triggers, and provides REST endpoints to update the schedule without restarting the application.
This article presents a comprehensive overview of a flexible, layered software architecture—covering gateway, business, and foundation layers—explaining how to evolve from simple startup setups to adaptable structures that support HTTP/TCP handling, service design, component abstraction, and common technical components.
This article demonstrates how to create a Spring Boot request‑rate‑limiting solution using a custom @RequestLimit annotation, a Redis‑backed interceptor, and configuration classes, providing step‑by‑step code examples and usage instructions for both class‑level and method‑level protection.
RaftKeeper is an open‑source, C++‑implemented Raft‑based distributed consensus service that offers double‑the‑throughput, sub‑second latency, five‑nines availability, and full ZooKeeper compatibility, targeting high‑performance OLAP workloads and large‑scale backend scenarios.
This article explains three core rate‑limiting algorithms—Leaky Bucket, Token Bucket, and Sliding Window—detailing their principles, suitable scenarios, and provides complete Go implementations to help developers choose and integrate the right strategy for handling traffic spikes and protecting backend resources.
This article describes how to identify abnormal Nginx requests caused by bots like AhrefsBot and Scrapy, and provides a step‑by‑step Docker‑based solution that includes a custom Nginx configuration, agent‑deny rules, and optional Alibaba Cloud security‑group IP blocking to prevent memory spikes.
This article provides a comprehensive roundup of recent Java ecosystem developments, including new JDK 20 and 21 builds, updates to OpenJDK drafts, releases of GraalVM, Spring Framework, Quarkus, Micronaut, JobRunr, MicroStream, Hibernate, Apache projects, and related community events.
A recent Redis‑py library vulnerability caused ChatGPT to expose personal data of about 1.2% of Plus users, prompting an OpenAI apology, a detailed post‑mortem, and a series of backend and security fixes to prevent similar incidents.
This step‑by‑step tutorial shows how to configure Alibaba mirrors, install PHP 8.2, Nginx, MySQL 8, Redis 6 and Composer on Ubuntu 20.04, adjust PHP‑FPM settings, create a test PHP file, start services, and verify the full LEMP stack works within about 20 minutes.
The article analyzes post‑pandemic salary changes in China for various tech positions—including backend (Java, PHP, Python), frontend, network security, mobile, testing, operations, data analysis, algorithm engineering, and architecture—showing modest growth in most areas with notable declines for Python and Android developers.
This article explains how to design an effective multi‑level caching system for microservice environments, covering client‑side static resource caching, application‑layer CDN caching, and service‑layer Redis caching, and provides practical Nginx configuration examples to implement these caches.
This article explains the fundamental concepts of rate limiting, including time and resource dimensions, various rule types such as QPS, connection count, bandwidth, black/white lists, and distributed considerations, then details common algorithms like token bucket, leaky bucket, sliding window, and practical implementations using Nginx, Guava, Redis, and Sentinel.
This article introduces Alibaba's open‑source Canal middleware, explains its architecture and high‑availability design, walks through MySQL binlog configuration, Canal setup, and provides a complete Java client example for real‑time data synchronization, cache refresh, and task dispatch scenarios.
This article explains how to limit the number of requests an interface can receive within a specific time window in a Spring Boot application by using a custom @RequestLimit annotation, Redis for counting, and a Spring interceptor to enforce the limits, complete with full code examples and configuration steps.
This article dissects the architecture of a 12306‑style ticket‑spiking service, explaining load‑balancing strategies, weighted Nginx routing, local and remote stock deduction using Go and Redis, and demonstrates performance testing that achieves thousands of requests per second while preventing oversell and undersell.
This tutorial demonstrates how to generate PDF files in Java with iText by filling form templates, inserting images and charts, creating dynamic tables, handling page breaks, and adding custom page headers, footers, and watermarks for backend applications.
This article explains how merging similar or duplicate requests upstream using Hystrix Collapser, a custom BatchCollapser implementation, and Guava's ConcurrentHashMultiset can significantly reduce downstream load, improve throughput, and outlines their configurations, usage patterns, and suitable scenarios.
This article examines common delay‑processing scenarios such as payment timeouts and token refreshes, compares several implementation methods—including Java DelayQueue, MQ‑based delay queues, scheduled tasks, Redis ZSETs, and time wheels—highlights their advantages and drawbacks, and presents a concrete architecture and demo code for a robust, retry‑capable distributed delay component.
This guide explains how to fix common Composer dependency errors in a Laravel project by backing up and removing the composer.lock file, reinstalling dependencies, and restoring the lock file, while also showing the typical error messages that may appear.
This article explains the concepts of functional and data permissions, the advantages of RBAC, and provides a step‑by‑step guide for designing and implementing a SaaS multi‑tenant data scope permission system using Spring Boot, MyBatis Plus, and Vue.
This article explains how to build a ready‑to‑use Spring Boot starter for enterprise OSS object storage, leveraging the Amazon S3 protocol to support major providers such as Alibaba Cloud OSS, Tencent COS, Qiniu OSS, and MinIO, and includes full Maven configuration, Java code, and packaging steps.
This guide explores practical strategies for managing Elasticsearch indexes, covering management approaches, structural maintenance, data synchronization, refresh policies, and deep pagination techniques to avoid common pitfalls and ensure reliable search performance.
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.
