This article explains how Spring Boot's spring-retry module and the @Retryable annotation enable clean, annotation‑driven retry logic for common failure scenarios, covering configuration, code examples, recovery handling with @Recover, and important usage precautions.
This article introduces Hippo4J, a Java dynamic thread‑pool solution inspired by Meituan's design, detailing its web‑based parameter tuning, monitoring, alerting capabilities, two deployment modes (lightweight with config‑center and standalone server), and the operational advantages it brings to developers and operators.
This article presents sixteen practical Spring Boot best‑practice recommendations—including custom BOM management, auto‑configuration, project initialization with Spring Initializr, clean controller design, service layering, database isolation, constructor injection, logging, testing, and configuration externalization—to help developers build maintainable, high‑quality microservices efficiently.
This article explains the conditions that cause ThreadPoolExecutor’s RejectedExecutionHandler to fire, reviews the built‑in policies such as DiscardOldestPolicy, AbortPolicy, CallerRunsPolicy and DiscardPolicy, provides their source code, and offers practical advice on selecting and avoiding pitfalls when handling rejected tasks in Java concurrency.
This article explains the three stages where RabbitMQ messages can be lost and presents a comprehensive reliability strategy—including producer confirm mode, durable exchanges/queues, message persistence, database‑backed compensation, and manual consumer acknowledgments—to achieve virtually loss‑free message delivery.
The article advises using a private static final Object as a lock to protect critical sections in Java, explains why uncontrolled monitor objects such as this, class objects, or shared interned strings can cause deadlocks, and lists unsafe and safe monitor objects with examples.
This article explains how Spring implements broadcast and listener functionality through ApplicationEventPublisher and ApplicationListener, analyzes the underlying bean post‑processor workflow, and provides complete source‑code examples for custom events, publishers, listeners, and a REST client to demonstrate end‑to‑end event handling.
This article provides a theoretical overview of seven major Java performance optimization techniques—including code reuse, computation parallelism, asynchronous processing, lazy loading, result set reduction, resource conflict handling, and JVM tuning—offering readers a comprehensive framework to understand and improve application efficiency.
This article presents a theoretical overview of seven major Java performance‑optimization directions—including reuse, parallel execution, async conversion, result‑set trimming, resource‑conflict handling, algorithm tuning, and JVM tuning—explaining their principles, typical techniques, and practical considerations for developers.
This article explains how to implement single-node scheduled tasks using JDK's ScheduledExecutorService and Spring @Scheduled, compares Redis‑based approaches with ZSet and key‑space notifications, and reviews popular distributed scheduling frameworks such as Quartz, elastic‑job‑lite, LTS, and XXL‑Job for microservice environments.
This article introduces a fully functional, open‑source Baidu Wenku‑style document library built with Go/Beego, Bootstrap, and MySQL, detailing its architecture, SVG‑based document rendering, point system, watermarking, and how to obtain the source code.
When two JARs contain identically named classes and methods but differ in a method's return type, Java's class‑loading mechanism may load the wrong version, triggering a java.lang.NoSuchMethodError, which can be prevented by detecting duplicate classes with Maven Enforcer rules.
This article explains how to make a child thread inherit the values stored in a parent thread's ThreadLocal by using InheritableThreadLocal, demonstrates the behavior with a runnable Java example, and details the underlying ThreadLocalMap mechanism that enables the inheritance.
This article presents sixteen essential Spring Boot best practices—from managing dependencies with a custom BOM and leveraging auto‑configuration, to structuring packages, using constructor injection, handling concurrency, externalizing configuration, and comprehensive testing—helping developers build maintainable, high‑performance Java microservices.
This article explains how to use Spring Boot to add WebSocket support, covering the protocol basics, Maven dependencies, configuration classes, a test controller, a simple HTML client page, and troubleshooting tips, all illustrated with complete Java and JavaScript code examples.
This article explains how Airwallex uses Domain-Driven Design (DDD) to model a complex payment system, detailing strategic and tactical patterns, bounded contexts, domain events, and the translation of domain models into microservice architectures, while highlighting the benefits of clear communication and modular design.
This article presents sixteen practical Spring Boot best‑practice recommendations—from managing dependencies with custom BOMs and leveraging auto‑configuration to structuring packages, handling concurrency, externalizing configuration, and adopting testing strategies—aimed at building clean, maintainable microservices.
This article compares traditional object creation with Spring’s dependency injection, demonstrating how injecting DAO beans via XML configuration decouples service and data layers, includes Java code examples, test results, and visual analogies of gear systems to illustrate reduced coupling.
This tutorial explains how to build a highly available, horizontally scalable distributed scheduled‑task system using Quartz in a Spring Boot application, covering application scenarios, Maven dependencies, database initialization, configuration properties, job and scheduler code, and verification of failover behavior.
The Apache APISIX community announced the 2.13.0 LTS release, enhancing stability, adding observability plugins, a new OpenTelemetry tracing plugin, multi‑language (Wasm, Python, Go) support, and a comprehensive list of bug fixes and improvements.
This article shares sixteen practical Spring Boot best‑practice recommendations—ranging from custom BOM management and auto‑configuration to proper package layout, constructor injection, concurrency awareness, externalized configuration, logging, testing, and global exception handling—to help developers build clean, maintainable Java microservices.
This guide shows how to enable hot‑deployment in Spring Boot using DevTools, simplify JavaBean code with Lombok, and add the Spring Configuration Processor for better property‑binding support, including Maven dependencies, IDE settings, and example snippets.
This article explains how to configure Logback in a Spring Boot application to separate logs by level, implement asynchronous logging with AsyncAppender, and compare performance using JMeter, demonstrating a tenfold throughput increase while providing detailed XML configuration examples and underlying implementation details.
This article introduces Alibaba's EasyExcel library, explains its memory‑efficient design, lists its main advantages and common annotations, provides Maven dependencies, and demonstrates import and export code snippets for Java backend applications.
Spring Boot 3.0.0 M2, released on March 25, 2022, brings 50 bug fixes, documentation enhancements, and dependency updates, revisits the M1 changes such as Java 17 baseline and Jakarta EE migration, and adds features like restored EhCache 3 support, H2 Console, and improved @ConstructorBinding detection.
The March 19 Elixir Meetup brought together four seasoned Elixir practitioners and over 3,200 online attendees to discuss resilience with Elixir and Kubernetes, FaaS design using Arweave and LiveView, native compilation of Elixir, Zig‑based NIF development, and to share learning resources and community opportunities.
The article outlines how F5 announced a complete stop to its sales in Russia and withdrew support for the Nginx open‑source project, recounts Nginx’s Russian origins, its rapid market growth, acquisition by F5, and the broader irony of a Russian‑born server now barred from the country.
This article explains the concept of API idempotency, why duplicate requests can cause critical issues such as double payments, and presents a comprehensive set of client‑side and server‑side strategies—including token mechanisms, PRG pattern, unique indexes, optimistic locking, distributed locks, and more—to guarantee safe, repeatable operations.
This article explains how Java objects store behavior in the method area, introduces the java.lang.instrument.Instrumentation API for redefining classes at runtime, and demonstrates practical dynamic tracing techniques using BTrace and Arthas, complete with code examples and architectural insights.
This article explains Spring's bean lifecycle, the three‑level cache mechanism (singletonObjects, earlySingletonObjects, singletonFactories) used to break circular dependencies, the role of Aware interfaces and BeanPostProcessor, and why a second‑level cache is essential when AOP proxies are involved.
The author recounts submitting a Go PR to fix a benchmark timeout overflow bug, detailing the code review feedback, overflow detection issues, testing strategies, and proper commit‑message conventions, ultimately sharing insights from a largely unsuccessful contribution attempt.
This article explains how to make a Spring MVC endpoint simultaneously accept JSON, URL‑encoded form data, and multipart/form‑data by creating a custom @GamePHP annotation, implementing dedicated argument resolvers, and configuring the necessary beans to replace the default @RequestBody and @RequestParam handling.
This guide demonstrates how to build a distributed multi‑tenant database using Django with Postgres and Citus, covering installation, supported Django versions, model modifications via mixins or inheritance, middleware for tenant context, automatic composite foreign keys, and the library’s API with concrete code examples.
An in‑depth analysis shows that in Spring Boot 2.0.3 a @Configuration class defining a @Bean can override a @Component‑annotated bean of the same type, how the Spring container registers and replaces the bean definitions, and the evolution of bean‑overriding controls in later Spring and Spring Boot releases.
This article walks through upgrading a Spring Boot project to version 2.6.x, explains why circular bean dependencies and Swagger failures occur after the upgrade, and provides step‑by‑step configuration changes—including allowing circular references, using @Lazy, and adjusting MVC path‑matching—to resolve the problems.
This article introduces the open‑source Go generic utility library samber/lo, explains how to install Go 1.18 beta and the library, and demonstrates common operations such as type conversion, concurrent processing, containment checks, filtering, deduplication, grouping, chunking, and ternary-like expressions with concise code examples.
Google’s Go 1.18 release introduces native fuzz testing, generics support, module workspaces, and up to 20% performance gains on ARM64 and Apple M1, enhancing security and productivity for developers while reinforcing Go’s pivotal role in cloud‑native projects like Kubernetes and Docker.
This article explains two Spring Security configuration approaches, introduces a custom @IgnoreAuth annotation, and shows how to automatically whitelist annotated endpoints by scanning RequestMappingHandlerMapping, complete with code examples and workflow details.
This article walks through the fundamentals of Spring’s IoC container by manually implementing a lightweight version, covering concepts such as IOC, DI, bean definitions, resource loading, bean registration, and a simple BeanFactory with example code and a test demonstrating singleton caching.
The Luxury strategy‑center platform solves extensibility by defining a unified hook interface using the Adapter pattern, schema‑driven forms, and flat key‑value outputs, allowing operators to configure third‑party integrations via visual mappings without code changes, cutting integration time to half a day and fostering reusable assets.
This guide highlights the most influential Java books—from core language fundamentals and JVM internals to concurrency and effective coding practices—explaining why each title is vital for building a solid backend development skill set.
This article explores the inner workings of Java’s CountDownLatch from JDK 1.8, detailing its core concepts such as the counter, thread synchronization, shared mode, and AQS mechanisms, and demonstrates practical usage through step‑by‑step code analysis and examples.
This article details Ant Group’s Needle platform, a progressive Node‑based FaaS solution that tackles BFF development challenges through function‑level isolation, dynamic deployment, high‑availability design, and a roadmap for future performance and cost optimizations.
An extensive SpringBoot guide covering its definition, benefits, core configuration files and formats, main annotations, activation methods, container independence, run options, auto‑configuration mechanics, new 2.x features, pagination, security, ActiveMQ, YAML, Actuator, Swagger, exception handling, request mapping nuances, legacy compatibility, protection strategies, executable jar differences, and task scheduling.
This article explains how to use OpenResty and Lua to integrate Redis caching, compress responses, schedule periodic updates, and configure URL‑based cache rules directly within Nginx, improving concurrency and resilience of web services.
This article explains the internal architecture of Nacos, its core components, the registration principles of service instances, how Spring Cloud integrates Nacos through the ServiceRegistry interface and auto‑configuration, and the mechanisms for heartbeat, data consistency, and dynamic service discovery in a cloud‑native backend environment.
The article introduces MyBatis‑Pro, a Spring‑Boot starter that eliminates manual single‑table SQL by generating CRUD methods through naming conventions, explains quick integration, core features, configuration options, entity annotations, logical‑delete strategies, generic services, and provides extensive code examples for developers.
The article presents thirty practical architectural principles—ranging from simplicity, YAGNI, iterative development, automated testing, and ROI to server concurrency, distributed system design, user experience, and configuration management—aimed at guiding engineers and teams toward robust, scalable, and maintainable software solutions.
This article walks through EggJS’s core design principles, demonstrates building a simple GitHub aggregation API, shows how to evolve reusable code into plugins and custom frameworks, and explains progressive development practices for large‑scale enterprise applications, highlighting configuration, plugin management, and framework layering.
This article shares a junior engineer's detailed journey of securing a backend engineering offer at Tencent, covering three interview rounds, key technical topics like Spring, HashMap, Elasticsearch, Redis, and personal reflections on strengths, weaknesses, and preparation strategies.
This article examines Node.js hot‑update mechanisms, explains how modules like clear‑module and decache can cause memory, resource, and versioning leaks, demonstrates real‑world examples with code, and offers guidance on when hot‑reloading is safe and how to mitigate its pitfalls.
This article explains why Spring Cloud Gateway may emit duplicate Access-Control-Allow-Origin and Vary headers during CORS handling, analyzes the internal processing flow, and provides two practical solutions—using DedupeResponseHeader configuration or a custom GlobalFilter—to eliminate the duplication.
This article explains how to replace inefficient traditional delay mechanisms with RabbitMQ's delayed‑queue plugin, showing step‑by‑step configuration, producer and consumer code in Spring Boot, and demonstrates successful delayed message delivery using real‑world examples such as auto‑confirm orders and ticket reservations.
This article explains why traditional delayed‑message solutions like Redis expiration, database polling, or JVM DelayQueue are inefficient, and demonstrates how to use RabbitMQ's delayed‑queue plugin with Spring Boot to configure exchanges, send delayed messages, and consume them reliably.
This article explains why Spring Boot creates only one UserManager bean when both @Configuration + @Bean and @Component definitions exist, how the bean definition overriding mechanism works across different Spring versions, and how to control it with the allowBeanDefinitionOverriding setting.
This article shares a comprehensive Java concurrency interview guide covering thread states, communication methods, and key concepts, and explains how to obtain the full PDF resource via a WeChat public account.
This article explains the fundamentals of message queues, their typical use cases such as decoupling, asynchronous processing, and traffic shaping, compares popular MQ products, and outlines best practices for high availability, loss prevention, idempotency, ordering, backlog handling, and expiration management.
This article explains how using the uppercase YYYY pattern in Java's SimpleDateFormat can incorrectly shift dates to the next year for week‑based years, demonstrates the issue with sample code, and provides guidance to avoid this subtle bug in date handling.
This guide introduces RedisMod’s enhanced modules, shows how to install Redis with Docker, demonstrates native JSON storage using RedisJSON, walks through building and querying a full‑text search index with RediSearch—including Chinese support—and compares its performance against Elasticsearch.
This article walks through Redis’s annotated source code to explain how its single‑threaded architecture initializes the server, loads configuration and data, and continuously processes file and time events within a while‑loop, revealing why Redis achieves high performance without spawning additional worker threads.
This article examines Redis's single‑threaded architecture by walking through its source code, detailing the main function initialization steps, the event‑loop implementation, and how file and time events are processed, while also noting the promotional messages interspersed throughout.
This article explains how Spring's bean lifecycle and its three-level caching mechanism—singletonObjects, earlySingletonObjects, and singletonFactories—work together to resolve circular dependencies, especially when AOP proxies are involved, highlighting why a three‑cache approach is necessary.
This comprehensive guide explains what Nginx is, its key advantages, typical use cases, request processing flow, high‑concurrency model, proxy types, directory layout, configuration directives, load‑balancing strategies, rate‑limiting, compression, health checks, and differences from Apache, providing practical examples and code snippets for backend developers.
This article examines various delayed‑message implementations in distributed message‑queue systems, comparing external‑storage approaches using databases, RocksDB and Redis, and reviewing built‑in solutions in open‑source MQs such as RocketMQ, Pulsar and QMQ, while discussing their advantages, drawbacks and design considerations.
This article explains how ZuanZuan's operations team applies Go's error handling mechanisms—including error values, panic/recover, sentinel errors, and custom error types—along with practical guidelines and code examples to improve reliability and maintainability of production services.
This article presents 16 practical Redis use cases—including caching, distributed sessions, locks, global IDs, counters, rate limiting, bitmaps, shopping carts, timelines, message queues, lotteries, likes, product tags, filtering, follow relationships, and ranking—detailing data types, commands, and implementation tips for building scalable backend services.
This article details the design and implementation of an online customer service instant messaging system, covering requirements analysis, client‑server network model, HTTP and WebSocket protocols, distributed architecture choices such as routing rules, Redis shared memory, server‑master sync, and message‑queue broadcasting, and explains why Netty was selected as the development framework.
This article explains three Redis‑based rate‑limiting techniques—setnx with expiration, a sliding‑window implementation using sorted sets, and a token‑bucket algorithm with lists—complete with Java code examples and discussion of their advantages and limitations for high‑concurrency backend services.
This article provides an in‑depth Java Stream API tutorial, covering stream creation, intermediate operations like filter, map, flatMap, and terminal operations such as forEach, reduce, collect, with numerous real‑world employee‑data examples and complete code samples.
The article compares popular Java microservice frameworks, highlighting Spring Boot's ease of use but high memory consumption, Vert.x's lightweight performance, and the characteristics of SparkJava, Micronaut, Javalin, and Quarkus, while also noting required infrastructure components for Spring Cloud.
This tutorial explains the advantages of WebSocket over HTTP and provides a step‑by‑step guide, including Maven dependency, Spring Boot configuration, a ServerEndpoint class, a simple HTML/JavaScript front‑end, and a controller method, to build a real‑time chat system with online/offline notifications and private or broadcast messaging.
This article describes how a Python‑based diff utility was created to compare old and new API responses during a promotion change‑record migration, detailing its implementation, handling of JSON structures, improvements over the first version, and plans for integration with an API testing platform.
This article explains how to redesign Spring Security's captcha authentication by creating a custom filter configurer, detailing the inheritance hierarchy, code implementation, and integration into a SecurityFilterChain for clean, reusable authentication handling.
This article provides a comprehensive guide to optimizing SpringBoot services, covering metric exposure with Prometheus, custom business monitoring, Java flame‑graph profiling, SkyWalking distributed tracing, HTTP and Tomcat tuning, layer‑wise code improvements, and practical code examples for real‑world performance gains.
This article revisits the fundamentals of Spring AOP, detailing its core annotations such as @Before, @After, @Around, and their execution sequence, while providing a complete demo project, code examples, and insights into common pitfalls like proxy failures and multi‑aspect ordering.
The article introduces PHP's FFI extension, explains how to call C libraries such as libbloom, manipulate Linux namespaces, and use raylib for graphics, provides complete code examples, and discusses performance considerations, offering a practical guide for backend developers.
This article presents a curated collection of Spring Framework utility classes—including assertion helpers, object/array/collection utilities, file and resource IO tools, as well as reflection and AOP utilities—providing ready‑to‑use methods that replace many custom helper functions in Java backend development.
This article walks through how MyBatis parses the transaction manager factory from XML configuration, builds the Environment, and applies the transaction manager during SqlSession creation, including detailed code examples of XMLConfigBuilder, transaction factories, and the JdbcTransaction implementation.
This tutorial explains how to embed Dataway—a zero‑code API configuration UI built on DataQL—into a Spring Boot application by adding Hasor dependencies, configuring properties, setting up required database tables, wiring the data source into Hasor, enabling Hasor annotations, and finally creating and publishing APIs through the Dataway UI.
This article dissects Netty’s core connection‑acceptance mechanism, explains how the OP_ACCEPT event is processed, reveals a subtle bug that limits read loops to a single connection, and shows the fix introduced in version 4.1.69.final, offering developers a complete understanding of Netty’s reactor architecture.
This article provides a comprehensive overview of Tomcat, covering its role as a Java web server, internal components such as Server, Service, Connector and Container, lifecycle management, deployment methods, connector implementations (BIO, NIO, APR), Comet support, and asynchronous servlet processing, with code examples for thread handling.
This article explains how to guarantee that insert messages are processed before update messages for the same data identifier across different Kafka topics by applying fine‑grained distributed locks and a caching strategy to detect and correct out‑of‑order consumption.
The article outlines the major updates in Spring Boot 3.0.0 M1, including the jump to Java 17, migration from Java EE to Jakarta EE, removed legacy support, upgraded Spring and third‑party dependencies, and the roadmap for upcoming milestone releases.
This article introduces PyWebIO, a Python library that lets developers create web‑based interactive applications with simple input and output functions, eliminating the need for HTML or JavaScript, and demonstrates installation, a BMI calculator example, and core input/output APIs.
This article explains how Spring’s @Transactional annotation leverages AOP dynamic proxies and the TransactionInterceptor to automatically manage transaction boundaries, reducing boilerplate code and allowing developers to focus on business logic.
The article reviews the latest Spring Native 0.11.2 and Spring Authorization Server 0.2.2 releases, detailing new features, compatibility changes, bug fixes, and dependency upgrades that impact cloud‑native Java applications and backend security.
Discover the MyBatis Generator GUI tool that streamlines Java POJO and mapping file creation, outlines its six key features, system requirements, and three easy startup methods—including self‑build, IDE launch, and native packaging—so you can quickly generate MyBatis code.
This article demonstrates how to refactor a coupon‑type service by applying the Strategy pattern and a Map combined with Java 8 lambda expressions, eliminating bulky if‑else or switch statements while improving maintainability and readability.
The article explains how Spring Boot 3 drops Java 8, embraces Java 17 and Spring 6, outlines the major framework changes, removed components, and offers practical advice on when and why developers should consider upgrading.
This article explores comprehensive API lifecycle management, detailing how a lightweight API gateway works with a robust development platform that uses object‑driven modeling to generate contracts, map to databases, publish services, handle testing, documentation, rule processing, and visual service orchestration.
This article explains how an API development platform can manage the full API lifecycle—design, development, testing, deployment, monitoring, and orchestration—by leveraging object‑driven modeling, automatic CRUD generation, rule processing, service composition, and source‑code export for microservice deployment.
This article explains how to design consistent API return codes and messages, using HTTP status code concepts, segmenting error codes, providing human‑readable messages, enabling personalized user messages, and centralizing handling to improve communication, debugging, and monitoring in backend development.
The article reviews VS Code’s 2021 updates, outlines its 2022 roadmap centered on six key areas—including extensive Spring Boot enhancements—and speculates that these improvements aim to keep VS Code competitive against JetBrains’ upcoming Fleet IDE for Java developers.
The article explains why a well‑designed API return‑code system—modeled after HTTP status codes, with clear numeric ranges, descriptive messages, and personalized user messages—reduces communication overhead, simplifies maintenance, and enables effective monitoring and alerting for backend services.
The article chronicles Igor Sysoev’s exit from NGINX and F5, recounts the creation and evolution of NGINX from its 2004 open‑source launch to its 2019 acquisition by F5, and highlights its rise to become the world’s most widely used web server.
This tutorial walks through creating a Spring Boot lottery application that caches activity, prize, and record data in Redis, covering project setup, Maven dependencies, YML configuration, MyBatis‑Plus code generation, Redis key management, lottery API, event‑driven data loading, stock handling, and asynchronous record saving.
This article presents a step‑by‑step guide to building a Spring Boot lottery application that leverages MyBatis‑Plus and Redis for caching activity, prize, and record data, covering project setup, dependencies, configuration, code generation, Redis integration, lottery logic, and stock management.
Spring Boot 3.0.0 M1, released on January 20 2022, upgrades the Java baseline to Java 17, migrates all Java EE APIs to Jakarta EE, drops support for several components, updates numerous Spring and third‑party dependencies, and outlines the upcoming release schedule.
FastAPI is a high‑performance, easy‑to‑learn Python web framework that lets you build robust APIs quickly, offering features like speed, concise code, automatic validation, and OpenAPI compatibility, with simple installation via pip and interactive documentation out of the box.
This article explains how to correctly load resources in Java using Class and ClassLoader getResource methods, compares their behavior, demonstrates batch resource retrieval, and shows how Spring's ResourceLoader and ResourcePatternResolver simplify resource access, providing practical code examples and best‑practice guidelines.
