This article provides a comprehensive, step‑by‑step explanation of the JVM class‑loading mechanism, covering the five phases—Loading, Verification, Preparation, Resolution, and Initialization—along with diagrams and detailed descriptions of each operation performed by the JVM.
This article explores PolarisMesh’s server-side registration process, detailing how client registration requests are handled, the data flow through apiserver, resource auth filter, service and storage layers, and provides concrete code examples for both Java and Go SDKs, along with MySQL storage schema.
This article explains Java heap memory concepts, garbage collection, common memory issues like leaks and OutOfMemoryError, and outlines the team's quality assurance framework—including left‑shift code review, right‑shift monitoring, and continuous delivery practices—to help prevent and resolve production alerts.
This article explains how to create a compile‑time annotation processor that automatically injects the JAR version into a static constant, enabling Prometheus to monitor version usage without manual updates, and demonstrates the implementation with Lombok‑style code examples.
This guide explains how to use SpringBoot's PropertySourcesPlaceholderConfigurer and PropertyOverrideConfigurer to handle missing placeholders, set default values, customize prefixes, load custom property files, and override bean properties—including nested properties—while avoiding common pitfalls like startup errors and NPEs.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages after a transaction successfully commits, ensuring data consistency in payment‑system archiving scenarios.
This article explains the Spring Boot startup process, enumerates the key extension points and their execution order, demonstrates the sequence with practical code examples, and answers common questions about bean initialization, lifecycle callbacks, and the proper timing for opening RPC, MQ, and HTTP traffic.
This article details the end‑to‑end design, configuration, and code implementation of a 50‑table sharding solution for cash repayment and loan application data, covering database schema planning, historical data migration, backend query adaptation, dynamic switches, scheduled consistency checks, and practical pitfalls encountered with Spring Boot 3 and ShardingSphere.
The article explains why Spring StateMachine is heavyweight and thread‑unsafe for high‑concurrency order management, introduces the open‑source COLA stateless state machine as a simpler, lock‑free solution, and provides detailed design principles, core concepts, and extensive Java code examples.
This article explains Java virtual threads introduced in Java 19, compares them with traditional OS threads, shows how to enable them in Spring Boot, and presents performance benchmarks that demonstrate dramatic latency reductions for I/O‑bound workloads.
This article explains the default Tomcat settings bundled with Spring Boot 2.7.10, details core parameters such as accept‑count, max‑connections, thread pool sizes, and timeouts, describes the internal Acceptor and Poller threads, provides configuration examples and testing results, and includes reference links.
This article provides a comprehensive guide on integrating Alibaba's Druid connection pool into Spring Boot applications, covering its advantages, dependency setup, detailed configuration properties, built‑in filters, monitoring pages, ad removal techniques, and programmatic access to runtime statistics.
This article explains Java's BigDecimal class, covering its purpose for high‑precision arithmetic, recommended constructors, key arithmetic methods, comparison techniques, formatting with NumberFormat, handling of division exceptions, and best‑practice tips such as using the String constructor and managing immutability.
The article explains how to replace tightly‑coupled if‑else or switch statements for selecting CSV, JSON, or XML parsers with a Service Locator Pattern in Spring, showing step‑by‑step code examples, configuration, and the resulting adherence to the open‑closed principle.
This article explains the purpose of Java's parent delegation class‑loader mechanism, describes its three built‑in loaders, and details common scenarios—such as JNDI, JDBC, Tomcat, and OSGi—where developers intentionally break the delegation to achieve flexibility and isolation.
This article explains how to design and implement a fixed-size FIFO export queue in Java to manage large‑scale MySQL data exports, detailing the ExportQueue class, abstract export logic with EasyExcel, a concrete ExportImpl service, and a test controller, while discussing performance considerations and future enhancements.
This guide explains the fundamentals of Druid as a Java database connection pool, how to add required Maven dependencies, configure various Druid properties and filters for SQL and web monitoring, enable slow‑SQL logging, integrate Spring AOP monitoring, remove the default Alibaba advertisement, and retrieve monitoring data via the DruidStatManagerFacade API.
The article explains why fail‑fast iterators throw ConcurrentModificationException when a collection is modified during iteration, outlines two common scenarios that trigger the exception, and presents both incorrect and correct Java code examples along with strategies such as avoiding modifications, using synchronization, iterator.remove(), or switching to fail‑safe concurrent collections.
This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using custom annotations, Redis-based locks, and Redisson distributed locks, covering key generation, lock acquisition, configuration, and testing to ensure idempotent API calls.
This article explains how Java's parallelStream uses the shared ForkJoinPool, why developers may need to customize the thread pool for better performance and isolation, and provides two approaches—setting the system property and creating a dedicated ForkJoinPool—along with complete code examples and execution results.
This guide explains how to integrate Alibaba's Druid connection pool into Spring Boot, covering basic concepts, Maven dependencies, essential configuration properties, built‑in filters, monitoring pages, SQL and slow‑query logging, Spring AOP monitoring, ad removal, and programmatic access to Druid statistics.
This article provides an in-depth review of common Java backend interview questions, covering alternative object creation methods, practical reflection scenarios, serialization techniques, garbage‑collection algorithms, I/O multiplexing mechanisms, network port listening, and troubleshooting tips for server‑client communication issues.
This article explains the concept of idempotency, identifies which HTTP requests are naturally idempotent, discusses why idempotency is essential for retries, async callbacks, and message queues, and demonstrates a practical Java implementation using custom annotations, AOP, and Redis for token management.
This article explains the common slow approach of reading Excel files with POI and inserting rows via JDBC, then presents three practical optimizations—caching data, using asynchronous multithreaded reads, and per‑file async processing—along with thread‑pool configuration tips and EasyExcel examples to dramatically reduce import time from minutes to seconds.
This article walks through a complete API protection scheme that combines HTTPS fundamentals, symmetric AES encryption, RSA key exchange, SHA‑256 hashing, and custom signature logic to prevent crawling, request tampering, and replay attacks while maintaining high performance.
This article provides a comprehensive technical overview of pfinder, a Java‑based APM system, covering its core concepts, feature set, comparison with other tracing tools, bytecode instrumentation techniques, plugin architecture, trace‑ID propagation across threads, and a simple hot‑deployment implementation.
This article explains what Java virtual threads are, compares them with traditional threads, shows how to enable them in SpringBoot with configuration and code examples, and presents performance tests that demonstrate dramatic speed improvements for IO‑bound workloads.
This article provides a comprehensive explanation of Spring Boot's startup process, detailing each lifecycle extension point, the order of execution, common pitfalls with RPC/MQ/HTTP traffic, and includes runnable code examples to help developers master Spring initialization.
The article documents a production incident where each Spring Boot service consumed about 12 GB of memory on a 64 GB server, explains how default JVM settings caused the issue, and provides step‑by‑step troubleshooting and tuning guidance to reduce memory usage.
This article walks through MyBatis dynamic SQL tags—foreach, concat, choose, selectKey, if, where, trim, set, and sql fragments—explaining their attributes, usage patterns, and common pitfalls, and provides complete XML and Java code examples for each technique.
Learn how to set up a simple yet powerful Java logging solution by installing Loki and Grafana via Docker, configuring Loki4j in a Spring Boot project, and visualizing logs in Grafana dashboards, with step‑by‑step instructions and essential code snippets.
This article introduces Spring Cloud Alibaba AI, explains its relationship to Spring AI, and provides a step‑by‑step tutorial—including Maven setup, dependency configuration, code examples, and sample calls—to integrate Alibaba's Tongyi large‑model services for text QA, image generation, and speech synthesis in a Java Spring Boot application.
Spring Boot 3.3.1 introduces a comprehensive set of bug fixes, documentation updates, and numerous dependency upgrades, while also warning that the 3.0‑3.1 series has reached end‑of‑life, urging developers to migrate to the latest version for continued support.
This article documents the step‑by‑step investigation of an unexpected ~100 ms response delay in a Spring Boot channel service, showing how network checks, curl tests, Arthas trace/stack commands, and source analysis revealed a Tomcat‑embed bug caused by Swagger‑ui resources and how upgrading Tomcat resolved the issue.
Learn how to download massive files—such as multi‑gigabyte videos—by splitting them into chunks using HTTP Range headers, implementing a Java Spring backend with MinIO storage, multi‑threaded retrieval, and seamless merging, while also handling breakpoint resume and Swagger documentation.
This article explains the background of metrics in cloud‑native systems, shows how to expose custom Prometheus metrics using OpenTelemetry's MeterProvider, compares different exporters, and provides a complete Pulsar client example with code snippets and configuration for end‑to‑end observability.
The article measures the exact time cost of establishing and closing a MySQL connection from Java, breaks down each network and protocol step with Wireshark captures, and shows how these latencies add up to hundreds of milliseconds, making connection pooling essential for high‑traffic web services.
This article discusses the proper use of null‑checking in Java, distinguishes between valid and invalid null returns, proposes alternatives such as returning empty collections, using assertions or throwing exceptions, and demonstrates the Null Object pattern with concrete code examples while also noting related community resources.
On October 27, 2023, a sudden surge in request volume and downstream latency caused the bfe‑customer‑application‑query‑svc to exhaust its Tomcat thread pool, triggering health‑check failures and pod restarts; a deep dive revealed that an ill‑designed custom executor and unchecked thread‑waiting calls created a bottleneck that amplified the outage.
This article explains a Java-based contract signing system that combines the Chain of Responsibility, Composite, and Strategy design patterns within a Spring Boot application, detailing the processing flow, project structure, key code implementations, and how annotations and enums simplify bean injection.
This article provides a comprehensive overview of Java reflection, explaining its definition, underlying JVM mechanisms, practical usage with code examples, detailed source‑code walkthrough, advantages and disadvantages, and its critical role in popular frameworks such as Spring.
This article explains the concept of interface debouncing, identifies which API endpoints need it, and provides detailed Java implementations using custom @RequestLock annotations, Redis caching, and Redisson distributed locks to prevent duplicate submissions in backend services.
This article describes a real‑world API security incident, explains the fundamentals of asymmetric RSA and symmetric AES encryption, and provides a complete Java implementation—including a hybrid encryption strategy, custom @RequestRSA annotation, Spring AOP decryption aspect, and utility classes—to securely transmit and automatically decrypt request parameters.
The article explains BitMap fundamentals and introduces Roaring BitMap’s compressed container architecture—Array, BitMap, and Run containers—detailing their conversion logic, Java implementation snippets, performance advantages over traditional BitSets, and practical API usage for high‑performance, memory‑efficient big‑data applications.
This article explains how to use the LiteFlow rule‑engine framework to define reusable Java components, express execution flows with EL expressions, design a visual canvas that converts JSON into an abstract syntax tree, generate valid EL code via DFS, and manage workflow updates through push‑pull refresh mechanisms, while also outlining benefits and future plans.
Exploring the differences between PhantomReference and WeakReference in Java’s ZGC, this article explains how ZGC’s concurrent phases and the should_drop method use distinct bitmap bits to determine object liveness, revealing why only PhantomReference reliably tracks object reclamation in certain finalization scenarios.
The article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, unnecessary parameters, and complex inputs—then proposes a unified ResultBean response model, controller conventions, and AOP-based logging and exception handling to improve code readability and maintainability.
This article introduces the PowerJob Java distributed scheduling framework, explains its features and task types, provides step‑by‑step installation via JAR and Docker, demonstrates database setup, server and worker configuration, and details how to create and configure scheduled tasks with code examples.
This guide walks you through installing and configuring the CheckStyle plugin in IntelliJ IDEA, explains how to import custom rule sets, and details common style violations such as missing annotations, spacing, naming, formatting, logical errors, and import order, offering practical fixes to keep Java code clean and consistent.
This guide explains what an AI‑native application is, compares AI‑native and AI‑based approaches, and walks through Spring AI’s core features—including chat models, prompt templates, function calling, structured output, image generation, embedding, and vector stores—showing step‑by‑step code examples and how to assemble a complete AI‑native app with RAG support.
This article explains how to implement a gray (canary) release strategy in a Spring Cloud microservice ecosystem using Nacos for service discovery, Spring Cloud Gateway for request routing, Ribbon for load balancing, and custom filters and interceptors to control traffic based on request headers, IP, city or user ID.
This article explains why replacing MyBatis with MyBatis‑Plus caused a LocalDateTime conversion exception, identifies the root cause as an outdated mysql‑connector‑java version, and shows how upgrading the connector (to 5.1.37 or later) resolves the issue while providing code examples and debugging steps.
This article details how to switch a SpringBoot + MybatisPlus + MySQL project to PostgreSQL by adding the driver, updating JDBC settings, handling numerous SQL and type‑conversion pitfalls, and provides ready‑to‑run PostgreSQL scripts for bulk column modifications and default‑value settings.
This article explains why API debounce is essential, outlines which endpoints need it, describes how to generate unique keys, and provides complete implementations using Redis cache and Redisson distributed locks in a Spring Boot 3 backend, complete with testing results.
This article explains how Java thread pools handle exceptions differently when using execute() versus submit(), and shows how ThreadPoolExecutor can pre‑start core threads before task submission to achieve pool warm‑up.
This article investigates the mysterious "prevent gc" comment in RocketMQ source code, explains how Thread.sleep(0) interacts with JVM safepoints and counted loops, and demonstrates practical fixes by changing loop indices or inserting explicit safepoint calls.
This article explains how the JVM creates and manages FinalReference objects, how they interact with the finalize() method, and how the ZGC and other GC phases discover, revive, and eventually reclaim objects, detailing the roles of ReferenceHandler, FinalizerThread, and related internal data structures.
This article explains the concept of dynamic proxies, compares Spring's JDK‑based and CGLIB‑based proxy implementations with code examples, and shows how they power Spring AOP for cross‑cutting concerns such as transactions and logging.
This article presents a comprehensive collection of Spring Boot best practices—including package structuring, design patterns, starter usage, dependency management, constructor injection, SLF4J logging, pagination, caching, exception handling, naming conventions, and code quality tools—to help developers build more efficient, maintainable, and robust Java backend applications.
This article explains how Java's Thread.sleep(0) works, its native implementation, why it is used in RocketMQ source code, and how the call influences JVM garbage‑collection, safe‑point insertion, and CPU scheduling to improve multithreaded performance.
This article explains RabbitMQ’s architecture, details its core components, walks through the five main messaging patterns with visual diagrams, provides complete Java code examples for each pattern, and discusses reliability mechanisms such as acknowledgments, persistence, and practical use‑case scenarios.
This article explains how Java's CompletableFuture extends traditional concurrency tools with rich APIs for parallel execution, chaining, error handling, and timeout management, providing clear code examples that demonstrate building maintainable asynchronous applications.
This article introduces the URule rule engine, explains its background, installation steps, core concepts such as variable, constant, parameter, and action libraries, demonstrates both wizard‑style and script‑style rule sets, and provides complete Spring Boot integration code with real‑world usage scenarios.
This article presents a comprehensive guide to designing and implementing a Java‑based MySQL large‑table migration tool using microservice architecture, multiple design patterns, multithreading, custom logging, and flexible migration modes, complete with code snippets, repository links, and deployment considerations.
This article explains how HTTP's stateless nature requires session or token mechanisms for preserving user state, compares session‑based and JWT‑based authentication, details JWT structure, and provides a complete Java implementation with code examples.
This article introduces PowerJob, a young yet mature distributed task scheduling framework, explains why it was chosen, details its architecture, high‑availability design, deployment steps, and demonstrates various job types—including standalone, broadcast, map, and MapReduce—along with CRON, fixed‑rate, and fixed‑delay scheduling configurations.
This article explains the concept of remote calls, compares Feign and OpenFeign, walks through the step‑by‑step setup in a Spring Cloud project, and deeply analyzes the scanning, registration, dynamic proxy creation, MVC annotation parsing, request dispatch, Ribbon load‑balancing, and response handling mechanisms of OpenFeign.
This article explains common scenarios that cause MySQL or Java processes to consume 900% CPU, walks through step‑by‑step diagnosis using Linux tools, and provides concrete optimization techniques such as indexing, caching, thread analysis, and code adjustments to bring CPU usage back to normal levels.
This article examines the performance differences between using the '+' operator and StringBuilder for string concatenation in Java, presenting JUnit benchmark tests for simple concatenations and looped concatenations, analyzing compiled bytecode, and concluding that '+' is suitable for simple cases while StringBuilder excels in loops.
This article explains the Chain of Responsibility pattern, compares self‑driven and handler‑driven implementations with Java code, and demonstrates how major frameworks such as Spring Interceptor, Servlet Filter, Dubbo, and Sentinel realize the pattern, followed by practical usage scenarios.
This tutorial walks through designing a button‑level user permission system—including a five‑table database schema, Spring Boot + MyBatisPlus project setup, code generation, menu CRUD operations, recursive menu tree construction, role‑based permission queries, and annotation‑driven request authorization—complete with runnable code snippets and sample data.
This article explains Java generics, covering their syntax, type parameters, benefits such as compile‑time type safety and code reuse, demonstrates bounded and unbounded type erasure, and illustrates the need for bridge methods with detailed code examples.
This article provides an in‑depth explanation of the Spring Boot startup process, enumerates the key extension points, demonstrates their execution order with sample code and logs, and offers practical recommendations for correctly initializing RPC, MQ, and HTTP traffic.
The article explains why comparing floating‑point numbers with == in Java often yields unexpected results, describes the IEEE‑754 representation of float and double, demonstrates common pitfalls through code examples, and provides step‑by‑step methods for converting decimal fractions to binary.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean stereotypes, dependency‑injection and scope annotations, as well as Spring Boot conditional and lifecycle annotations, complete with code examples and usage tips for Java backend development.
Java's BigDecimal class offers arbitrary‑precision decimal arithmetic, requiring method calls like add, subtract, multiply, and divide instead of operators, and should be instantiated via String or valueOf to avoid double‑precision errors, with careful handling of scaling, rounding, formatting, and comparison for exact financial calculations.
This guide explains how to customize the Spring Boot startup banner by creating a banner.txt file, using ANSI color codes, retrieving various Spring Boot properties, and optionally disabling the banner altogether through code changes.
This article thoroughly explains the Spring Boot startup sequence, detailing each lifecycle extension point, common pitfalls with early RPC, HTTP, and MQ traffic, and provides code examples and answers to eleven critical questions to help developers master Spring initialization and avoid runtime failures.
This article explains why the Spring MVC @RequestBody annotation cannot be applied to multiple parameters in a single handler method, detailing the internal request‑body reading process, the resulting HttpMessageNotReadableException, and how to correctly handle multiple data parts using a single DTO.
This article provides a comprehensive guide to Java thread pools, covering common interview questions, core parameters, execution flow, lock mechanisms, custom queue implementations, rejection policies, best practices, monitoring strategies, and dynamic tuning with DynamicTp, all illustrated with code examples and diagrams.
This article analyzes the memory increase observed after enabling Log4j2 asynchronous logging in Java services, examines root causes such as thread‑local reuse and large char[] allocations, and presents configuration and code changes—including disabling thread‑locals and limiting message size—to prevent heap growth and improve performance.
This article explains why parameter validation is essential in Java web development, compares traditional manual checks with validator libraries, demonstrates practical usage of Bean Validation, Hibernate‑Validator, and Spring Boot starter‑validation, and covers advanced topics such as nested validation, group validation, custom constraints, and the underlying validation mechanism.
This article explains how to flexibly switch between Spring's built‑in @Scheduled tasks and XXL‑JOB implementations without changing existing code, by using conditional auto‑configuration, annotation scanning, task registration, log redirection, and a ready‑to‑use starter, complete with configuration examples and runtime verification.
This tutorial demonstrates nine practical ways to handle SpringBoot 3.2.5 request data, including Optional‑wrapped parameters, direct Servlet API access, retrieving the authenticated Principal, extracting method and locale, reading InputStream, using HttpEntity for headers and body, building request URIs, handling multipart parts, and passing flash attributes on redirects.
This article explains the fundamentals of Role‑Based Access Control (RBAC), its model classifications, permission concepts, and user‑group usage, then demonstrates how to implement RBAC in a Spring Security application, including in‑memory authentication, JWT integration, JSON login, and password encryption techniques.
This article explains how to use MyBatis dynamic SQL tags—including foreach, concat, choose, selectKey, if, where, set, trim, and sql fragments—providing clear examples and tips to write concise, error‑free XML mappings for Java backend applications.
This article demonstrates how a custom event published from a constructor in Spring Boot 3.2.5 can cause a deadlock, explains the underlying lock contention, and provides two solutions: using SmartInitializingSingleton to defer publishing and upgrading to Spring 6.2's multithreaded bean initialization.
The article explains common pitfalls in Java API design—such as inconsistent return formats, missing error handling, irrelevant parameters, and improper use of maps or JSON strings—and demonstrates how adopting a unified ResultBean structure together with AOP can improve readability, error management, and testability of backend services.
This article provides a deep technical analysis of Spring Boot's startup process, explains every relevant extension point, demonstrates how to log and verify execution order with sample code, answers eleven common questions about bean initialization, and offers practical guidance on when to safely open RPC, MQ, and HTTP traffic.
This article explains how to design a plug‑in architecture for a data‑governance service by using a custom URLClassLoader, Spring bean registration, and XXL‑Job integration to dynamically load, start, stop, upgrade, and unload individual governance tasks without restarting the whole service, and also shows how to persist the configuration in local YAML or Nacos.
The article shows how to implement a hot‑plug AOP system in Spring that lets users enable or disable logging at runtime by scanning, registering, and deregistering Advice/Advisor/Pointcut beans through the bean factory, demonstrated with a REST endpoint that adds or removes a logging interceptor.
This article explains how to build a clean, maintainable Controller layer in Java Spring by separating responsibilities, using unified response structures, applying ResponseBodyAdvice for automatic wrapping, implementing parameter validation with JSR‑303, and handling custom exceptions through centralized advice, illustrated with comprehensive code examples.
This article walks through Nacos's LongPollingService source code, showing how it extracts headers, calculates timeouts, detects configuration changes, enforces connection limits, and uses Servlet 3.0 AsyncContext to handle long‑polling without blocking threads.
This article walks through the problem of traditional session‑based captcha login, compares it with a modern front‑back‑separated architecture, and provides a step‑by‑step implementation using Spring Boot, Kaptcha, and Redis, including full code snippets, configuration classes, and flow diagrams.
To gracefully shut down a Java thread pool, use ExecutorService's shutdown() to reject new tasks, awaitTermination() to wait for running tasks with optional timeout, handle exceptions, and optionally invoke shutdownNow() for forced termination, as illustrated by code examples from Dubbo3 and RocketMQ.
The article explains a bug in Java's ConcurrentHashMap.computeIfAbsent that can cause recursive updates and infinite loops, leading to CPU spikes, and shows that newer Java versions throw an IllegalStateException while recommending avoiding nested computeIfAbsent/putIfAbsent calls, with a code example.
This article explains how to use SLF4J MDC together with a TraceId header to correlate logs across threads, services, and distributed tracing tools like SkyWalking, providing code examples for filters, Feign interceptors, thread‑pool adapters, and Logback configuration.
This article explains why RequestContextHolder fails to retrieve the HttpServletRequest in a multithreaded Spring MVC environment, demonstrates the problem with a concrete example, analyzes the underlying thread‑local handling of request attributes, and clarifies the default non‑inheritable behavior that leads to null requests.
This article provides an in‑depth tutorial on Java's BigDecimal class, covering its purpose, common constructors, essential arithmetic methods, comparison techniques, formatting with NumberFormat, handling of division exceptions, and a utility class offering precise add, subtract, multiply, divide, rounding, and comparison operations.
The article benchmarks Spring Boot and Quarkus for cloud‑native Java apps, showing Quarkus native images start up twice as fast, use less memory, and produce smaller artifacts than Spring Boot, while Spring Boot JVM offers slightly lower latency, and a migration guide demonstrates API compatibility and code reuse.
