The article explains why serial REST calls cause performance bottlenecks, illustrates the benefits of concurrent requests, and demonstrates how Java 8's CompletableFuture can be used to implement parallel REST calls with robust exception handling, improving throughput and resource utilization.
This article explains how Spring Boot controllers can return up to 17 different response types—including @ResponseBody, HttpEntity, ResponseEntity, HttpHeaders, ErrorResponse, ProblemDetail, String views, ModelAndView, @ModelAttribute, DeferredResult, Callable, CompletableFuture, ResponseBodyEmitter, SseEmitter, StreamingResponseBody, Flux and Mono—providing code examples, usage notes, and sample output images for each.
This article introduces several Java code quality tools—including Alibaba Java Coding Guidelines, CheckStyle, PMD, FindBugs, and SonarLint—detailing their installation, usage, and key features to help developers improve code standards, detect bugs, and streamline code review processes.
Log4j2’s asynchronous logging can cause thread blocking when the Disruptor ring buffer fills, a problem explored through its architecture, root causes, and practical mitigation strategies such as dual‑track log classification, bytecode‑enhanced line‑level control, Maven plugins, and IDE integrations for dynamic log management.
When a manager demands a script to move a 700‑terabyte database under a 2 Mbps bandwidth cap, the realistic solution combines physical Sneakernet transfer with a carefully staged export‑transform‑load script that handles field mapping, compression, rate‑limited transport, and fault‑tolerant import.
This article shares a candidate's interview experience at McDonald's China Technology R&D Center, detailing salary expectations, work schedule, and an extensive technical Q&A covering IoC/DI, MyBatis, JVM memory and garbage‑collection algorithms, MySQL storage engines, concurrency, locking, RPC, HTTPS, Docker/Kubernetes commands, and Git workflows, while also including some promotional material.
This article explains how to design and implement a plugin mechanism in Java and Spring Boot, covering the benefits of modular decoupling, common implementation patterns such as ServiceLoader and custom configuration files, and practical code examples for building extensible backend services.
This article explains the root causes of Java NIO empty polling, its impact on CPU usage, and presents Netty's multi‑layer detection, threshold‑based auto‑rebuild, and selector reconstruction techniques, along with configuration tips and future optimization directions for high‑concurrency backend systems.
This article explains Java's Service Provider Interface (SPI) mechanism, compares SPI with traditional APIs, and provides a step‑by‑step guide—including Maven project setup, interface definition, implementation classes, custom class loader, and Spring Boot integration—to build a dynamic plugin system for backend applications.
Facing a sudden 35% error rate in a payment API, the article explores why unprotected services crash, then details four common rate‑limiting algorithms—fixed window, sliding window, leaky bucket, token bucket—offering Java implementations, real‑world case studies, pitfalls, and performance tuning tips for production systems.
This article explains how Spring Cloud automatically wraps managed thread pool beans with trace-enabled proxies to preserve distributed tracing information, details the ExecutorBeanPostProcessor implementation, shows the relevant configuration and instrumentation code, and notes that manually created executors must be wrapped manually.
The article explains how the MemberClub open‑source project leverages a flow engine and plugin extension engine to achieve business code isolation and extensibility, illustrating the problems of if‑else branching in multi‑business systems, providing configuration examples, execution principles, and Java code snippets.
This article examines the causes of Log4j2 asynchronous logging blockage in high‑throughput Java services, explains the underlying Disruptor mechanics, and proposes a dual‑track logging architecture with compile‑time bytecode enhancement and IDE plugins for line‑level log activation.
This article introduces LeetCode problem 1448 about counting good nodes in a binary tree, explains the definition of a good node, provides example inputs and outputs, outlines constraints, offers a detailed DFS analysis, and presents complete Java and C++ implementations.
The article explains how to reduce latency in SparkStreaming jobs that heavily interact with Redis by using connection pools, batch sizing, pipeline techniques, and custom JedisCluster pipelines, while also covering Redis deployment modes, Codis proxy, and practical Java/Scala code examples.
An overview of two‑level caching architecture, the motivations for using local in‑memory caches, essential features of a local cache, comparative analysis of implementations using ConcurrentHashMap, Guava Cache, Caffeine, and Ehcache, and strategies for consistency, hit‑rate improvement, and practical code examples.
This article explains how to use Spring's built‑in cache annotations such as @EnableCaching, @Cacheable, @CachePut, and @CacheEvict to implement Redis‑backed caching in a Spring Boot application, covering configuration, core code, testing, and practical considerations for cache consistency and expiration.
This article introduces QLExpress, Alibaba's open‑source lightweight dynamic script engine, explains its thread‑safe and high‑performance features, compares it with other rule engines, and provides comprehensive Java examples covering integration, syntax, custom operators, functions, macros, dynamic parameters, collection handling, and traversal for enterprise rule management.
This article provides a step‑by‑step guide for integrating Alipay sandbox payment into a Spring Boot backend, covering sandbox configuration, network tunneling, Maven SDK dependency, application properties, payment request creation, callback processing, and common troubleshooting.
This article explains how to refactor Spring MVC controllers by introducing a unified response wrapper, using ResponseBodyAdvice for automatic packaging, handling String conversion issues, applying JSR‑303 validation for request parameters, creating custom validators, and defining centralized exception handling to keep controller code clean and maintainable.
This article explains RabbitMQ's transaction mechanism, outlines its basic workflow, core channel methods, provides a Java example, compares its advantages and disadvantages with the confirm mode, and offers guidance on choosing the appropriate approach for different scenarios.
This article demonstrates how to enable conversation memory and history in Spring Boot 3 applications using Spring AI's Advisor API, covering environment setup, Maven dependencies, configuration, code examples for advisors, unique chat IDs, history retrieval, and optional database persistence.
This article explains why and how to enforce the use of trace‑aware thread pools in Spring Cloud, presenting three approaches—including TraceableExecutorService, Tracer.currentTraceContext().wrap, and TraceCallable/TraceRunnable—to prevent loss of distributed tracing information in multithreaded applications.
This article introduces the JDFrame and SDFrame Java libraries that provide DataFrame‑like, semantic stream processing APIs, demonstrates how to add Maven dependencies, shows quick‑start examples, detailed CRUD, filtering, grouping, sorting, joining, pagination, and other advanced operations with full code snippets for developers.
This tutorial shows how to obtain a user's current latitude and longitude via an IP API, send the coordinates to a backend service that stores charging stations in Redis GEO, and query stations within a 20‑kilometer radius, with complete front‑end and back‑end code examples.
This article explains how to replace Spring Boot's default embedded Tomcat server with Undertow, detailing Undertow's features, Maven dependency changes, performance and memory benchmarks, and provides step‑by‑step configuration code to improve high‑concurrency Java web applications.
This tutorial explains how Spring's @Transactional and @Async annotations work, explores their interaction in various scenarios such as bank‑transfer examples, discusses thread‑context propagation, highlights pitfalls when mixing them, and provides best‑practice recommendations for maintaining data integrity.
This article explains two common approaches for configuring Java thread pools—static sizing based on CPU‑bound or I/O‑bound workloads and a formula‑driven method—then critiques their limits in real systems and introduces DynamicTp as a flexible, monitoring‑enabled alternative with code examples and architectural details.
This article explains what delayed queues are, details two RabbitMQ implementations using TTL with dead‑letter exchanges and the rabbitmq‑delayed‑message‑exchange plugin, provides full Java configuration and producer/consumer code examples, and outlines common use‑cases such as order timeout and refund processing.
This article explains Java's labeled break statement, showing its syntax, a practical example with code, discusses its potential as a code smell, outlines appropriate use cases, and offers guidance on when to prefer refactoring for clearer control flow.
This comprehensive guide walks you through Spring Boot 3 AOP fundamentals, showing how to declare aspects with @Aspect, define pointcuts using @Pointcut, apply various advice types, manage ordering, bind method parameters, and leverage inter‑type declarations with clear code examples and diagrams.
This article explains how to generate a unique traceId for each request, propagate it through Rest, RocketMQ, and Dubbo RPC modules, and configure Log4j2 (including custom Message, MessageFactory, and PatternConverter) to output the traceId so that logs across services can be correlated and read sequentially.
This article introduces Spring Framework's ResponseBodyEmitter, explains its role in asynchronous HTTP responses, outlines typical use cases such as long polling and real‑time log streaming, provides a complete Spring Boot example with code, and compares it with SSE and raw OutputStream approaches.
This article explains the concepts of RabbitMQ dead‑letter exchanges and queues, outlines why messages become dead letters, and provides complete Java code examples for configuring exchanges, publishing messages with TTL, and consuming both normal and dead‑letter queues.
This article demonstrates how to solve Spring Boot API timeout issues by creating a custom @Timeout annotation combined with an AOP aspect, covering annotation definition, aspect implementation, executor handling, fallback logic, configuration, and practical test results.
This guide explains how Spring Boot applications can dynamically load and unload JAR files at runtime—covering the underlying concepts, benefits such as modularity and hot‑plugging, and step‑by‑step implementations using SpringBootClassLoader as well as the OSGi resource‑locator library.
This article explains why the JVM throws java.lang.OutOfMemoryError: GC overhead limit exceeded, outlines common causes such as traffic spikes, memory leaks, insufficient heap and inefficient GC, and provides practical solutions and debugging steps to diagnose and fix the issue.
When a production Java service repeatedly restarts and triggers full GC and OutOfMemoryError alerts, this guide shows how to capture heap dumps using JVM flags, install and configure Eclipse Memory Analyzer (MAT), and systematically analyze the dump to pinpoint memory leaks, high usage, and problematic code.
java.lang.OutOfMemoryError: Requested array size exceeds VM limit occurs when a Java program attempts to allocate an array larger than the JVM's available heap, and can be mitigated by increasing heap size, optimizing code, or processing data in smaller batches.
This article provides a detailed tutorial on Maven, covering basic configuration, repository setup, dependency management, module organization, plugin usage (including jar, assembly, shade), and build settings, with examples and code snippets to help Java developers efficiently manage projects.
This article analyzes the coupling problems caused by multiple controller calls and third‑party push interfaces, proposes a TPS microservice to centralize third‑party interactions, demonstrates Java Feign interfaces and enum‑based routing, and shows how backend and frontend can achieve low‑coupling architecture while reducing code duplication.
This article explains Java's syntactic sugar—features like enhanced for-loops, autoboxing, varargs, string switches, and try‑with‑resources—showing the original concise syntax, the compiler‑generated code behind it, and practical considerations for performance and readability.
In high‑concurrency Java applications, LongAdder—introduced in JDK 8 and using partitioned cells to reduce contention—generally outperforms the single‑value AtomicLong, which relies on CAS and can cause CPU waste under heavy load, so Alibaba advises LongAdder for scalable distributed counters, though memory usage and workload specifics must be considered.
This article provides a comprehensive walkthrough of Spring Cloud Gateway, covering its core concepts, architecture, key components such as Route, Predicate, and Filter, and detailed source‑code analysis with configuration examples and the underlying HTTP handling flow.
This article demonstrates how Java 8's functional interfaces, especially Function and SFunction, can be used to abstract and reuse data‑validation logic, dramatically reducing boilerplate code, improving readability, and making validation rules easier to maintain and extend.
The article explains how to correctly combine Java's CompletableFuture with Stream API to achieve true asynchronous parallelism, highlights common pitfalls that lead to sequential execution, and provides the proper pattern of creating a CompletableFuture stream followed by a terminal operation.
Netty 4 employs a global multithreaded, locally single‑threaded (event‑loop) architecture where a boss thread pool accepts connections and delegates them to worker thread pools, each containing NioEventLoop instances with selectors, task queues, and pipelines, ensuring lock‑free, ordered processing while avoiding thread blocking.
Concept‑Download is a Spring library that lets developers replace verbose, multi‑step file‑download code with a single @Download annotation, automatically handling source loading, optional ZIP compression, and response writing for both MVC and WebFlux via a modular reactive handler chain.
This article explains the internal workings of Java's ThreadLocal and Netty's FastThreadLocal, compares their memory management and lookup mechanisms, provides code examples, and offers guidance on when to choose each for high‑concurrency backend applications.
Upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21) alters the execution order of @Around, @Before, @After, @AfterReturning, and @AfterThrowing advice within the same @Aspect, causing ThreadLocal data loss and prompting a recommendation to consolidate logic into a single @Around advice.
This article explains the differences between the various Apache Commons Lang StringUtils methods such as isEmpty, isNotEmpty, isAnyEmpty, isNoneEmpty, isBlank, isNotBlank, isAnyBlank, and isNoneBlank, provides example code snippets, and points to official documentation for deeper reference.
Learn how to boost Spring Boot 3 application performance by implementing a multi‑level cache that combines local and Redis storage, using custom @MultiLevelCache annotations and AOP aspects, complete with cache clearing mechanisms, code examples, and testing instructions.
This article walks through the complete process of implementing dynamic data source switching in a SpringBoot application, covering the core concepts of thread‑local context, abstract routing, custom annotations with AOP, configuration, code examples, and important considerations such as transaction management and performance.
The article details how Apache Paimon, integrated as an external table format in Alibaba’s Dolphin OLAP engine, achieves millisecond‑level query latency and up to 10k QPS through ORC push‑down, manifest conversion, caching, concurrency, and encoding optimizations, outperforming StarRocks and Hologres.
This article introduces Spring 6's new HTTP Interface feature with a step‑by‑step demo, explains the GetExchange annotation and service creation, and then shifts to promote AI‑related products and community offers, including code snippets and deployment instructions.
The article explains why designing RPC interfaces with generic Result objects that contain errorCode, errorMessage and data defeats RPC's purpose, and demonstrates how returning plain business objects and leveraging Java exceptions leads to cleaner, more maintainable backend code.
This article explains why designing RPC (JSF) interfaces to return HTTP‑like result objects with errorCode, errorMessage, and data defeats the purpose of RPC, and it offers concrete guidelines and Java examples for building clean, exception‑driven RPC APIs.
This article walks through why repetitive CRUD code wastes development time, reviews existing generators like MyBatis‑Generator and MyBatis‑Plus, and then demonstrates step‑by‑step how to create a custom Java code generator using Freemarker, Maven, and SpringBoot, complete with template and demo code.
This article explores how Domain‑Driven Design and hexagonal (clean) architecture were applied to Huolala’s user CRM, detailing the tactical design patterns, module breakdown, code examples, and the step‑by‑step migration that improved scalability, maintainability, and development efficiency.
This article explains MyBatis's two‑level caching mechanism, detailing how first‑level session cache works, why it often fails in Spring Boot without transactions, how to enable and configure second‑level cache, and the potential pitfalls of cache inconsistency across mapper namespaces.
This article explains the Fork/Join model and Java's ForkJoinPool, covering divide‑and‑conquer theory, task types, pool construction, core methods, performance testing, and practical recommendations such as avoiding the commonPool for blocking tasks.
This article provides a comprehensive guide to Spring's built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ReflectionUtils, and AopUtils—showing their purpose, typical usage patterns, and example method signatures for developers working on Java backend projects.
This tutorial explains how to use SpringBoot, AOP, and a custom @DataSource annotation to dynamically switch between MySQL master and slave databases—covering configuration, code implementation, multiple slave handling, and an Oracle example—to ensure high availability and flexible data source management.
This article explains how the Jackson @JsonView annotation can be used in Spring back‑end projects to selectively serialize object fields, reduce bandwidth, improve security, and handle nested associations by defining view interfaces and applying them on entity fields and controller methods.
This article explains the fundamentals and practical implementations of common rate‑limiting algorithms—including fixed‑window, sliding‑window, leaky‑bucket, and token‑bucket—provides Java and Redis code samples, discusses their advantages, pitfalls, and real‑world production scenarios, and offers performance‑tuning tips.
Given an integer array, the task is to find the maximum sum of a non‑empty subarray after optionally deleting at most one element, which can be solved via dynamic programming using two states to track sums with and without a deletion, as demonstrated with Java and C++ implementations.
This article explains why the java.lang.OutOfMemoryError: Kill process (java) or sacrifice child occurs, outlines system‑level memory‑shortage causes, and provides practical steps to prevent, fix, and troubleshoot the issue on Linux‑based Java applications.
java.lang.OutOfMemoryError: Metaspace occurs when the JVM's native Metaspace exceeds its configured limit, often due to excessive dynamic class generation, large numbers of loaded classes or classloader leaks, and can be mitigated by increasing Metaspace size, fixing memory leaks, and optimizing class loading.
Learn the seven most frequent Java Stream pitfalls—from missing terminal operations and modifying source data to overusing intermediate steps and thread‑safety issues—and discover practical fixes that ensure your streams execute correctly, efficiently, and safely.
This article explains the concepts, differences, and practical usage of Java's Future and CompletableFuture for asynchronous programming, highlighting their blocking behavior, task composition, exception handling, and suitable scenarios in performance testing and complex test workflows, with detailed code examples.
This article introduces the Liteflow rule engine, explains its architecture and components, demonstrates how to configure and use it with Spring Boot, shows EL rule file examples and a real e‑commerce workflow, and summarizes its performance benefits for backend development.
This article explains Java’s hashCode method, its role in hash-based collections like HashMap and HashSet, how objects are placed in buckets, the necessity of overriding hashCode alongside equals, and how proper implementation improves performance and ensures consistent behavior.
This article introduces Spring Integration, explains its fundamental concepts such as messages, channels, endpoints, adapters, filters and transformers, compares it with traditional middleware, and provides detailed XML and Java configuration examples, design‑pattern guidance, interceptor usage, and a complete order‑processing implementation.
The article analyzes various Java string‑replacement techniques—including simple String.replace, compiled regular expressions, Aho‑Corasick automaton, and custom Trie implementations—by presenting their designs, object sizes, and benchmark results to guide developers in choosing the most efficient solution for large keyword sets.
This article explains why messages can be lost in RabbitMQ at the producer, broker, or consumer stages and provides concrete techniques—including confirm mode, transaction handling, persistence settings, manual acknowledgments, and retry mechanisms with dead‑letter queues—to ensure reliable delivery.
This article introduces ten common Spring AOP pointcut expressions, explains their syntax and usage with both annotation‑based and XML configurations, provides concrete code examples, and shows how to combine them for flexible aspect weaving in Spring Boot 3.4.2.
This article demonstrates how to convert a traditional Spring Boot book‑management service into an AI‑enabled MCP server, covering dependency setup, entity definition, tool annotations, MCP configuration, chat client integration, data initialization, and testing, with complete code examples.
This article explains the Java memory pool model, common Out‑of‑Memory errors, their root causes, tuning parameters, and real‑world case studies to help developers diagnose and resolve OOM issues in containerized Java applications.
This article explains how to efficiently remove duplicates from 4 billion QQ numbers within a 1 GB memory limit by replacing the naïve HashSet approach with a memory‑saving Bitmap data structure, complete with calculations, algorithm steps, Java code, and a discussion of its pros and cons.
This article provides a comprehensive guide to MyBatis dynamic SQL tags—including foreach, if, choose, trim, selectKey, and reusable SQL fragments—explaining their attributes, usage patterns, and code examples to help developers write cleaner, more reliable XML mappers and avoid common pitfalls.
This article explains the JVM method area concept, its implementation as the permanent generation in JDK 1.7, the limitations of that approach, and how JDK 1.8 introduced metaspace using native memory to improve class metadata management and avoid out‑of‑memory errors.
This article explains how to use Jackson's @JsonView annotation in Spring Boot 3 to flexibly control JSON output for different REST scenarios, covering basic usage, programmatic view selection, view‑based MVC responses, deserialization restrictions, and default‑inclusion configuration with practical code examples.
When a midnight CPU alarm threatened a core Java service, I walked through rapid system checks, JVM profiling, algorithm refactoring, database indexing, Docker isolation, and enhanced monitoring to bring CPU usage back below 30% and restore service stability.
This article compares JWT and session-based authentication, detailing their differences, certification processes, advantages, disadvantages, security considerations, performance impacts, token renewal, and revocation strategies, and provides a complete Java implementation using Spring, Redis, and custom utility classes.
This tutorial provides a thorough walkthrough of IntelliJ IDEA's Debug functionality, covering preparation, main interface, detailed explanations of service and debug buttons, variable inspection and modification, conditional breakpoints, expression evaluation, frame dropping, force return, multithreaded and Stream debugging, as well as remote debugging techniques.
This article provides an extensive overview of core technical interview subjects—including operating‑system signals, process synchronization and data transfer methods, TLS encryption steps, common caching pitfalls and remedies, Java collection implementations, heap‑building algorithms, and various CPU scheduling strategies—offering concise explanations and practical code examples for each concept.
This article explains Java virtual threads introduced by Project Loom, compares them with platform threads in terms of memory usage and creation time, provides code examples for creating and managing virtual threads, and outlines practical guidelines and use‑cases for high‑concurrency backend applications.
This article demonstrates how to implement MySQL master‑slave dynamic data source switching in a SpringBoot 3.0.4 project using AOP, custom annotations, and configuration files, ensuring automatic failover to the master when a slave becomes unavailable.
This article investigates the time cost of establishing and closing MySQL connections in Java web applications, using Wireshark packet captures and code examples to demonstrate that a single connection can take over 200 ms, highlighting the importance of connection pooling and performance optimizations.
This article explains Java's dynamic ClassLoader mechanism, outlines the hierarchy of built‑in loaders, details frequent problems such as ClassNotFoundException, NoClassDefFoundError, ClassCastException and version conflicts, and provides practical troubleshooting steps and best‑practice recommendations for reliable class loading.
This article compares six WebSocket integration approaches—Javax, WebMVC, WebFlux, Java-WebSocket, SocketIO, and Netty—showing how to configure both server and client sides in Spring Boot, with step‑by‑step code examples, key annotations, and practical tips for each method.
This article shares practical interview communication advice and demonstrates a Java backtracking solution that enumerates every possible k‑element combination within the range [1, n] using pruning for efficiency.
This article explains how the java.lang.ClassLoader#loadClass() API works, why frequent concurrent calls can cause thread blocking due to internal synchronization, demonstrates the issue with a sample multithreaded program, analyzes thread‑dump data, and provides practical solutions to mitigate the performance problem.
This article explains the evolution from Spring AI FunctionCall to the newer ToolCalling, introduces the Model Context Protocol (MCP), and provides step‑by‑step code examples for building MCP servers and clients in Java, demonstrating how to integrate large language models with backend services.
This guide demonstrates how to use the Fabric8 OpenShift client DSL in Java to initialize an OpenShift client, create and manage resources such as DeploymentConfig, Route, BuildConfig, Project, ImageStream, and various policies, and perform listing and deletion operations with code examples.
This article provides a comprehensive guide to integrating WebSocket in Spring Boot, covering the native Javax API, Spring WebMVC and WebFlux approaches, as well as popular third‑party libraries such as Java‑WebSocket, SocketIO and Netty, with detailed configuration steps, code examples, and practical tips.
This article explains how to decouple business logic using Spring Boot transaction event listeners, demonstrates both manual TransactionSynchronization and @TransactionalEventListener implementations with full code examples, and shows a practical user‑registration scenario that avoids common pitfalls.
This article walks through Ant Group's bonus structure, explains Java heap vs stack, String object creation, TCP packet issues, MySQL index types, B+‑tree advantages, database lock mechanisms, and shows how Zookeeper and Redis implement distributed coordination and locking, providing concrete code examples and best‑practice recommendations.
This article explains how to use the Kubernetes Java client to create, approve, and deny CertificateSigningRequests, work with SharedInformers, list and delete resources with ListOptions and DeleteOptions, watch resources, retrieve logs, serialize objects to YAML, and run Pods, providing practical code examples and best‑practice recommendations.
This article explains why Spring Boot applications can consume up to 12 GB of RAM, demonstrates how to inspect JVM memory with tools like jps and jmap, clarifies default heap size calculations, and provides practical steps to tune JVM parameters for production stability.
