This article presents a backend‑focused study on reducing latency of vector‑based ad recommendation retrieval by leveraging Gonum, SIMD AVX2 intrinsics, and direct Plan9 assembly integration in Go, and it validates the approach with detailed performance benchmarks and CPU usage analysis.
This article reviews eight popular Node.js WebSocket libraries—SockJS, ws, Socket.IO, Faye WebSocket, SocketCluster, Sockette, and Feathers—detailing their features, popularity, installation commands, and typical use cases for building real‑time backend applications.
This guide explains how to install, configure, and use Midway 3.x's info component to expose application details, customize the info route, hide sensitive data, and access diagnostic APIs for deeper backend insight.
This tutorial walks through creating a Slackbot using the new Bolt API with Node.js, covering workspace setup, app creation, OAuth scopes, server configuration, code installation, environment variables, socket mode, slash commands, event subscriptions, a simple JSON knowledge‑base, and deployment steps.
This post shares a comprehensive Java interview handbook containing over 1,000 questions covering MyBatis, Zookeeper, Dubbo, Redis, MySQL, concurrency, Spring, Kafka, micro‑services and more, hosted on GitHub with 30K+ stars, and explains how to obtain the latest PDF via a WeChat QR code.
This article revisits RESTful API design using Go Web, covering twelve practical guidelines such as JSON usage, verb‑free and pluralized paths, hierarchical resources, pagination, unified response formats, proper HTTP status codes, versioning, HTTPS, and documentation to help developers build clear, consistent, and secure APIs.
This article provides an in‑depth overview of Kafka, covering why messaging systems are needed, core concepts, cluster architecture, performance optimizations such as sequential disk writes and zero‑copy, resource planning, deployment steps, configuration details, operational tools, and advanced topics like custom partitioners and time‑wheel scheduling.
This article demonstrates how to retrieve flat menu data from a database into a List, then use Java 8 Stream operations and recursive methods to assemble a hierarchical tree structure, printing the result as JSON for verification.
This article outlines the architectural principles, middle‑platform strategy, service layers, common components, cloud deployment, security measures, and detailed design diagrams for building a scalable, high‑concurrency e‑commerce transaction system using DDD, microservices, and cloud‑native technologies.
This article explains how to architect a highly scalable backend by starting with a simple single‑server setup, then applying vertical and horizontal scaling, database replication, sharding, caching, load balancing, CDN, GeoDNS and stateless design to support over a hundred million concurrent users.
This article details the background, overall architecture, iterative improvements, and future directions of JD Daojia's order timeliness system, covering early limitations, business‑driven challenges, solution iterations, order‑control mechanisms, product‑dimension handling, and the final business architecture to enhance fulfillment rates and user experience.
This article explains how Redis stores Set and Sorted Set objects using dual internal representations—intset and hashtable for sets, skiplist and ziplist for sorted sets—detailing their structures, encoding selection criteria, upgrade processes, command usage, and the reasons behind combining dictionaries with skiplists for optimal performance.
This article outlines seven fundamental Java performance‑optimization directions—ranging from code reuse and parallel execution to JVM tuning—providing a theoretical framework that helps developers understand how to balance resource usage, reduce latency, and improve overall system efficiency.
Learn to protect your server from malicious crawlers by creating a dynamic IP blacklist using Nginx, Lua, and Redis, covering architecture choices, installation steps, configuration snippets, and how to share and update the blacklist across multiple machines.
This article explains the risks of microservice architectures and presents a collection of reliability patterns—including graceful degradation, change management, health checks, self‑healing, failover caching, retries, rate limiting, bulkheads, and circuit breakers—to help engineers design and operate highly available backend services.
This article reviews common distributed ID generation methods—including UUID, database auto‑increment, segment mode, Redis, Snowflake, Baidu UidGenerator, Meituan Leaf, and Zookeeper—detailing their principles, advantages, drawbacks, and suitable scenarios to help developers select the most appropriate solution for their microservice architecture.
The article explains why unified log structures and traceId identifiers are essential for quickly locating bugs in high‑traffic backend services, provides a Java LogObject example, demonstrates chain‑style setters, shows how to combine request and response in one log entry, and compares manual logging with AOP‑based approaches for performance and maintainability.
This article analyzes a Spring transaction rollback issue caused by the use of pattern‑based exception matching, explains why certain custom exceptions trigger unexpected rollbacks, traces the problem through source code and GitHub issues, and describes how the Spring team fixed it with type‑safe rollback rules and documentation updates.
This article compiles a comprehensive list of video tutorials covering interface testing, HTTP request handling, JSON manipulation, performance testing, Java concurrency, and the Arthas diagnostic tool, each with titles, publication dates, and links for developers seeking practical guidance.
Spring Framework 6.x has been officially released, introducing Jakarta EE‑based packages for core annotations, requiring Hibernate‑Core‑Jakarta upgrades, updating servlet containers to Tomcat 10/Jetty 11/Undertow 2.2.14, and altering Web MVC/WebFlux behavior, with detailed migration steps and reference links.
This article explains how to design a dictionary entity, create a custom annotation, and use Spring's ResponseBodyAdvice together with Java reflection to automatically convert enum values to their textual representations in API responses, improving front‑end display without manual mapping.
This article provides a detailed overview of the evolution of software architecture from monolithic to microservices, discusses the advantages and drawbacks of each stage, and outlines essential microservice technologies such as service discovery, API gateways, authentication, logging, containerization, orchestration, and CI/CD pipelines.
This article explains why matplotlib fails on macOS with a pyenv‑managed Python, details the RuntimeError about missing framework and the subsequent _tkinter module error, and provides step‑by‑step solutions using TkAgg, Qt5Agg, and proper installation of PyQt and tkinter.
This article provides a comprehensive PHP form validation tutorial, covering required and optional fields, validation rules using regular expressions, secure handling of user input with trim, stripslashes, and htmlspecialchars, prevention of XSS via $_SERVER['PHP_SELF'] sanitization, and includes complete example code for both the HTML form and processing script.
This article explains why Spring Cloud Gateway can return duplicate Access‑Control‑Allow‑Origin and Vary headers during CORS handling, analyzes the underlying processing flow, and provides two practical solutions—using DedupeResponseHeader configuration or implementing a custom GlobalFilter—to ensure a single, correct header is sent to the client.
This article presents 22 practical best‑practice guidelines for designing consistent, secure, and user‑friendly RESTful APIs, covering URL naming conventions, HTTP methods, versioning, pagination, JSON naming, monitoring endpoints, CORS, error handling, and other essential considerations for backend developers.
This article explains why traditional delay solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, then demonstrates step‑by‑step how to configure RabbitMQ’s delayed‑queue plugin, create exchanges, queues, and bindings in Spring Boot, and send and consume delayed messages with code examples.
This article reveals how creating a new thread pool for each @Async method in Spring can exhaust system resources, explains Spring Boot’s default executor behavior, shows code examples, and offers practical guidance to prevent thread‑pool related crashes in Java backend applications.
This article explains why using scheduled tasks for closing timed‑out orders is problematic, demonstrates how to use RabbitMQ dead‑letter queues and the x‑delay‑message plugin to achieve accurate order timeout handling, and provides complete Spring Boot configuration and code examples with testing and limitations.
This guide explains the fundamentals of Netty, shows how to combine it with Spring MVC using DispatcherServlet, and provides complete Java code examples for a Netty server, channel pipeline, request handler, server startup, and a sample controller, along with practical configuration tips.
This article provides a comprehensive overview of Spring's core utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose, key methods, and practical code examples for robust backend development.
This article introduces two Spring Boot based workflow solutions—Spring‑boot‑activiti and RuoYi‑vue 4.x + Flowable—detailing their architecture, key features, deployment steps, and available resources to help developers understand and experiment with workflow engines.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable with exe4j, bundling a local JRE, and then creating a user‑friendly installer using Inno Setup, providing step‑by‑step screenshots and configuration details to avoid common pitfalls.
The author describes a high‑QPS Java web service, analyzes its GC behavior using jstat and gceasy, applies JVM parameter adjustments such as enlarging the young generation, tweaking MaxTenuringThreshold and disabling biased locking, and achieves roughly a 15% overall performance gain with improved GC throughput.
This article explains how to replace repetitive try‑catch blocks in Spring applications by using @ControllerAdvice for global exception handling, custom Assert utilities, and enum‑based error codes, resulting in cleaner, more maintainable backend code and consistent API responses.
This article explains why caching is essential for high‑concurrency systems, analyzes the challenges of keeping database and cache data consistent, and compares five practical cache‑invalidation strategies—including write‑after‑DB, delete‑before‑write, delayed double delete, queue‑based deletion, and binlog subscription—highlighting their trade‑offs and suitable scenarios.
This article presents a concise set of best‑practice guidelines for designing consistent, resource‑oriented RESTful APIs, covering naming conventions, URL structures, HTTP methods, parameter handling, versioning, monitoring, security, error handling, and documentation tools.
The article analyzes the memory overhead of naïvely storing per‑user read/unread lists for group chat messages and proposes a bitmap‑based scheme with user‑to‑map ID mapping, quit flags, and compact storage that can reduce per‑message space by over 95 percent.
This article explains why front‑end and back‑end separation is needed, describes the evolution from MVC to SPA, outlines responsibilities, development workflow, and provides a detailed version‑1.0.0 API contract with request/response formats, special field rules, and future front‑end trends.
This article explains the motivations for separating frontend and backend, outlines the evolution from MVC to SPA architectures, details responsibilities, development workflows, and provides a comprehensive API specification including request/response formats, special data handling, and future frontend trends.
This article provides a step‑by‑step methodology for identifying why a Redis instance becomes slow, covering baseline latency testing, slow‑log analysis, big‑key detection, expiration patterns, memory limits, fork overhead, huge‑page effects, AOF configuration, CPU binding, swap usage, memory fragmentation, network saturation, and practical remediation techniques.
PHP 8.1.3 has been released as a security‑focused update that fixes numerous core, FFI, filter, FPM, MBString, MySQLnd, pcntl, sockets, and standard extension bugs, and users of the 8.1 series are encouraged to upgrade promptly.
The article details how DaJia's recommendation system progressed through three architectural versions—V1.0's simple strategy‑factory design, V2.0's vertical business split and configurable pipeline, and V3.0's dynamic configuration service and modular pipeline—addressing scalability, fault isolation, and personalization challenges while outlining future directions for explainable AI recommendations.
This guide walks through the complete setup of SQLE's development environment, covering the Go-based backend API, MySQL configuration, and the Node.js/React frontend, including required tools, code cloning, building, and testing steps on Linux.
This article explains how DolphinScheduler (DS) implements workflow versioning by introducing integer‑based versions, describes the core principles of workflow and task relationships, outlines the key database tables and architecture, and provides detailed Java code for creating, updating, and managing workflow definitions, tasks, and their relations.
This guide shows how to modify a Go custom DNS resolver to perform simple load balancing by predefining IP addresses and randomly selecting one for each new connection, including full code examples and test output.
The article compares a traditional if‑else/switch implementation with the Strategy pattern and a Map‑plus‑lambda approach for routing coupon‑type requests, showing each method’s code, advantages, drawbacks, and how to choose the most maintainable solution.
The article describes Vivo’s overseas sales team’s multi‑language document system, detailing its low‑maintenance i18n design that leverages the existing configuration center, a MCMS UI, and a runtime JAR to streamline project creation, translation, testing, publishing, and real‑time front‑end text updates across web and decoupled architectures.
Node.js now offers a native fetch() API—an experimental, Promise‑based HTTP client introduced in v17.5.0 that mirrors the browser Fetch API, simplifying requests, improving performance, and paving the way for future LTS support.
This article explains the Snowflake distributed ID algorithm, compares it with other ID generation methods, details its 64‑bit structure, provides a complete Java implementation with thread‑safe code, and discusses practical limits such as the 69‑year timestamp and front‑end numeric handling.
This article explains how to design a scalable multi‑account login architecture—including self‑built phone‑number registration, optimized password‑optional flows, third‑party integrations such as Weibo, and a unified user‑basic and user‑auth table schema—while also covering one‑click carrier‑based login and its advantages and drawbacks.
This article explains how Spring Security’s HttpSecurity class maintains the order of its built‑in filters using FilterOrderRegistration, demonstrates the registration and retrieval logic with code examples, and clarifies how duplicate orders are resolved during filter sorting.
This article explains how Nohost extends the Whistle packet‑capture tool into a multi‑process, multi‑user remote proxy platform, detailing its architecture, interaction flow, master‑process logic, environment injection, user‑state recording, and Whistle process management for developers and operations teams.
This article explains why Linux kernels 3.9+ allow multiple processes to bind the same port, how the REUSEPORT option implements kernel‑level load balancing, and provides step‑by‑step examples showing configuration, code snippets, and performance verification.
This article compares three Go transaction implementations, explains their trade‑offs, and presents a refined pattern that uses defer tx.Rollback() to guarantee rollback while still allowing successful commits, covering both simple and loop‑based use cases.
The article examines tiered data storage and evaluates four cache‑synchronization strategies—updating the database before the cache, deleting the cache before updating the database, updating the cache before the database, and deleting the cache after a database update—highlighting their trade‑offs and practical solutions such as delayed double deletion, message‑queue retries, and binlog‑driven cache updates.
This article details the research background, environment preparation, and three Redis‑based message‑queue implementations—using List structures, Pub/Sub, and Stream APIs—along with code examples, design considerations, testing strategies, and deployment tips for building a lightweight messaging component in Java Spring Boot.
The article introduces a real-time code coloring system for Lua-based game development, explaining its purpose, usage scenarios, core functionalities, data collection methods, architectural design, technical challenges, performance optimizations, and network communication using Django Channels.
The article analyzes the problem of data inconsistency when using caches such as Redis or local memory alongside a database, classifies data by real‑time requirements, compares four write‑through/write‑behind strategies, and proposes practical solutions like delayed double‑delete, message‑queue compensation, and binlog‑driven cache updates.
Elasticsearch 8.0 introduces major updates including 7.x REST API compatibility headers, default‑enabled security with registration tokens, protected system indices, a preview KNN search API, storage‑efficient keyword/match_only_text/text fields, faster indexing for geo_point and geo_shape, PyTorch model support, and numerous deprecations and enhancements across aggregations, allocation, analysis, authentication, cluster coordination, and engine components.
This guide presents a concise set of best‑practice rules for designing consistent, RESTful backend APIs—including naming conventions, URL structures, HTTP methods, versioning, pagination, security, and documentation tools—to help developers create clear, maintainable, and user‑friendly services.
This guide outlines a practical seven‑step methodology for mastering Redis source code, from mapping the project structure and preparing prerequisite knowledge to focusing on core execution paths, handling complex functions, exploring side modules, and iteratively filling knowledge gaps.
This article explains the concept of API idempotency, why duplicate requests occur in distributed systems, and presents a comprehensive set of server‑side and client‑side techniques—including token mechanisms, PRG pattern, unique indexes, optimistic locking, distributed locks, and idempotent state machines—to guarantee that repeated calls produce only a single effect.
This article presents a thorough Java production troubleshooting workflow, covering essential knowledge, tools, and data analysis techniques, with detailed explanations of JVM garbage collection, profiling utilities, and real‑world case studies to help engineers quickly locate and resolve performance and stability problems.
This article explains how to use the ngx_lua module in Nginx to assign traffic tags, implement header‑based or domain‑based routing, and integrate with dynamic upstreams for parallel testing, load testing, and gray‑release scenarios, providing code examples and configuration details.
Midway 3.0 was officially released on January 20, 2022, introducing multi‑version documentation, a clarified tech stack for standard, serverless, and integration projects, a redesigned API syntax with zero‑API calls, enhanced operators, Prisma ORM support, a new full‑stack suite, and a lightweight request SDK for both Node.js and browser environments.
This article compiles a comprehensive set of Tencent interview questions and detailed answers covering HashMap internals, thread safety, red‑black trees, Redis performance, MySQL indexing, TCP reliability, IO multiplexing, RPC, and system bottleneck analysis to help candidates prepare effectively.
Elasticsearch 8.0 introduces 7.x REST API compatibility headers, default‑on security features with automatic enrollment tokens, tighter protection of system indices, a preview KNN search API, storage‑saving field encodings, faster geo‑point and geo‑shape indexing, PyTorch model support, and a long list of deprecations and internal improvements.
A seemingly harmless RPC framework bug caused a 4 GB byte array allocation, leading to repeated OutOfMemoryErrors in service B after service A’s deployment, and the article walks through the diagnosis, root‑cause analysis, and a simple fix.
This article reviews Alibaba’s Java Development Manual, highlights the latest Huangshan edition’s 11 new coding and design rules—including enum immutability, NPE‑prone ternary usage, security checks, and database practices—while providing concrete code examples and practical insights for Java engineers.
This article provides a comprehensive overview of Apache Tomcat, covering its role as a Java web server, the internal components such as Server, Service, Connector, and Container, the lifecycle management, startup process, connector types, NIO handling, Comet support, and asynchronous servlet processing.
The article explains the concepts of forward and reverse proxies, compares their functions and deployment scenarios, and then introduces load balancing principles, layer classifications, and common software such as DNS‑based, reverse‑proxy, NAT, and application‑layer solutions, highlighting their use in backend architectures.
The article shares a real‑world case study of a legacy multi‑service web platform where traffic spikes exposed DB connection leaks, leading to a 90% response‑time bottleneck, and outlines four key takeaways about tail‑latency metrics, investing in tools and people, actively maintaining legacy systems, and treating every line of code as critical for performance.
This article investigates whether the Mapped Diagnostic Context (MDC) in Java logging can lead to memory leaks by analyzing its ThreadLocal implementation, running multiple thread‑pool scenarios, and comparing the findings with classic ThreadLocal leak cases.
This article explains Kafka consumer group rebalance, covering core concepts, trigger conditions, detailed protocol steps, common pitfalls like long pause times, and modern improvements such as static membership and incremental cooperative rebalance, plus practical configuration tips to minimize disruptions.
This article explains why the default InMemoryDnsResolver cannot provide load balancing, shows how to create a custom SystemDefaultDnsResolver that randomly selects IPs, and demonstrates single‑thread, multi‑thread, and single‑connection pool tests to verify the behavior.
This guide explains what Pusher is, outlines its common real‑time use cases, and provides step‑by‑step instructions for registering a Pusher account and integrating its PHP and JavaScript libraries into a Laravel project for seamless WebSocket communication.
This article walks through building a simple Netty HTTP server, explaining how thread groups, channel options, handlers, and the bind operation work together to start a server, and highlights key implementation details such as selector creation and performance‑focused choices.
kkFileView is a free, Apache‑licensed Spring Boot project that enables online preview of numerous file types—including office documents, PDFs, CAD files, images, archives, and multimedia—offering RESTful APIs, easy deployment, and extensible interfaces for developers seeking a versatile document viewer.
This article walks through the design and practical implementation of a high‑throughput red‑envelope service capable of handling 10 billion requests, covering target load calculations, hardware and software choices, client‑server coordination, performance testing, monitoring, and key takeaways for building scalable backend systems.
This tutorial explains how to install Docker, configure remote access, create a Spring Boot project in IntelliJ IDEA, add Dockerfile and Maven settings, build a Docker image, run the container, and verify the application through a browser and log inspection.
This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, common methods, and usage examples to replace redundant custom code.
This article introduces how to enable SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and use the Spring Configuration Processor for property binding hints, providing Maven dependencies, IDE settings, and example code snippets for Java backend development.
This curated list compiles numerous Chinese-language articles and tutorials covering API and interface testing techniques, including Java HttpClient usage, Spring Boot integration, socket and WebSocket testing, performance measurement, automation frameworks, and related tools, offering developers practical guidance for backend service validation.
This article provides a comprehensive overview of MyBatis, detailing its three‑layer architecture, core modules such as caching, reflection, and transaction management, as well as the complete execution process from configuration files to SQL execution, helping developers master the framework for enterprise‑level Java applications.
This article explains how to break monolithic applications into domain‑driven microservices by defining clear bounded contexts, using aggregates, applying context‑mapping and event‑storming techniques, and choosing appropriate communication patterns such as asynchronous events, CAP trade‑offs, and BFF for frontend integration.
The article argues that despite widespread criticism, PHP remains highly popular and indispensable for web development, citing its long‑standing ecosystem, ease of use, massive market share, and the practical advantages it offers over languages like Python in real‑world projects.
This article explains how to analyze, diagnose, and optimize performance problems in production business systems, covering the typical causes such as high concurrency, data growth, hardware limits, and environment changes, and detailing practical steps for hardware, OS, database, middleware, JVM tuning, code review, and APM monitoring.
This article explains the concept of middleware, demonstrates how to implement it in Go using the net/http Handler interface and the Negroni library, and provides complete code examples for logging and authentication middleware chains.
This article shares a detailed account of a backend engineer's multi‑stage interview process at Huanju (formerly YY), covering personal background, common Java and system design questions, database and caching strategies, distributed lock handling, and reflections on preparation and outcomes.
The article explains why service rate limiting is essential for high‑concurrency systems, compares it with service degradation, describes common algorithms such as counter, leaky bucket and token bucket, and shows how to implement distributed rate limiting using Redis.
IntelliJ IDEA's Stream Trace feature allows developers to visualize each step of Java Stream operations during debugging, showing element counts, intermediate results, and object details, with split and flat modes, demonstrated through a sample code that filters strings by length.
This article shares a step‑by‑step account of a candidate's three‑round ByteDance interview, covering background, technical questions on Java, JVM, Redis, MySQL, Kafka, and algorithm challenges, along with personal reflections on pacing, preparation, and why concise answers matter.
This guide explains how to configure Python's logging.handlers.SMTPHandler to email log messages, why QQ enterprise and Gmail require SSL instead of TLS, and provides a complete logging.conf example with sample code to avoid common pitfalls.
This article explains MyBatis's first‑level and second‑level caching mechanisms, demonstrates data inconsistency problems caused by joined‑table queries, and provides a custom annotation‑driven relation cache solution with code examples for configuring and validating the cache behavior.
This article explains the execution order of Spring AOP annotations, demonstrates why an @Around advice may invoke a method twice when ProceedingJoinPoint.proceed() is called multiple times, and provides corrected code to ensure proper single execution.
This guide walks you through downloading XXL-Job, setting up its database, configuring Spring Boot profiles, customizing log paths, deploying the admin console, writing a sample executor with @XxlJob, and managing tasks through the web UI, all with concrete commands and code snippets.
cURL author Daniel Stenberg announced plans to add native JSON handling, explaining its importance for REST APIs, the common pain points developers face, and introducing two new command‑line options that simplify sending JSON payloads and headers.
The article analyzes the challenges of maintaining data consistency when using both cache (local memory or Redis) and a database, classifies data by real‑time requirements, evaluates four double‑write strategies, and proposes practical solutions such as delayed double deletion, message‑queue compensation, and binlog‑driven cache updates.
This article demonstrates how to enable browser-based preview of Word, Excel, and PowerPoint files in Java by converting them to PDF streams with Apache OpenOffice and JODConverter, covering installation, Maven setup, utility code, service logic, and controller exposure.
