This guide explains RocketMQ's four core components, details its architecture, walks through configuring and starting the NameServer and Broker, and provides troubleshooting steps for common startup problems, all illustrated with commands and diagrams.
This article explains the difference between synchronous and asynchronous method calls in Java, demonstrates how to implement synchronous tasks, then shows how to convert them to asynchronous execution using Spring Boot's @Async annotation, @EnableAsync configuration, and Future-based callbacks to measure total execution time.
This article explains how Nginx location matching works, why the presence or absence of a trailing slash in both location blocks and proxy_pass directives changes request routing, and provides concrete configuration examples to avoid common pitfalls.
This article presents a comprehensive, categorized collection of essential technical books covering frontend development, backend engineering, mobile app creation, server architecture, testing practices, multimedia processing, computer vision, data mining, recommendation systems, and 3D/AR technologies, offering readers valuable resources for deepening their expertise across the software development spectrum.
The article details how a legacy e‑commerce supply‑chain system plagued by unclear boundaries, inventory inaccuracies, and tangled dependencies was redesigned using domain‑driven design, hexagonal architecture, CQRS, and an EventStore solution, resulting in accurate inventory, easier extensions, and a reusable event‑driven component.
This article provides a comprehensive interview‑oriented overview of message queues, covering their use cases, popular frameworks, selection criteria, message models, reliability techniques, ordering, throughput optimization, high availability, and common Kafka interview questions.
This article comprehensively explains rate‑limiting concepts for Spring Cloud Gateway, covering common throttling scenarios, major algorithms such as Fixed Window, Sliding Window, Leaky Bucket and Token Bucket, reviews popular open‑source libraries, and demonstrates both single‑node and distributed implementations with detailed code examples.
This article explains the differences between system and operation logs, explores various implementation methods such as Canal, file logging, LogUtil, and method annotations, and demonstrates how to achieve clean, dynamic, and decoupled operation logging in Java Spring applications using AOP, SpEL, custom functions, and a well‑structured logging context.
This article explains how to improve database insertion performance in Java by replacing per‑iteration inserts with MyBatis‑Plus’s saveBatch method, detailing dependency setup, schema creation, entity, controller, service, and mapper code for efficient bulk operations.
This guide shows how to implement a custom EnvironmentPostProcessor in Spring Boot to decrypt sensitive configuration values such as datasource passwords, explains registration via META-INF/spring.factories, and details the execution order and related Spring Boot internals.
The Hulk framework, built on GDP2, provides a business‑oriented Go web development platform with out‑of‑the‑box components, standardized architecture, rich observability, and tooling that together improve code quality, development speed, and SRE efficiency for large‑scale short‑video services.
This article explains how Java reflection can be used to bypass private access modifiers, demonstrating code examples to access private fields, constructors, and methods, and discusses the advantages and disadvantages of using reflection in backend development.
This article explains how to implement a student QR‑code seat‑selection feature using PHP, detailing database schema design, URL parsing, seat‑allocation logic, attendance tracking, and daily cleanup tasks, enabling teachers to monitor seating without login while automatically recording student attendance.
An in‑depth comparison of the four major API architectural styles—RPC, SOAP, REST, and GraphQL—examining their mechanisms, strengths, weaknesses, and ideal use‑cases, helping developers choose the most suitable approach based on performance, scalability, security, and ecosystem considerations.
This article explains Java 8's CompletionStage API and its standard library implementation CompletableFuture, demonstrating its behavior through a series of concise examples that cover creation, chaining, asynchronous execution, custom executors, exception handling, cancellation, and composition of multiple stages.
This article explains Go's variadic parameters, showing how to declare them, pass arguments directly or via slices with the ... operator, and highlights common pitfalls and best practices for writing flexible backend functions.
This article provides a comprehensive overview of core Python concepts—including garbage collection, tuple versus list differences, process/thread/coroutine models, shallow and deep copying, the Global Interpreter Lock, sorting algorithms, closures, decorators, iterators, generators, and essential Django backend components such as WSGI, request lifecycle, middleware, ORM methods, caching, and REST framework.
This article explains the three Redis clustering modes, details how Redis Cluster uses 16384 hash slots calculated by CRC16, describes the rationale behind the slot count, and outlines the gossip‑based heartbeat communication and message format between master nodes.
This article introduces a comprehensive open‑source parking lot management system, detailing its five core functions, extensive feature set, modern Java‑Spring backend, Vue frontend, cloud‑ready architecture, and step‑by‑step deployment guide for developers.
A 2021 Spring ecosystem survey shows that Spring Data, Spring Security, Spring WebMVC, Kotlin adoption, API importance, modern architectures, Spring Native, and Kubernetes integration dominate developer choices, highlighting Spring's continued dominance in enterprise Java development.
This article demonstrates how MyBatis dynamic SQL simplifies conditional query building by explaining the usage of if, choose, foreach, trim, and bind tags, providing Maven project setup, table creation scripts, mapper interfaces, XML snippets, and unit test examples for SELECT, UPDATE, INSERT, and batch operations.
This article explains the fundamentals of distributed transactions, illustrates classic solutions such as two‑phase commit (XA), SAGA, TCC, local message tables, transactional messaging, and maximum‑effort notifications, and introduces a sub‑transaction barrier technique to handle network anomalies in microservice architectures.
This article provides a step‑by‑step guide for integrating Alipay's new transfer interface in a Java Spring application, covering certificate placement, property configuration, Maven dependencies, bean injection, configuration classes, utility services, and related data models with full code examples.
This article analyzes performance and concurrency problems in a code‑diff service, compares the original JGit‑based approach with a GitLab‑API solution, addresses new accuracy issues, and presents a compensation strategy using java‑diff‑utils to achieve stable, efficient backend diff processing.
The article explains why session sharing is critical in micro‑service and distributed deployments and presents four backend solutions—Nginx ip_hash load balancing, Tomcat session replication, Redis‑based centralized session storage, and cookie‑based sessions—detailing their implementations, advantages, and drawbacks.
The Vivo online mall introduces a multi‑dimensional pricing capability matrix and floor‑price monitoring system that flags or blocks orders when combined promotions push SKU prices below predefined thresholds, providing pre‑event configuration checks, real‑time alerts during sales, and post‑event analysis to prevent loss and price‑hunting incidents.
Airbnb replaced duplicated, latency‑prone authorization checks in its new service‑oriented architecture by moving them into data services and building Himeji, a Zanzibar‑inspired centralized permission store that uses triple‑based policies, configurable unions, sharded caching, and Aurora backing to deliver sub‑10 ms latency for millions of checks per second with 99.999 % availability.
This article explains how to build a free Java-based online preview service for Word, Excel, and PowerPoint files by installing Apache OpenOffice, adding JODConverter dependencies, creating a conversion utility class, and exposing the functionality through SpringBoot service and controller layers.
This article analyzes Elasticsearch’s distributed architecture, explaining core concepts such as nodes, indices, shards and replicas, comparing mixed and layered deployment models, and discussing data‑layer design choices and their trade‑offs in modern distributed storage and search systems.
This article provides a step‑by‑step guide to Django, covering web framework basics, the MVC/MTV pattern, project and app creation, URL routing, view logic, template rendering, static files, form handling, and database configuration with migrations.
This article provides a comprehensive overview of Node.js’s architecture, including its composition, code structure, startup process, event loop phases, process and thread management, core modules such as Cluster, libuv thread pool, signal handling, file operations, and networking protocols, illustrating how the runtime integrates V8 and operating‑system features.
The article demonstrates how to implement elegant, business‑logic‑independent operation logging in Java back‑ends by using AOP‑driven annotations, SpEL dynamic templates, custom parse functions, thread‑local context, and a Spring Boot starter, offering flexible persistence and automatic operator retrieval.
This article explains what a deadlock is in concurrent Java programs, discusses its impact on systems such as databases and the JVM, provides a guaranteed deadlock example with full source code, and walks through debugging steps to analyze and prevent such issues.
This article explains the principles, advantages, and drawbacks of various distributed transaction solutions—including XA two‑phase commit, three‑phase commit, TCC, Saga, and message‑based eventual consistency—while showing how they are implemented in Java/Spring environments and when each should be used.
The article explains why excessive null‑checking in Java code is problematic, distinguishes between null as a valid response and null as an error, and offers practical techniques such as returning empty collections, using assertions, throwing exceptions, and applying the Null Object pattern to write cleaner, safer code.
Learn how to extend Nacos’s configuration persistence beyond Derby and MySQL by cloning the feature_multiple_datasource_support branch, compiling the source with Maven, configuring Oracle as a datasource in application.properties, and launching Nacos in standalone mode, with step‑by‑step commands and essential scripts.
This article presents a detailed guide on building a startup backend architecture, covering language choices, core components, development processes, system tooling, and practical selections for project management, DNS, load balancing, CDN, RPC frameworks, databases, messaging, logging, monitoring, configuration, deployment, and security.
This article explains the fundamentals of data consistency in distributed systems, compares strong, weak, and eventual consistency, describes three classic cache patterns (Cache‑Aside, Read‑Through/Write‑Through, Write‑Behind), and presents practical techniques such as delayed double delete, retry mechanisms, and binlog‑based asynchronous deletion to keep Redis caches and MySQL databases in sync.
This guide explains how to install, configure, and use the @midwayjs/task module for distributed and delayed task scheduling in Midway, covering Redis setup, code examples for cron jobs, local tasks, manual triggers, progress tracking, logging, and troubleshooting.
This article presents a curated list of the eleven most popular Java open‑source projects on GitHub in August, including brief descriptions, star counts, and links, covering frameworks, messaging systems, data processing engines, and development tools for Java developers.
This guide explains how to create a custom DingTalk robot using Python 3.7, covering webhook configuration, security signing, step‑by‑step setup in the PC client, and a complete code example for sending text messages.
This guide explains how to add the mica-ip2region starter to a Spring Boot project, covering Maven and Gradle dependencies, built‑in configuration, custom Maven settings for the ip2region.db file, bean injection, available lookup methods, and a complete service example.
Jeepay is an open‑source payment system for internet businesses that supports multiple channels like WeChat Pay, Alipay and UnionPay, offers a Spring Boot backend with Spring Security, Ant Design Vue frontend, and provides comprehensive documentation, architecture diagrams, and deployment guides.
This article explains the motivation for client‑side caching, what data should be cached, and details the Redis tracking feature—including normal, broadcast, and redirect modes—while providing implementation examples and best‑practice guidelines for reducing latency and load on Redis servers.
This article explains why circular imports occur in Python, demonstrates the resulting ImportError with example modules, and provides three practical solutions—including importing modules directly, using lazy imports, and redesigning code structure—to prevent such issues.
This article explains how to use GraphQL as a Backend‑for‑Frontend gateway on Alibaba Cloud EdgeRoutine, covering the migration of Apollo Server, TypeScript setup, CDN edge caching, resolver implementation, and adding a Playground debugger, with full code examples and deployment tips.
This article introduces a high‑performance Python microservice framework built on Sanic, detailing its architecture, asynchronous design principles, integration of uvloop, asyncpg, aiohttp, Peewee ORM, OpenTracing, Swagger API documentation, middleware, testing, and deployment considerations for scalable backend services.
This article documents a step‑by‑step performance optimization of a high‑traffic web module, covering requirement analysis, bottleneck identification, caching, message‑queue offloading, Linux TCP tuning, and the resulting capacity increase to 50,000 QPS with sub‑70 ms latency.
This article dissects Nacos 2.0's UDP‑based service‑instance change notification, explaining client‑side listening, UDP port registration, server‑side storage, push logic, acknowledgment handling, and current design limitations, all backed by concrete Java code snippets.
This article explains the core concepts, patterns, and architectural styles of Domain-Driven Design, covering model‑driven design, bounded contexts, layered and hexagonal architectures, building blocks such as entities, value objects, aggregates, repositories, factories, and services, with practical examples and diagrams.
This article explains how to structure Python projects so that configuration can be cleanly switched between development, testing, staging, and production environments using packages, __init__.py tricks, environment variables, and dynamic imports, following principles from the Twelve‑Factor App.
This guide walks through building a minimal Nginx server, explains the root, location, and try_files directives with syntax, modifiers, matching priority, and practical code examples, and highlights common pitfalls such as using try_files in the wrong context.
This article explores why Spring transactions may fail, covering seven common pitfalls such as incorrect method visibility, final methods, internal calls, missing Spring management, multithreading, unsupported table engines, and misconfigured propagation, and provides practical solutions to ensure reliable transaction handling.
iQIYI’s mobile backend employs dogfooding‑driven gray releases with cloud‑controlled traffic, gray‑tag propagation, comprehensive front‑end and back‑end metrics, device white‑lists, and downstream service integration, allowing internal users to quickly verify code and configuration changes and catch issues before full production rollout.
This article explains three practical methods for assigning default values in Elasticsearch—using ingest pipelines, update‑by‑query scripts, and pipeline scripts—while also addressing how to maintain create_time and update_time fields in a way similar to relational databases.
This article explains Java's method reference syntax, including static, instance, and constructor references, demonstrates their use with functional interfaces, introduces the Optional class for handling nullable values, and shows how static factory methods like of() can replace constructors, providing practical code examples throughout.
This guide introduces MyBatis‑Mate’s core capabilities—including dictionary binding, field encryption, data masking, automatic DDL maintenance, dynamic sharding, and data‑scope permissions—while providing Maven dependencies and complete Java code examples for integrating these features into Spring Boot applications.
The article explains PHP's imageloadfont function, which loads a user‑defined bitmap font and returns its identifier, details its string parameter, return values (font ID or FALSE), notes platform‑specific binary format requirements, and provides a complete code example demonstrating image creation, font loading, text rendering, and output as PNG.
This article explains the fundamentals of load balancing, why a single entry point is needed for multi‑server deployments, how different network layers (L2‑L7) implement balancing, and the practical trade‑offs of hardware versus software solutions such as Nginx, HAProxy, and LVS.
This article explains the evolution from basic web cookies to session management, explores domain sharing, details cookie‑session architecture, introduces single sign‑on methods, and compares the traditional session approach with JWT token authentication, highlighting their advantages, limitations, and implementation considerations.
This article explains how Go implements enumeration using const and the iota counter, provides step‑by‑step code examples, demonstrates alternative type‑based enum patterns, and shows how to add a String method for readable output, helping developers write clean, maintainable constant definitions.
Tencent Docs was completely rebuilt on a modular, serverless architecture that integrates micro‑services such as SSR, OCR and plugin back‑ends, enabling automatic scaling for traffic spikes, versioned gray releases, pay‑per‑use cost savings, and faster development cycles for its tens‑of‑millions‑user base.
This article compares MySQL‑based single and multi‑record stock deduction methods with a Redis‑based approach that uses Lua scripting and distributed locks, providing full Java implementation details and REST examples for high‑concurrency inventory management.
This article explains the purpose, evolution, business logic, design principles, system architecture, permission model, and technical implementation of a payment operation platform that serves internal staff such as developers, testers, product managers, finance, and customer service within a payment company.
This article explains the concepts, strategies, and algorithms of rate limiting—including circuit breaking, service degradation, leaky‑bucket and token‑bucket methods—and provides practical Java, Guava, and Nginx + Lua implementations for controlling concurrency and protecting backend services.
The article explains PHP's imagejpeg() function, detailing its parameters, return values, and usage example for creating and outputting a JPEG image directly to the browser or saving it to a file, including optional quality settings.
This article explains how Nginx achieves high concurrency with an asynchronous, non‑blocking, epoll‑based architecture, why it avoids multithreading, lists common optimization settings, and enumerates typical reasons for 502 errors, providing practical commands and configuration examples.
The article introduces Hulk, a Go service development framework created by the short‑video R&D team to replace PHP monoliths, outlines its background, design principles, component hierarchy, comparison with GDP2, and demonstrates how its built‑in monitoring, configuration, and tooling improve code quality, development speed, and SRE efficiency across Baidu’s short‑video services.
Through a detailed case study, the author documents the process of optimizing a Python‑based web module—identifying bottlenecks, redesigning architecture with Redis queues, tuning MySQL, adjusting Linux TCP settings, and iteratively load‑testing until achieving 50,000 QPS with sub‑70 ms latency and zero errors.
This article explores Python’s underused singledispatch feature from PEP 443 as a clean, extensible way to serialize arbitrary objects to JSON, comparing it with traditional json module approaches and showing how it avoids cumbersome if‑elif‑else logic while keeping classes untouched.
The article explains PHP's imagegif() function, detailing its parameters, return values, and providing a complete example that creates a true‑color image, adds text, sets the appropriate header, outputs the GIF directly to the browser, and cleans up the resource.
The article explains the PHP imagegd2() function, detailing its parameters, return values, and usage example for outputting GD2 images either directly to the browser or saving them to a file, including optional chunk size and type settings.
This article details the step‑by‑step architectural evolution of JD Daojia's product system—from the initial 1.0 monolithic design, through 2.0 high‑availability and performance enhancements, to the 3.0 domain‑driven microservice architecture—highlighting the motivations, technical solutions, and future outlook.
This article explains why resource isolation is essential in distributed architectures and details various isolation techniques—including thread, process, cluster, data‑read/write, static, and crawler isolation—illustrated with Netty, Dubbo, and Tomcat examples, code snippets, and practical recommendations.
This article explains the PHP imagefilledpolygon function, detailing its parameters, return values, and providing a complete example that creates an image, allocates colors, defines polygon points, draws a filled polygon, outputs the PNG, and cleans up the resources.
This article explains how to use Spring annotations such as @Component, @Configuration, @Bean, @Autowired, and @Qualifier to inject beans via XML replacement, constructor injection, setter injection, property injection, List and Map injection, providing code examples and detailed explanations for each method.
This guide explains RabbitMQ dead‑letter queues, covering the conditions that turn messages into dead letters, how to configure exchanges and queues with x‑dead‑letter‑exchange, TTL, and max‑length, and provides step‑by‑step Spring Boot code examples for testing each scenario.
This article provides a comprehensive collection of Linux commands and techniques for identifying memory, CPU, network, disk, and application bottlenecks in Java backend services, including practical examples of free, vmstat, top, sar, iostat, iotop, and jstack usage.
The team built a whitelist‑based time‑travel module that overrides the system clock for selected operators, letting them preview future promotional prices in Vivo’s e‑commerce flow without creating real orders, by propagating an openId context through Dubbo filters and replacing System.currentTimeMillis() with a custom TimeTravelUtil.
This article explains the fundamentals of QR code login, detailing how QR codes convey identity, the token‑based authentication mechanism, and the step‑by‑step process that enables a mobile device to securely authenticate a PC session without exposing passwords.
The article analyzes why the Dubbo RPC framework is ill‑suited for transmitting files due to serialization and single‑connection constraints, compares it with HTTP's streaming capabilities, and shows how Feign can handle uploads while still facing memory‑usage challenges, concluding with practical recommendations for file‑transfer scenarios.
This article explains the Apache Commons Lang3 StringUtils utility class, detailing the behavior, usage examples, and source code of isEmpty, isNotEmpty, isAnyEmpty, isNoneEmpty, isBlank, isNotBlank, isAnyBlank, and isNoneBlank methods for Java developers.
This tutorial walks through building HTTP interface tests with the FunTester framework in Java, covering request types (GET, POST), headers, cookies, response parsing, JSON handling, and resource cleanup, and provides code examples for each step.
This article showcases an abstract Java 8 code snippet that tests developers' mastery of the language's advanced features, explains why such convoluted code is rarely used, and invites readers to share how long it took them to understand it.
Go 1.17 brings a 5% speed increase, smaller amd64 binaries, Windows ARM64 support, pruned module graphs to cut unnecessary dependencies, and three language upgrades—including slice‑to‑array pointer conversion and new unsafe functions—plus links to full release notes and downloads.
This article explains the PHP GD library function imagefilledarc, detailing its parameters, return values, and providing a complete example that creates a PNG image with filled elliptical arcs and a simple 3‑D effect.
This guide explains how to set up Alibaba Cloud's Composer mirror, provides global and project‑specific configuration commands, and offers debugging and troubleshooting steps to ensure fast and reliable PHP package management using the latest Composer version.
This guide explains how the of_device_id structure and of_device_get_match_data() function enable flexible device matching in ARM‑based SoCs, covering their definitions, usage patterns, code examples, troubleshooting tips, and how to expose device tables to user space.
This article examines the landscape of cache systems, compares four major categories, evaluates popular distributed caches such as Redis, Memcached, Tair and EvCache, explains Redis Cluster architectures and sharding strategies, and outlines common cache pitfalls with practical mitigation techniques.
This article provides a comprehensive overview of caching in large distributed systems, covering theory, common components, classification, CDN and reverse‑proxy caches, local application caches, popular implementations like Ehcache, Guava, Memcached and Redis, and a detailed comparison of their features and trade‑offs.
This article explains PHP's imagefill() function, detailing its purpose for region filling in images, describing each parameter (image resource, x and y coordinates, and color), the return values, and provides a complete example script demonstrating its usage.
This article demonstrates how to dramatically speed up importing tens of thousands of records into MySQL by evolving a naïve list‑to‑MySQL approach into grouped batch inserts and finally a multi‑threaded MyBatis solution, while also addressing packet size limits and configuration tweaks.
The article explains how designing domain models as interfaces, rather than concrete classes, improves flexibility in backend architectures by simplifying data exchange, supporting multiple persistence technologies, and enabling seamless deployment across standalone, clustered, and micro‑service environments.
This tutorial demonstrates how to capture network packets from the Super Schedule Android app, perform a login request with required headers, and repeatedly fetch and parse topic data using Python urllib2 and JSON handling, enabling infinite scrolling of user‑generated topics.
This article introduces a SpringBoot-based service that leverages OpenOffice to upload, convert (DOC/DOCX/XLS/PPT to PDF or HTML), and preview files directly in the browser, detailing built‑in features, configuration settings, and sample controller code for seamless integration.
The article explains PHP's imagecreatetruecolor function, detailing its purpose of creating a true‑color image resource, required parameters width and height, version compatibility notes, return values, and provides a complete example script that generates a PNG with custom text.
This guide explains how to build a minimal, secure Nginx server, covering the required minimal configuration and detailed usage of the root, location, and try_files directives with practical code examples and matching rules.
This article demonstrates how to copy production traffic to a pre‑release or test environment using Nginx's ngx_http_mirror_module, covering installation via YUM, configuration snippets, request‑body handling, and useful command‑line tools for managing and monitoring Nginx processes.
This tutorial walks you through installing Flask‑SQLAlchemy, configuring MySQL connections, defining models, handling various relationships, and performing full CRUD operations with code examples, enabling you to build a functional backend for a web application.
The article analyzes why duplicate OpenID entries appeared in the fast‑app center's t_account table, examines the concurrency root cause, and presents two mitigation strategies—adding a unique index and implementing a Redis‑based distributed lock—detailing their trade‑offs, implementation code, and cleanup process.
