This article explains how to use Spring Boot's YAML configuration files to define and manage simple properties, collections, maps, nested objects, and complex data structures, providing code examples and a complete sample to help developers efficiently handle intricate configuration scenarios.
This comprehensive guide walks you through RabbitMQ fundamentals, installation on macOS, core AMQP concepts, exchange types, queue patterns, evaluation criteria, advanced features like TTL and dead‑letter queues, and provides ready‑to‑run Java code examples for producers and consumers.
This article explains how Spring’s FactoryBean mechanism enables seamless integration with MyBatis by detailing the roles of BeanFactory, SqlSessionFactoryBean, MapperScannerConfigurer, and MapperFactoryBean, and provides annotated code examples and XML configuration to illustrate the underlying process and its benefits for transaction management and thread safety.
The article explains why Apache POI loads entire .xlsx zip files into memory causing OOM, demonstrates the issue with code examples, and shows how switching to EasyExcel's streaming read dramatically reduces memory usage while handling large Excel files in Java.
This article presents eight common multithreading scenarios involving Java synchronized methods, explains whether each case is thread‑safe, provides detailed code demonstrations, shows execution results, and summarizes the underlying lock mechanisms that determine safety.
This article demonstrates how ASM is used to generate dynamic proxies with cglib and to create high‑performance JSON deserializers in Fastjson, providing code examples, explanation of the underlying bytecode generation, and practical tips for developers.
This article explains every Spring Boot startup event, from ApplicationStartingEvent to ApplicationFailedEvent, showing when each occurs, how to customize them, and providing clear code examples to help developers extend and debug their applications effectively.
This article explains the KISS (Keep It Simple, Stupid) principle, outlines its core ideas, presents best‑practice guidelines and common anti‑patterns, and demonstrates how to refactor an over‑engineered Java DAO into a concise, maintainable implementation.
This article presents a concise reference of Spring's Assert class, common ObjectUtils, StringUtils, CollectionUtils, file and stream copy helpers, as well as ReflectionUtils and AOP utilities, illustrating their purpose, typical usage scenarios, and providing ready‑to‑copy code snippets for Java backend development.
The Java service crashed when the Linux OOM killer terminated its process after a developer opened a 37 GB log file with Vim, which loaded the entire file into the container’s 8 GB memory, triggering a port alarm and prompting investigation and recommendations to use streaming tools instead of Vim.
This article explains the Java class loading mechanism, the parent‑delegation model, how it can be broken, and then details Tomcat’s custom classloader hierarchy—including CommonClassLoader, CatalinaClassLoader, SharedClassLoader, and WebappClassLoader—showing why Tomcat deviates from the standard delegation model.
The article walks through a DDD‑inspired four‑layer microservice architecture, explains how an application SDK enables RPC communication across services, details each architectural layer, and showcases the open‑source D3boot framework that bundles reusable base components, BOM management, and SaaS‑ready features for rapid backend development.
This article explains how to apply Redisson's distributed lock in Java, demonstrates the basic lock and tryLock APIs, shows how to create a custom @DistributedLock annotation and an AOP aspect to handle locking automatically, and provides a practical usage example with two services.
The article explains why Java 21 deprecates the Windows 32‑bit x86 port and dynamic agent loading, describes the technical reasons, shows the new configuration options and related warnings, and discusses the impact on virtual threads and best practices for avoiding deprecated APIs.
This article explains Spring’s type conversion system, introduces the core conversion service interfaces, demonstrates how to use GenericConversionService, DefaultConversionService, and WebConversionService, and provides step‑by‑step examples of custom converters, factories, generic converters, and their registration in Spring MVC.
This article explains the seven SOLID design principles, introduces the Chain of Responsibility pattern, demonstrates its application to a video‑review workflow with step‑by‑step Java code, and shows how to evolve the implementation from a basic chain to a Spring‑managed, fully open‑closed solution.
By replacing the naïve double‑loop matcher with a Double‑Array Trie‑based Aho‑Corasick automaton and refactoring the system into a layered name‑and‑data microservice architecture that shards the keyword dictionary and rebuilds the automaton only on version changes, the real‑time keyword‑matching service reduced latency from seconds to milliseconds even at thousands of QPS.
This article explains how to design microservice permission control using Apache Shiro, sharing session data via Redis, outlines failed approaches, presents a workable solution with custom cache and session managers, and provides complete code examples for realms, configuration, and login flow.
This article walks through the limitations of Java's Future, introduces CompletableFuture's richer asynchronous API, and demonstrates step‑by‑step how to refactor a shop‑detail page using parallel tasks, custom thread pools, and composition patterns to cut response time from seconds to under two.
This article explains the Java class file format, including its magic number, version, constant pool, access flags, fields, methods, and attributes, and then details how the JVM loads, verifies, prepares, resolves, and initializes classes, manages object memory layout, and executes bytecode using a stack‑based interpreter.
This article provides a comprehensive overview of the five creational design patterns—Singleton, Abstract Factory, Factory Method, Builder, and Prototype—explaining their concepts, UML structures, implementation details, typical use cases, advantages, disadvantages, and includes Java code examples and diagrams.
This article revisits a recent poll on MySQL field length, then presents a Java code example that uses the synchronized keyword on a locally created String variable, asking readers to determine whether this approach truly provides locking, and invites discussion on Java concurrency semantics.
This article explains LeetCode problem 42 “Trapping Rain Water”, detailing the problem statement, example, and three efficient O(n) solution approaches—two‑pointer, prefix‑max arrays, and a monotonic stack—each accompanied by complete Java implementations and analysis of their logic.
This article explains the internal mechanics of HashMap traversal in Java, comparing iterator, keySet, entrySet and stream approaches, and reveals why using keySet results in two passes—once to obtain an iterator and once to fetch values—by examining the underlying KeySet, KeyIterator, and HashIterator implementations.
This article walks through a real‑world investigation of a pod whose CPU spiked to over 90%, detailing how abnormal JVM garbage‑collection patterns were identified, traced to a specific Java thread, and resolved by fixing an inefficient Excel export routine.
This comprehensive guide walks you through setting up Spring Security in a Spring Boot project, configuring password encoding, implementing JWT-based authentication, building custom login and logout endpoints, managing user details with MyBatis Plus, and applying role‑based access control with custom permission handlers, all illustrated with complete code examples.
An irreverent guide shows how to artificially inflate Java code volume by adding unnecessary interfaces, redundant methods, extra configuration fields, event listeners, utility classes, custom exceptions, and classic design patterns, while warning that such practices harm readability and maintainability despite boosting line counts.
Thread pools are essential for managing concurrent tasks efficiently, reducing resource overhead by reusing threads instead of creating new ones for each task, which is crucial for handling high-volume operations like exporting large datasets to Excel.
This article explains the purpose and implementation of Java's CompletionService, compares it with ExecutorService, walks through its source code and key methods, and demonstrates typical usage patterns for efficiently retrieving the earliest completed asynchronous results.
This article explains the Prototype design pattern, covering its definition, UML class diagram, Java implementation with shallow and deep copy examples, advantages and drawbacks, comparisons with Factory Method and Singleton patterns, and practical scenarios where cloning objects provides an efficient alternative to costly object creation.
The article analyzes DeWu’s product lifecycle, explains New, Product, and Draft types, introduces state‑machine fundamentals, compares Java enum, Spring, Squirrel, and Cola implementations, benchmarks their throughput (showing Cola vastly faster), and concludes that despite Cola’s performance, Spring StateMachine is chosen for its richer features and seamless Spring integration.
This article explains how to enable and configure Spring Boot's @Async annotation, provides code examples for thread‑pool setup and asynchronous service methods, and discusses important caveats such as calling async methods from the same class, transaction incompatibility, blocking issues, and exception handling.
This tutorial walks you through adding MongoDB dependencies to a Spring Boot project, configuring the connection, defining entity and repository classes, implementing service and controller layers, and optionally setting up sharding or replica‑set architectures for scalable data management.
This article explains how to build a Spring Boot‑based service registry that replicates Nacos' core features—service discovery, health‑checking, and dynamic configuration management—by creating server‑side registration APIs, scheduled heartbeat checks, client registration logic, and database‑backed configuration storage.
This article explains how to use Spring Cloud Gateway 3.1.5 to create a lightweight API gateway by configuring routes in YAML and implementing routing logic directly in a Spring MVC or WebFlux controller with ProxyExchange, covering features, code examples, and dynamic path mapping.
This article introduces Javaassist, a Java library for runtime bytecode manipulation, and demonstrates how to view compiled bytecode, add Maven dependencies, generate new classes, modify existing ones, insert fields and methods, and apply AOP‑style enhancements without changing source code.
This article explains the Chain of Responsibility design pattern, shows how to apply it to multi‑step product creation validation and expense‑approval workflows, walks through abstract and concrete handler implementations, dynamic configuration, and client execution with full Java code examples.
This article explains why Quartz jobs can overlap when their execution time exceeds the trigger interval, demonstrates how to prevent concurrent execution with the @DisallowConcurrentExecution annotation, discusses distributed lock and idempotency solutions for clusters, and covers thread‑pool limits, exception handling, and a complete Java demo.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
Discover 28 practical IntelliJ IDEA tricks—from viewing code history and adjusting memory settings to customizing shortcuts, managing imports, visualizing dependencies, and leveraging plugins—designed to streamline Java development, enhance efficiency, and simplify everyday coding tasks for both beginners and seasoned developers.
This article introduces the high‑performance Java library Disruptor, explains its core concepts such as Ring Buffer, Sequence, and Wait Strategy, and provides a step‑by‑step demo with Maven configuration, code examples, and test results to help developers implement fast, lock‑free producer‑consumer queues.
This article explains Java's Future and CompletableFuture APIs, demonstrates how to replace blocking Future.get() and CountDownLatch patterns with CompletableFuture, shows creation methods, result retrieval options, callback chains, exception handling, task composition techniques, and provides best‑practice recommendations for thread‑pool usage.
This article explains the ThreadLocal mechanism, its memory‑leak pitfalls, introduces the new ScopedValue feature in JDK 20 as a safer alternative, and demonstrates practical Spring and virtual‑thread examples using StructuredTaskScope for modern Java backend concurrency.
This article investigates the performance difference between Java's List.sort() and Stream.sorted(), providing simple demos, JMH benchmark results, and analysis of underlying overheads to explain why the native list sorting is generally faster than sorting via streams.
This guide compiles 28 practical IntelliJ IDEA tips—from viewing local history and adjusting virtual memory to using plugins, customizing shortcuts, and visualizing code dependencies—helping Java developers streamline their workflow, reduce distractions, and dramatically increase coding efficiency.
This article analyzes a coupon‑claiming race condition that caused stock to become negative under load and presents four solutions—including Java synchronized blocks, SQL conditional updates, Redis SETNX locks, and Redisson client locks—to reliably prevent over‑issuance in backend systems.
By instrumenting Java services with JaCoCo’s agent and analyzing runtime coverage data, teams can identify unused (“zombie”) code, safely remove or deactivate it, and consequently reduce maintenance costs, shorten delivery cycles, and improve overall system performance and developer productivity.
This article explains the Factory Method design pattern, covering its definition, UML diagram, key participants, the problems it solves compared to the Simple Factory, step‑by‑step Java implementation with code examples, advantages, disadvantages, application scenarios, and differences from the Simple Factory pattern.
This article explains how to design a clean, maintainable Spring MVC controller layer by unifying response structures, applying centralized exception handling, and leveraging JSR‑303 validation with custom rules, illustrated with comprehensive code examples and best‑practice guidelines.
This article explains LeetCode problem 124, describing the definition of a path in a binary tree, analyzing the constraints, and providing a detailed Java implementation that uses depth‑first search to compute the maximum path sum while handling negative sub‑paths.
This article demonstrates why @Transactional fails in multithreaded Spring services, presents a thread‑pool based solution using manual SqlSession control to achieve full rollback across child threads, and provides complete code examples and test results illustrating both failure and successful transaction handling.
The article explains that Java’s Random class uses a predictable linear‑congruential generator, making its output vulnerable to seed‑guessing attacks, and demonstrates how SecureRandom with strategies like SHA1PRNG, NativePRNGBlocking, and NativePRNGNonBlocking provides stronger, non‑predictable randomness suitable for security‑critical applications.
This article reviews the most important new features introduced in Java JDK 10 through JDK 21—including local‑variable type inference, the standardized HTTP client, experimental garbage collectors, pattern‑matching enhancements, records, sealed classes, and virtual threads—providing code examples and migration guidance for developers.
This article explains how to construct and send Ethereum JSON‑RPC calls such as net_version through a WebSocket connection using the Web3j Java library, including source code analysis, request construction, and a practical example with console output.
This article explains why iterating a Java HashMap with keySet() results in two traversals, detailing the internal iterator creation, the role of KeyIterator and HashIterator classes, and how the do‑while loop in HashIterator’s constructor locates the first entry, with code examples and bytecode analysis.
This article explains how to handle enum and JSON string parameters in Spring MVC by creating custom annotations and argument resolvers, demonstrates the implementation steps with full code examples, and also reviews Spring MVC's built‑in parameter binding mechanisms such as @RequestParam, @PathVariable, @RequestBody, and @ModelAttribute.
This article explains how to redesign a JSON payload that repeats a sessionId for each scene by moving the sessionId to the outer level and using MyBatis resultMap with a collection to map a Session object containing a list of Scene objects, including Java entity definitions, mapper XML, service, and controller code.
This article explains what unit testing is, why it is essential for software quality, outlines its benefits such as early bug detection and design improvement, and provides practical guidance on writing effective Java unit tests using JUnit5, Mockito, and JaCoCo, along with CI integration and best‑practice principles.
This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
This article presents a comprehensive collection of 28 practical IntelliJ IDEA shortcuts and configuration tricks—such as viewing local history, adjusting VM memory, adopting Eclipse keymaps, managing inspections, customizing templates, navigating code, and leveraging plugins—to dramatically improve Java development productivity.
The article reviews five major distributed unique ID generation methods—including UUID, Redis auto‑increment, database auto‑increment, database segment mode, and Snowflake—explains their principles, advantages, drawbacks, and provides practical integration guides and code examples for Java developers.
This article explains how to implement a flexible business retry mechanism in Spring using custom annotations and AOP, covering the rationale, code examples for the @Retry annotation, RetryAspect, transaction considerations, and alternative Spring Retry library integration.
This article explains the G1 garbage collector’s heap layout, collection cycles, pause prediction, log analysis, and monitoring tools, helping Java developers diagnose and resolve performance issues such as frequent restarts, OOM, CPU spikes, and periodic latency spikes.
This article explains Java compilation and decompilation basics, introduces the JD‑GUI decompiler, and provides a step‑by‑step guide to protect Java applications by configuring ProGuard and integrating it into a Maven build, including sample configuration files and common pitfalls.
Thread profiling uses threshold‑triggered tasks on business threads to capture stack snapshots, which a dedicated profiler thread sends via high‑performance gRPC to a server that queues them in Kafka, enriches and stores them in ClickHouse, correlates with OpenTelemetry traces, and provides metrics that let developers quickly pinpoint latency bottlenecks and improve system stability.
This article examines the benefits of moving from JDK 11 to the long‑term support JDK 17, detailing performance gains—especially sub‑millisecond ZGC pause times—new language features, compatibility considerations, benchmark results, and step‑by‑step migration instructions for Spring‑based applications.
The article investigates frequent OutOfMemoryError incidents in a distributed Java service, explains heap and metaspace causes, analyzes MyBatis source that retains large SQL strings in memory, reproduces the issue with heavy IN clauses and limited heap, and offers practical mitigation advice.
This article explains how Apache Pulsar is used within Apache InLong to collect, sort, and reliably deliver massive MySQL binlog incremental data, covering component architecture, job isolation, client and producer management, consumption strategies, common pitfalls, performance tuning, and practical code examples.
This article introduces the open‑source Disruptor framework, explains its core concepts such as Ring Buffer, Sequencer, and Wait Strategies, and provides a step‑by‑step Java demo—including Maven setup, event factory, handlers, and a test case—to illustrate building a high‑throughput, low‑latency in‑memory message queue.
This article compares Spring Boot and Quarkus across startup time, memory usage, CPU consumption, and response latency, presents benchmark results from JMeter and VisualVM tests, and provides practical guidance for migrating Java developers from Spring to the cloud‑native Quarkus framework.
This article explains the internal workings of HashMap traversal in Java, showing why using keySet() results in two passes—first converting to an iterator and then fetching values—and details the underlying iterator, KeyIterator, and HashIterator implementations with code examples.
This article details the design and implementation of a Java‑based flash‑sale (Seckill) system using SpringBoot, Redis, RabbitMQ, and related technologies, covering architecture, security, caching, asynchronous processing, oversell prevention, and rate‑limiting techniques.
This article explains the distinct origins, injection strategies, and internal processing of Spring's @Resource and @Autowired annotations, compares their behavior, and walks through relevant source code to illustrate how each annotation resolves dependencies.
November 2023’s TIOBE Index reveals Python still leads at 14.16%, while C# jumps to fifth place, narrowing its gap with Java to just 0.7%, as Java slips to fourth with its biggest monthly decline, and C and C++ also see modest drops.
This comprehensive guide explains Java's collection framework, covering the core interfaces Collection, List, Set, and Map, their abstract and concrete implementations, iterator mechanisms, and key differences that are essential for both interview preparation and real‑world backend development.
This article introduces Hutool, a comprehensive Java utility library that consolidates common functions such as file handling, encryption, date manipulation, and more, explains its key modules, shows how to add it via Maven, and provides practical code examples for utilities like DateUtil, StrUtil, NumberUtil, and SecureUtil.
This article explains how duplicate form submissions occur, outlines common prevention techniques such as token validation and timestamp checks, and demonstrates a practical SpringMVC interceptor implementation with token storage and scheduled cleanup to ensure request uniqueness and reduce server load.
This article explains why Java's BigDecimal is essential for high‑precision arithmetic, outlines common use cases such as finance and scientific computing, highlights typical pitfalls with floating‑point numbers, and provides practical code examples and best‑practice tips for correct usage.
Given a circular road with n stations and the distances between each consecutive pair, this article explains how to determine the minimal travel distance between any two stations by evaluating both clockwise and counter‑clockwise routes, providing problem details, examples, solution logic, reference implementations in Python, Java, and C++, and complexity analysis.
This article explains why iterating a Java HashMap via keySet() incurs two passes—once to obtain an iterator and again to fetch values—while entrySet() or Map.forEach() performs a single pass, detailing the underlying iterator implementations and their bytecode behavior.
This article explains why load balancing is crucial for RocketMQ producers, details the internal selection algorithm using ThreadLocal indexes and round‑robin logic, and provides Java code examples illustrating how messages are distributed across queues.
This article explains the Chain of Responsibility design pattern and demonstrates how to apply it in a Java backend to evaluate login risk factors such as password errors, unusual login times, IP whitelist violations, and abnormal login locations, providing full code examples and execution flow.
This article explains the definition and properties of directed acyclic graphs (DAG), describes the basic topological sorting algorithm steps, and provides a complete Java implementation using Guava's MutableGraph class, illustrating the process with an example and its execution result.
This article compares Java classes with Go structs, covering how each language handles state and behavior, inheritance versus composition, and visibility rules, while providing concrete code examples to illustrate the practical differences for developers.
This article introduces LiteFlow, a lightweight and fast component‑based rule engine that decouples complex business logic, explains its design principles, demonstrates usage in both non‑Spring and SpringBoot environments with Maven dependencies and XML configurations, and delves into its core components and execution flow through detailed source code analysis.
This article explains the concept of request merging for high‑concurrency web services, outlines its advantages and drawbacks, and provides a complete Java implementation using ScheduledExecutorService, a memory queue, and a generic BatchCollapser utility with usage examples.
This article explains the internal mechanics of Java's HashMap traversal, showing that keySet() incurs two passes due to iterator creation while entrySet() (or Map.forEach) iterates in a single pass, and it demonstrates the process through decompiled source code and concrete examples.
This article explains the concept of a local message table, shows how it can be used to achieve reliable distributed transaction consistency with MQ, and provides complete MySQL DDL and Java service code along with a retry mechanism and analysis of failure scenarios.
This article examines the causes of Java OutOfMemoryError in a distributed backend service, analyzes MyBatis-related memory leaks, demonstrates a reproducible scenario with large SQL concatenations and multithreading, and offers practical mitigation strategies to prevent heap and metaspace overflow.
This step‑by‑step guide shows how to download, configure, and launch SkyWalking with Spring Boot, connect it to Elasticsearch, instrument a sample service and Redis calls, and view real‑time monitoring data through the SkyWalking UI and Kibana.
The article analyzes why a Java API endpoint took eight seconds, demonstrates through benchmarks that List.sort() outperforms Stream.sorted(), shows how sorting on computed columns and using BigDecimal can drastically slow execution, and presents three practical optimizations that reduce the response time to under a second.
This article introduces a generic asynchronous processing SDK for Java back‑ends, explaining its purpose, advantages, underlying principles, components, design patterns, database schema, configuration, usage, and operational considerations, and provides complete code and configuration examples.
This article introduces the open‑source mall project—a SpringBoot + Vue + uni‑app e‑commerce platform with over 60 K GitHub stars—detailing its payment flow, architecture, tech stack, video tutorial series, and how to join the learning community for hands‑on development experience.
This article compares Spring Boot and Quarkus, detailing their architectures, performance benchmarks—including startup time, memory usage, CPU, and response latency—both in JVM and native modes, and provides guidance on migrating Spring applications to Quarkus with code examples and best‑practice tips.
This article explains the internal mechanics of HashMap traversal in Java, showing that keySet() uses an iterator that iterates twice to locate entries, whereas entrySet() (or Map.forEach) iterates only once, and it walks through the relevant source code and decompiled bytecode to illustrate the process.
This article explains why Elasticsearch is fast, outlines its key features, and provides a complete Spring Boot 2.4 tutorial—including dependencies, configuration, data model, repository usage, and test code—for building a distributed search service.
This guide demonstrates essential Java Stream API techniques—including grouping collections into maps, extracting first entries, performing reductions to find max or min, converting streams to lists, sorting, removing duplicates, and a comprehensive list of frequently used stream operations—providing practical code examples for Java 11 and 17.
This article explains why a Spring Boot application runs with the configured port when packaged as a JAR using the embedded Tomcat, but switches to Tomcat's default port and context path when deployed as a WAR, and provides step‑by‑step instructions to package and deploy both formats along with historical context and technical differences.
This article explains the business scenarios that drive the need for globally unique distributed IDs, analyzes the challenges of uniqueness, performance, and availability, and details Vivo's self‑built LuBan ID service—including its architecture, three ID formats, custom extensions, SDK usage, performance optimizations, and real‑world deployment metrics.
This article explains the concept of open interfaces and signature verification, outlines the end‑to‑end signing and verification flow, and provides a complete Spring Boot implementation including configuration properties, a signature manager, custom annotation, AOP aspect, request‑caching filter and utility classes, all illustrated with code snippets.
