This tutorial explains how to obtain a user's IP address from an HttpServletRequest, interpret the IP using the ip2region offline database, and display the corresponding province or country in a Java backend application, including code examples and Maven integration.
This article explains how the PHP in_array() function can return misleading results when the strict comparison flag is omitted, demonstrates the issue with a simple code example, and shows the correct usage as well as a comparable JavaScript approach using indexOf().
This article walks through a real‑world backend performance case, detailing how a batch‑score query API was trimmed from 20 seconds to under 500 milliseconds by adding composite indexes, introducing multithreaded execution, and limiting request batch size.
The Go 1.19 release candidate introduces generic bug fixes, an updated memory model aligned with C, C++, Java, JavaScript, Rust and Swift, higher default file descriptor limits, a v3 thread‑sanitizer race detector, a new "unix" build tag, LoongArch‑64 support, and a jump‑table‑based switch implementation that improves performance by roughly 20%.
This article demonstrates how to create custom Spring events, define listeners, publish events, and enable asynchronous handling with @EnableAsync and @Async annotations, providing complete code examples and test results for both synchronous and asynchronous scenarios in a Spring Cloud Alibaba micro‑service environment.
This article compiles 22 detailed case studies of backend development challenges—including Spring @Value injection failures, Docker‑based Sentinel CPU metrics bugs, Dubbo tag‑routing quirks, memory leaks in gateways, Nacos TIME_WAIT issues, Go benchmark timeouts, JDK bugs, and more—offering practical troubleshooting insights for engineers.
This article walks through the design, implementation, and optimization of a complete supplier management system built with SpringBoot, Thymeleaf, MyBatis‑Plus, MySQL, and Redis, covering project setup, configuration, core Java code, file upload handling, and caching strategies.
This article explains what microservices are, how they communicate, compares Spring Cloud and Dubbo, describes the relationship between SpringBoot and SpringCloud, defines circuit breaking and service degradation, outlines microservice advantages and pitfalls, and lists common microservice technology stacks and tools.
This article explains the concept of interface idempotency, demonstrates how to achieve idempotent update operations using version control and token mechanisms, and provides a comprehensive guide to distributed rate limiting—including time‑window and resource‑based dimensions, token‑bucket and leaky‑bucket algorithms, and practical implementations with Guava RateLimiter, Nginx, and Redis‑Lua scripts.
This article explains how to efficiently handle large‑scale batch updates in Java by splitting the data set, using a thread pool for concurrent processing, and providing reusable utility code, all illustrated with a clear workflow diagram and step‑by‑step examples.
The article examines various ways to implement precise delayed tasks such as order‑closure timers in e‑commerce, comparing message‑queue delayed delivery, Redisson DelayQueue, Redis expiration listening, RabbitMQ dead‑letter queues, and time‑wheel structures, and recommends the most reliable approaches.
The author refactors a high‑traffic gather‑order page by introducing a reusable multi‑level cache with update‑key validation, Redis distributed locks and asynchronous refresh, and by restructuring the processing flow using a chain‑of‑responsibility/command pattern, while also handling pagination, weighted sorting, and time‑bound marketing keys to improve reliability, extensibility, and performance.
This guide explains what caching is, why it’s essential for database‑driven applications, and how MyBatis implements first‑level and second‑level caches, including configuration steps, sample code, execution results, and key considerations to ensure effective cache usage.
This article uses Taobao as a case study to trace the evolution of a high‑performance backend architecture from a single‑machine setup to a cloud‑native, micro‑service ecosystem, highlighting the technical challenges and design principles at each scaling stage.
This guide explains how to set up Celery, a distributed asynchronous task framework, to use Redis both as the message broker and result backend, covering project structure, configuration code, task definition, execution, state monitoring, and common control operations.
This article explains why timeouts are inevitable in distributed systems, illustrates the challenges they create, and presents five practical strategies—including using defaults, safe retries, status checks, and user‑focused fallback—to manage slow or failed API calls in microservice architectures.
This guide explains how to replace the default PHP 5.6 with PHP 7.3 on a Linux server by editing the system profile, updating the PATH variable, and reloading the profile, including the necessary command-line steps and code snippets.
This article explains the classic HttpBasic authentication mode in Spring Security, its limited use cases, how to integrate it with a Spring Boot project by adding Maven dependencies and configuration code, and details the underlying Base64‑based mechanism with step‑by‑step illustrations.
The article outlines PHP 8.2's upcoming QA releases, the July 19 feature‑freeze deadline, newly accepted RFCs such as standalone false/null and true types, deprecation of is_callable, DNF types, and provides links to downloads, Docker images, source code and related proposals.
This article explains how Spring WebFlux automatically configures the HttpHandler, builds the HttpWebHandlerAdapter, chains WebFilters, and ultimately invokes the DispatcherHandler to process a request, detailing each class and method involved in the reactive request pipeline.
This article explains how to implement a Java backend service that determines coupon grant types by using the Strategy pattern and a Map with functional interfaces, replacing bulky if‑else logic with maintainable, extensible code, and includes full code examples and discussion of trade‑offs.
This article explains the evolution of Go's scheduler, detailing the early GM model, its limitations, and the modern GMP design with processors, local and global runnable queues, and work‑stealing, illustrating how these mechanisms enable high‑performance concurrent programs.
Network timeouts do not necessarily indicate server‑side failure; handling them with appropriate retry strategies, exponential backoff, and idempotent APIs—combined with mechanisms such as distributed locks and atomic transactions—helps maintain system stability while avoiding duplicate operations and resource exhaustion.
The article explains multiple methods for implementing asynchronous execution in Spring Boot, covering @Async annotation, Java 8 CompletableFuture, Callable, WebAsyncTask, DeferredResult, Tomcat connection tuning, container switching to Undertow, and async interception, all illustrated with complete code examples.
This article explains how Java's synchronized keyword works at the bytecode level using monitorenter/monitorexit, compares synchronized methods and blocks with explicit Lock implementations, and discusses performance, interrupt handling, and usage differences for multithreaded backend development.
This article walks through the step‑by‑step evolution of Taobao’s backend architecture—from a single‑machine deployment to distributed caching, load‑balancing, database sharding, micro‑services, and finally cloud‑native solutions—explaining the technologies introduced at each stage, the performance bottlenecks encountered, and the design principles that guide large‑scale system construction.
This article explains how to design a consistent JSON response format for Java Spring APIs, covering status codes, messages, data payloads, and how to use a custom @ResponseResult annotation together with an interceptor and ResponseBodyAdvice to automatically wrap controller results, while also discussing potential improvements and best practices.
This article walks through upgrading the open‑source Mall‑Tiny e‑commerce project to SpringBoot 2.7.0, detailing version changes for the entire technology stack, configuration tweaks, code adjustments, and deployment documentation updates to help developers perform a smooth migration.
The article describes an online customer service platform that guides users from robot chat to human agents and satisfaction rating, detailing its visitor‑side interfaces, multi‑console backend architecture, service‑hour schedules, channel‑based routing, queue‑overflow handling, reliable IM messaging with retry logic, SOP knowledge‑base assistance, and session‑termination policies.
A recent Go article sparked a lively poll and discussion about the reasonableness of Go's read‑write lock design, revealing surprising community opinions, common misconceptions, and deeper questions about reentrant locks, communication versus sharing, and Go's concurrency philosophy.
This article explains the design and implementation of distributed locks, covering database pessimistic and optimistic locks, various Redis lock patterns, Redisson and RedLock, as well as Zookeeper's lock mechanism, and compares their advantages, drawbacks, and suitable use cases.
This article explains how to solve cross‑server WebSocket communication in a distributed Java application by using a message queue (Redis or Kafka) to broadcast messages, storing user‑node mappings, and providing complete Spring configuration, code examples, and a demo page for end‑to‑end testing.
This article explains Spring's core.convert package, the ConversionService API, Formatter SPI, default and custom formatters, annotation-based formatting, and how to configure and use them in Spring MVC and Spring Boot applications.
The article explains that Fastjson sometimes throws a syntax‑error exception when deserializing a JSON list of StewardTipCategory objects because the JVM returns overloaded constructors in nondeterministic order, causing Fastjson to pick the wrong constructor; removing or renaming the ambiguous constructor fixes the issue.
This article details the end‑to‑end design of Baidu App’s personal wallet, covering background requirements, business integration, system architecture, data‑sync mechanisms, multi‑level caching, read‑write separation, data consistency, configuration management, and database sharding to achieve high availability and scalability.
The article examines how naive timestamp caching can increase CPU usage under high concurrency, analyzes implementations in Alibaba’s Cobar and Sentinel, presents performance test results, and explains Sentinel’s adaptive algorithm that switches between cached and direct timestamps based on QPS.
This article chronicles ByteDance's transition from Python to Go, the shortcomings of the first‑generation Kite RPC framework, and the design, features, performance advantages, open‑source journey, and real‑world deployment lessons of the next‑generation Kitex framework for scalable microservices.
This article provides an in‑depth overview of JSON Web Tokens (JWT), explaining their structure, authentication workflow, advantages such as statelessness and CSRF protection, drawbacks like revocation difficulty, and presents practical solutions including blacklist, secret rotation, short‑lived tokens and refresh‑token strategies.
This article presents a comprehensive case study of Baidu App’s personal wallet, detailing its background, business goals, system architecture, data‑synchronization mechanisms, multi‑level caching, read‑write separation, consistency guarantees, configuration management, and database sharding to achieve high availability and scalable performance.
This article walks through the author’s decision to continue learning Go for Redis access, outlines a step‑by‑step study plan, compares Go and Java Redis clients, presents a custom Go‑Redis wrapper with full source code, demonstrates usage in unit tests, and shares console output observations.
This article compares Python's two leading web frameworks—Flask and Django—detailing their core features, strengths, and trade‑offs, and provides guidance on when to use each based on project size, complexity, and developer preferences.
The article introduces alanpoi, a Java library that streamlines Excel import and export with millisecond‑level parsing, multi‑sheet support, error feedback, and extensible consumption interfaces, providing configuration, inheritance, and invocation examples along with annotation‑driven export capabilities.
This article explains how Guava's RateLimiter implements the token bucket algorithm to provide precise rate limiting in Java, demonstrates usage with code examples, explores the underlying token bucket mechanics, and shows extended implementations for burst capacity and token synchronization.
This article explains the REST architectural style, its core principles, resource modeling, representations, state transfer, and provides comprehensive guidelines for designing RESTful APIs, including HTTP verbs, URI conventions, versioning strategies, maturity levels, and practical code examples.
This article explains how to mask sensitive fields such as ID numbers, phone numbers, and addresses in Java APIs by creating a custom @Sensitive annotation, defining masking strategies, implementing a Jackson serializer, and testing the solution with a Spring REST controller, providing complete code examples and sample output.
This article details the design and implementation of Baidu App’s “My Wallet” feature, covering its background, business goals, system architecture, data synchronization, multi‑level caching, read‑write separation, data consistency, configurability, and database sharding to achieve high availability and performance for billions of users.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑based Spring beans and reflection‑based classes), and dynamically load, register, and unload user‑supplied JAR files at runtime through hot‑deployment mechanisms in a Java backend system.
This article explores common cache challenges such as centralized expiration, cache penetration, avalanche, hot keys, large keys, data consistency, and concurrent pre‑warming, offering practical design patterns and mitigation strategies to build robust, high‑performance backend systems.
This article introduces a lightweight Java logging utility class named LogUtils that supports four log levels, formats messages, and can output logs to the console or a file, with configurable level, target, and file settings, accompanied by example usage code.
This article explains the design and operation of an external resource manager that improves overseas e‑commerce service stability by employing CDN, local memory, and disk caches, detailing access methods, cache mechanisms, CDN configurations, and practical use cases such as Google Fonts and translation integration.
The article examines the evolution from monolithic to distributed architectures, contrasts Spring Cloud with Kubernetes and Istio, and explains how service mesh and sidecar proxies enable language‑agnostic, non‑intrusive microservice deployments in modern cloud‑native environments.
This article introduces ten common software architecture patterns—layered, client‑server, master‑slave, pipe‑filter, proxy, P2P, event‑bus, MVC, blackboard, and interpreter—explaining their structures, typical use cases, and advantages to help developers choose suitable designs for large‑scale systems.
The article explains how Tubi, an ad‑supported streaming platform with tens of millions of users, migrated from a Node.js‑Spark‑Redis stack to a Scala‑based backend to achieve sub‑10‑millisecond recommendation latency, improve fault tolerance, and simplify domain modeling using Akka and functional programming.
This article explains the fundamentals of database transactions, the ACID properties, Spring's @Transactional support, various propagation behaviors and isolation levels, and provides practical code examples for both declarative and programmatic transaction management in Java backend development.
This article explains why microservice architecture is preferred over monolithic applications, outlines a detailed learning roadmap covering core concerns such as Docker, container orchestration, API gateways, load balancing, service discovery, event buses, logging, monitoring, tracing, persistence, caching, and cloud providers, and recommends suitable tools for each component.
Short URLs are essential for many scenarios, and this article explores their components, including domain and path design, and dives into various path generation methods such as hash functions, auto‑increment IDs, distributed Snowflake algorithms, base‑62 encoding, and the trade‑offs between 301 and 302 redirects.
This article explains the core goals of microservice architecture, outlines essential design principles, and presents a comprehensive catalog of decomposition and design patterns—including Strangler, Bulkhead, Sidecar, API Gateway, Aggregator, Proxy, Chained, Branch, UI composition, database strategies, CQRS, Event‑driven, Saga, observability, logging, metrics, tracing, health checks, external configuration, service discovery, circuit breaker, and blue‑green deployment—providing practical guidance for building resilient, scalable systems.
This article walks through the complete OAuth2 token generation process, covering gateway pre‑processing, client authentication, request handling, authentication object assembly, password validation, token creation, storage options, and response handling with code examples and diagrams.
This article explains how to implement a custom PropertySourceLocator in Spring Cloud Alibaba, detailing the necessary spring.factories configuration, core classes like NacosConfigBootstrapConfiguration and NacosPropertySourceLocator, and the process of obtaining ConfigService, loading shared, extended, and application configurations from Nacos.
This article provides an extensive overview of backend architectural concepts, covering microservices fundamentals, gateway design, service registration, configuration management, observability pillars, tracing standards, logging practices, metric collection, service mesh implementations, and a detailed comparison of modern message queue technologies.
This article provides an in‑depth overview of modern backend architecture, covering microservice fundamentals, design principles, gateway patterns, service registration, configuration management, observability pillars, service mesh options, and a detailed comparison of popular message‑queue technologies.
This article presents a step-by-step guide to building a full-screen dashboard for LED displays, detailing requirement analysis, deployment options, overall architecture, key front‑end HTML/CSS layout, Echarts visualizations, back‑end Java REST API, JSON data handling, and configuration instructions.
This article explores the core goals of microservice architecture, outlines key design principles such as scalability and resilience, and presents a comprehensive catalog of decomposition, integration, cross‑cutting concern, and observability patterns—including API gateway, Strangler, Bulkhead, Saga, and CQRS—to guide developers in building robust, maintainable backend systems.
This article demonstrates how to set up an Nginx location block that proxies image requests to a PHP watermark service, provides a complete PHP Watermark class implementation, and shows a usage example for applying watermarks to images on the fly.
This article provides a comprehensive overview of microservice architecture, covering its core goals, design principles, various decomposition and integration patterns, database strategies, observability, resilience, deployment, and operational concerns, offering practical guidance for building scalable, maintainable services.
This article explains the concept of idempotency, outlines common business scenarios such as duplicate orders and payments, describes natural and required idempotent operations, and provides practical techniques—including unique keys, database constraints, and message‑queue handling—to ensure idempotent behavior in backend systems.
Redis caching can suffer from avalanche, breakdown, and penetration anomalies, but using staggered expirations, mutex locks, double‑key backups, high‑availability clusters, rate limiting, empty‑value caching, Bloom filters, warm‑up and degradation strategies effectively mitigates these risks and protects database stability.
This article provides an in‑depth overview of caching, covering its definition, when to use it, core concepts, various cache types (client, server, CDN, reverse‑proxy, in‑process, distributed), eviction policies, multi‑level cache architectures, common pitfalls such as cache avalanche, penetration and breakdown, and practical mitigation techniques.
This article explains why processing JSON in a statically‑typed language like Go can be cumbersome, demonstrates two basic approaches—using map[string]interface{} and struct tags—highlights their limitations, and introduces third‑party libraries such as SJSON and GJSON that make JSON reading and writing more concise and efficient.
This tutorial explains how to install Django with pip, create a new Django project and app, configure essential files, implement a simple HelloWorld view, and run the development server, providing step‑by‑step commands and code snippets.
This tutorial explains how to prevent overseas IP addresses from reaching a website by installing the libmaxminddb-devel dependency, adding the ngx_http_geoip2 module to Nginx, upgrading to Nginx 1.18, configuring GeoIP2 database paths, mapping country codes, and returning a 404 response for foreign requests.
This article provides a detailed examination of Node.js's built‑in path module, explaining common usage scenarios, the internal execution flow, and a line‑by‑line analysis of key utility functions like resolve and join, complete with code examples and a comparative behavior table.
This article compares three request‑merging approaches—Hystrix Collapser, a custom BatchCollapser implementation, and Guava’s ConcurrentHashMultiset—explaining their configurations, code examples, and suitable scenarios for reducing downstream load and improving system throughput while also highlighting performance trade‑offs and practical tips for integration in Spring‑Boot services.
This guide walks you through upgrading to Spring Boot 3.0 by adopting Java 17, moving to Spring Boot 2.7 first, cleaning deprecated APIs, adjusting configuration files, handling profile activation, and addressing compatibility and performance changes such as the new PathPatternParser.
This article explains the fundamental differences between RPC and HTTP services, covering OSI layers, RPC architecture, synchronous and asynchronous calls, and introduces popular RPC frameworks such as gRPC, Thrift, and Dubbo, while also showing a simple HTTP request example.
After a year of cross‑BU experimentation, the Tianji precision testing platform was built to centralize coverage data, automate incremental analysis, and provide actionable insights, resulting in higher test coverage, faster release gating, and measurable productivity gains for both developers and QA teams.
This article explains a complete backend user login process, including phone verification, token generation, token expiration strategies, gateway token validation, logout handling, anonymous request options, blacklist management, and provides a Spring‑Redis implementation for request‑rate limiting.
This article explains how to simulate user HTTP requests in automated testing by sending GET/POST requests with Java, storing and extracting cookies from the application’s cookie store, and returning them as JSON, accompanied by a complete code example.
This article presents a comprehensive summary of backend performance problems encountered in a production system—including slow queries, deep pagination, missing or ineffective indexes, excessive joins, large data volumes, thread‑pool and lock mis‑designs, machine issues, and caching strategies—along with concrete diagnostic steps and code‑level remedies to improve response times and stability.
Spring Security OAuth has reached end‑of‑life, with its documentation removed and code moved to a read‑only Spring attic repository; this guide explains how to detect deprecated dependencies, replace them with Spring Security 5.7’s OAuth2 Client, Resource Server, and the new Spring Authorization Server, ensuring a smooth migration to modern, supported authentication solutions.
The Hasura Storage team rewrote their Node.js service in Go, ran k6 benchmarks, and achieved up to five times more request handling, half the memory usage, and significantly lower response times across multiple download scenarios, demonstrating the scalability benefits of Go for backend services.
The article explains how Facebook built a stable, abstracted integration‑testing infrastructure for backend services, combining automated testing, fuzzing, record‑and‑playback, and isolation techniques to enable rapid prototyping while avoiding side effects and improving bug detection.
This article introduces the open‑source mall‑tiny rapid‑development scaffold, explains its core features and integration with the mall‑admin‑web front‑end, and provides a step‑by‑step guide to upgrading it to Spring Boot 2.7.0, covering Swagger, Spring Security, MyBatis‑Plus, circular‑dependency resolution, and CORS configuration.
This article explains how to design and implement a flexible, strategy‑pattern‑based state machine for e‑commerce after‑sale services, covering action abstraction, synchronous vs asynchronous execution, compensation via delayed MQ, and execution delay techniques to improve reliability and performance.
Facing billions of cached hotel records, Ctrip’s backend team analyzed Java object layout and HashMap memory costs, evaluated alternative structures, and applied bitmap, dictionary, run‑length and delta encodings to compress data, ultimately reducing cache size to under 2% of its original footprint.
The article explains how to address single‑point failures and capacity limits by clustering servers using replication patterns and introduces the AKF microservice splitting principle, detailing X‑axis horizontal replication, Y‑axis business‑oriented division, and Z‑axis data‑driven partitioning with diagrams.
This article explains three Redis‑based rate‑limiting methods—using SETNX for simple counters, leveraging ZSET for a sliding‑window algorithm, and implementing a token‑bucket scheme with LISTs—complete with Java code examples and discussion of their advantages and drawbacks.
This article explains how to shift authentication and authorization from the gateway to downstream Spring Cloud microservices by removing the gateway's ReactiveAuthorizationManager, defining three custom annotations (@RequiresLogin, @RequiresPermissions, @RequiresRoles), creating an AOP aspect to enforce them, and demonstrating their usage in controller methods.
This article walks through the background of a production Java service that received many performance complaints, enumerates common causes such as slow MySQL queries, complex business logic, thread‑pool misconfiguration, lock contention and machine issues, and provides concrete diagnostic steps and code‑level solutions including pagination fixes, indexing strategies, async processing, thread‑pool tuning, lock refinement and caching techniques.
This article provides a comprehensive overview of microservice architecture, covering its definition, history, differences from monolithic development, key characteristics, comparison with SOA, practical implementation steps, common design patterns, advantages and disadvantages, and essential considerations for successful adoption.
To handle dynamic file changes such as rule updates, configuration reloads, or log monitoring, this article compares three Java approaches—simple polling with File#lastModified, the OS‑integrated WatchService API, and the Apache Commons‑IO monitor—detailing their implementations, advantages, drawbacks, and practical usage tips.
The article compares delayed and scheduled tasks and presents five backend solutions—database polling with Quartz, JDK DelayQueue, Netty's HashedWheelTimer, Redis ZSET, and RabbitMQ delayed queues—detailing their implementations, code examples, outputs, and pros and cons.
Spring Boot 2.7.0 introduces major enhancements such as a new @AutoConfiguration annotation, upgraded Flyway modules, H2 2.1 support, GraphQL starter, Podman integration, Cache2k auto‑configuration, and several deprecations and test annotation improvements, providing a comprehensive update for Java backend developers.
This article introduces eight typical software architecture design patterns—including single-database single-application, content distribution, query separation, microservices, multi-level caching, sharding, elastic scaling, and multi-datacenter deployment—explaining their structures, typical use cases, advantages, disadvantages, and practical considerations for building scalable, reliable systems.
This article explains what rate limiting is, why it is needed, various strategies and algorithms such as leaky bucket, token bucket, fixed and sliding windows, and discusses challenges like inconsistency and race conditions in distributed systems, as well as different throttling types.
This article explains how to unify error handling between gRPC and traditional HTTP services by defining shared protobuf messages, mapping gRPC status codes to HTTP responses, and customizing response structures with additional fields like stat and msg for consistent business‑level error reporting.
This article examines how PHP stores variables internally by analyzing the zval structure defined in the C source code, detailing its fields, type flags, memory layout, and associated macros, and explains why each variable occupies 16 bytes at runtime.
This article walks through a simple Java file‑change watcher, reveals a JDK 8/9 bug where lastModified returns seconds instead of milliseconds, demonstrates the issue with test code, and presents a version‑file workaround to reliably detect updates.
The article introduces eight widely used software architecture design patterns—including single‑database, content distribution, query separation, microservices, multi‑level caching, sharding, elastic scaling, and multi‑datacenter deployment—explaining their typical structures, suitable scenarios, and the key pros and cons of each.
After upgrading to Spring Boot 2.6, a NullPointerException occurs when integrating Swagger due to the new PathPatternParser, and the issue can be resolved by changing the path‑matching strategy to ant_path_matcher or adding a custom WebMvcEndpointHandlerMapping bean.
