This article explores the major Java 17 language enhancements—including records, sealed classes, pattern matching, text blocks, var, and the new switch expression—showing how they reduce boilerplate, improve readability, and boost performance compared to legacy Java 8 code.
This article explains how to enforce data‑access restrictions in MyBatis‑Plus by creating a custom @UserDataPermission annotation, building an InnerInterceptor that rewrites SQL queries, handling role‑based scopes, and integrating the interceptor into the MyBatis‑Plus plugin for both basic and advanced use cases.
This article demonstrates how to decouple business logic from validation in Spring Boot 3 by creating a custom @BusinessValidation annotation, defining rule interfaces, implementing concrete validators, and using an AOP aspect to execute them with configurable fast‑fail and exception handling, complete with code examples and testing.
This article explains how the open‑source SmartAdmin project satisfies China’s Level‑3 security protection requirements by detailing identity verification, access control, audit, intrusion prevention, data integrity, confidentiality, backup, and masking, and shows the corresponding UI settings and backend code implementations.
This article introduces PowerJob, a young yet powerful distributed task scheduling framework, covering its selection reasons, core concepts, high‑availability setup, workflow types, scheduling modes, deployment steps, and detailed code examples for single, broadcast, map, and MapReduce jobs.
This article explains the internal mechanics of Java virtual threads, the role of Continuation, pinned threads, and carrier threads, and provides concrete monitoring techniques using JVM flags, JFR events, and framework-specific considerations for Helidon and Quarkus.
This article demonstrates how to create a complete real‑time message broadcasting system using Spring Boot 3's reactive Server‑Sent Events (SSE) and WebFlux, covering the core Sink component, backend implementation, and a simple front‑end page to display live updates.
This article explains the Java Service Provider Interface (SPI) concept, contrasts it with traditional APIs, details the ServiceLoader mechanism, showcases real‑world uses in JDBC, Spring, and Dubbo, and discusses its advantages and drawbacks for building modular back‑end systems.
This tutorial shows how to use the x‑file‑storage library to unify file operations across multiple storage platforms such as Amazon S3, MinIO, and RustFS in a Spring Boot application, providing step‑by‑step Docker setup, Maven configuration, YAML settings, and controller code.
By imposing a strict 1 GB memory cap on identical workloads across Go, Rust, Node.js, Python (Flask/Gunicorn), and Java Spring Boot, this study reveals how each language’s runtime handles memory pressure, detailing survival times, performance quirks, and ultimate failure modes.
This guide demonstrates how Arthas enables rapid, non‑intrusive diagnosis of Java production problems by addressing common online challenges such as slow interfaces, thread blocking, memory leaks, hot‑fixes, and data inconsistencies, offering concrete commands, code examples, and best‑practice tips for reliable operations.
This article introduces a continuously updated collection of 151 Spring Boot 3 practical examples, covering built‑in retry mechanisms, concurrency limits, and automatic HTTP client registration, complete with configuration snippets, code samples, and visual illustrations to help developers implement resilient backend services.
This article explains how oversized database query results can cause JVM heap spikes, frequent Full GC, or OOM crashes in Java services, and demonstrates a non‑intrusive MyBatis interceptor solution that monitors, grades, and blocks risky queries while exposing Prometheus metrics for proactive alerting and capacity planning.
This article demonstrates how to apply the Chain of Responsibility design pattern together with SOLID principles to refactor a video upload, transcoding, review and publishing workflow, providing clear Java examples, UML diagrams, and Spring integration for a maintainable, extensible solution.
The article recounts a series of three OOM incidents in a production service that combines Paimon data lake and RocksDB via an SDK, detailing the step‑by‑step investigation, the discovery of excessive bucket‑driven thread creation and off‑heap memory leaks, and the final mitigation measures that restored stability.
This article reveals the hidden default configurations of Spring Boot—such as Tomcat connection limits, HikariCP pool sizes, Jackson timezone handling, logging, caching, file upload limits, async thread pools, static resource caching, and transaction timeouts—and provides practical YAML adjustments to prevent performance bottlenecks and production failures.
A developer upgraded an old Spring Boot project by swapping MyBatis for MyBatis‑Plus, ran into a Conversion not supported for java.time.LocalDateTime error, traced the root cause to MyBatis 3.5.1 delegating type conversion to an outdated mysql‑connector‑java, and resolved it by upgrading the connector and adjusting validation logic, illustrating the ripple effects of component upgrades.
LangChain4j 1.2.0 introduces a suite of stable modules, advanced inference and thinking capabilities, streaming tool calls, and extensive AI service enhancements, offering developers finer control, lower latency, and richer debugging for LLM‑driven applications.
This article explains the fundamentals of Java NIO, showing how to use Channels and ByteBuffer to efficiently read, write, and manipulate large files, including memory‑mapped files and RandomAccessFile alternatives, with clear code examples and step‑by‑step guidance.
Learn how to efficiently remove duplicates from 4 billion QQ numbers using a memory‑friendly Bitmap approach that fits within a 1 GB limit, including calculations, step‑by‑step implementation, Java code, and a discussion of its advantages and drawbacks.
This article introduces JD's open‑source JoyAgent‑JDGenie, a lightweight multi‑agent framework, explains its architecture and performance, and provides step‑by‑step instructions for local Docker deployment, configuration, and usage for creating AI‑driven applications.
The article examines the challenges of achieving distributed consistency when a business operation writes to MySQL and external systems, analyzes failure scenarios, and presents a step‑by‑step solution that splits the large transaction into small, retryable tasks with Spring afterCommit optimization.
This article demystifies Java's volatile keyword by explaining how instruction reordering, CPU caches, store buffers, memory barriers, and the JVM's happens‑before rules work together to guarantee correct visibility and ordering in multithreaded programs.
FlowLong is a domestically developed, high‑performance workflow engine that uses JSON‑based process models and a visual designer to simplify complex approval scenarios, integrates seamlessly with Spring Boot and Mybatis‑Plus, provides extensive BPMN features, and includes detailed installation, architecture, and database schema documentation.
This article explains the fundamentals of Java I/O streams, showing how to efficiently read, write, copy, delete, move, and inspect both text and binary files using NIO, Buffered streams, and modern APIs, while providing ready‑to‑use code examples.
Spring Framework 7.0 introduces built‑in resilience annotations @Retryable and @ConcurrencyLimit, eliminating the need for external spring‑retry dependencies and enabling declarative retry, exponential backoff, and concurrency throttling—including reactive support—so developers can write cleaner, more robust Java backend services.
A seemingly trivial pagination update in a Java order service caused a P0 outage, leading to a 73‑minute disruption, 156 user complaints, and an estimated 650,000 CNY GMV loss; the post details the root cause, impact analysis, emergency response, and concrete process improvements to prevent recurrence.
Based on recent Maimai data, the article analyzes the stark contrast between soaring demand and high salaries for AI talent and the oversupply, declining wages, and hiring difficulties faced by Java programmers, illustrating the causes, real‑world case studies, and actionable strategies for developers to adapt.
This guide shows how to integrate Spring Boot DevTools for automatic hot deployment, configure remote debugging via Docker, and streamline development with IDE auto‑build settings, providing step‑by‑step code examples and configuration snippets.
The article explains how Maven's default resource filtering corrupts binary .p12 certificates during packaging, causing Spring Boot startup failures, and provides a step‑by‑step solution using dual resource configurations and best practices for handling binary files in Java backend projects.
This article presents a coding challenge that asks Java developers to perform common I/O operations—reading files, streams, URLs, sockets, and more—in a single line of code, and demonstrates how the jd.commons library provides concise fluent APIs to achieve these tasks while reducing boilerplate.
This article explains the challenges of multithreaded programming, compares blocking, lock‑free and wait‑free approaches, details essential atomic primitives, and provides a practical Java lock‑free stack implementation with best‑practice guidelines.
This article walks developers through Maven's core concepts, including repository configuration, basic project structure, dependency management, module inheritance, unified dependency versions, and common plugins such as jar, assembly, and shade, while also covering build settings like JDK version, resource exclusion, and main‑class configuration.
This article explains Java’s reverse‑domain package naming convention, illustrates it with a Maven project structure, and outlines four key advantages—collision avoidance, global uniqueness, readability, and logical layering—while showing how the open‑source mall‑swarm micro‑service project applies these principles.
In this detailed case study I describe how I discovered the CRMEB Java e‑commerce project on GitHub, cloned and evaluated its features, customized product, order, and payment modules for a mother‑and‑baby shop, tackled environment setup, performance tuning, and deployment, and ultimately delivered a fully functional marketplace that boosted my freelance income fivefold.
This article introduces Java 25, the upcoming LTS release, detailing its major language and compiler enhancements, new APIs such as Scoped Values and Structured Concurrency, and provides complete preview‑ready code examples to help developers quickly grasp each feature.
This article explains the MicroProfile OpenAPI 3.0 specification, covering its architecture, configuration options, core properties, annotation usage, server definitions, programming model, model readers, filters, processing rules, endpoint behavior, and release notes for both 3.0 and earlier versions.
This article explains why using the plain new operator is far faster than reflection, shows how an object pool can dramatically reduce memory usage and allocation time, and demonstrates a factory‑plus‑cache pattern that eliminates most repetitive new calls, delivering up to three‑fold performance gains.
This article explains Java’s happens‑before guarantees, covering instruction reordering, the visibility guarantees of volatile variables and synchronized blocks, and demonstrates how improper reordering can cause stale data or wasted resources through detailed code examples such as FrameExchanger and ValueExchanger.
This comprehensive guide explains Java's synchronized keyword, covering instance and static methods, synchronized blocks in various contexts, data visibility, instruction reordering, object selection, performance considerations, and alternatives, with clear code examples for multithreaded programming.
This article explains Spring's circular dependency problem, distinguishes when such dependencies are harmless, shows why constructor injection can still fail, and details how Spring's three‑level cache with singleton, early‑singleton, and factory caches resolves setter‑based circular dependencies, including code examples and key source snippets.
This article chronicles the fictional archaeological discovery of Java, tracing its origins at Sun Microsystems, its golden era in enterprise and Android development, the explosion of design‑pattern culture, its struggle against modern micro‑service trends, and its ultimate decline in the age of AI‑driven coding.
This guide explains how to let users upload a JAR that implements a predefined interface, then hot‑deploy the new implementation at runtime using either Spring annotation‑based bean registration or pure Java reflection, complete with utility methods for loading, registering, and cleaning up beans.
This guide explores the core pain point of frequent business rule changes versus system stability, introduces five rule engines (Drools, Easy Rules, QLExpress, Aviator, LiteFlow), compares their performance, advantages, disadvantages, and provides practical selection tips and pitfalls to avoid.
Learn how Spring interceptors work, their relationship with WebApplicationContext, various types, configuration methods, execution flow, advanced features, and practical examples such as logging and authentication, plus a comparison with servlet filters and demo results.
This article explains Spring Interceptors, their relationship with WebApplicationContext, various types, configuration methods, execution flow, advanced features, differences from filters, and provides practical logging and authentication examples with code snippets.
Fuzz testing injects massive amounts of random or semi‑random inputs into applications to expose crashes, logic errors, and security flaws, and the article explains its principles, the types of defects it uncovers, real‑world practices at Google Chrome, and step‑by‑step Java integration using CI Fuzz and JUnit.
Spring 7.0 introduces JmsClient, a modern, stream‑oriented API for JMS messaging that mirrors the design of JdbcClient and RestClient, offering fluent creation, flexible destination configuration, rich QoS options, and simplified send/receive operations compared to the traditional JmsTemplate.
This article demonstrates how to implement flexible, decoupled data permission control in Spring Boot 3 by defining a @DataPermission annotation, creating strategy classes for different scopes, wiring them through an AOP aspect, and integrating the solution with JPA entities, MyBatis mappers, and comprehensive test cases.
This article explains how Java’s volatile keyword ensures variable visibility across threads, details its full visibility and happens‑before guarantees, explores instruction reordering challenges, outlines scenarios where volatile alone is insufficient, and discusses performance considerations and alternative synchronization mechanisms.
This article explains the Java Memory Model, how the JVM organizes memory into thread stacks and heap, how threads interact with shared variables, the impact of hardware memory architecture, and practical techniques like volatile and synchronized to ensure visibility and avoid race conditions.
This article explains what false sharing is in Java, how cache lines and cache‑line invalidation cause performance penalties, and provides concrete code examples and @Contended annotation techniques to detect and fix false sharing for faster multithreaded applications.
This article presents nine practical methods for loading files from the resources directory in a Spring Boot project, covering ClassLoader, Class, Spring ResourceLoader, ResourceUtils, ApplicationContext, ServletContext, Java IO, NIO, and ClassPathResource approaches.
This tutorial introduces the magic‑api Java framework, shows how to integrate it with Spring Boot, configure data sources, create the necessary MySQL tables, and implement full CRUD operations, parameter validation, result transformation, transaction handling, and Swagger documentation using concise scripts.
An extensive performance benchmark compares four GUID generation techniques—UUID, Snowflake algorithm, ThreadLocal exclusive counters, and atomic counters—across varying thread counts, revealing that ThreadLocal excels in high‑concurrency single‑machine scenarios while Snowflake remains stable for distributed use, with detailed optimization recommendations.
This article explains how to solve the Student Geographic Information Report problem by defining a Student class, using three‑level nested Java Maps for province‑city‑district grouping, and implementing aggregation and ranking logic to count students per region and identify the city with the most students.
Generating globally unique identifiers (GUIDs) is essential for performance testing and business scenarios such as user behavior tracking, and this article compares five approaches—UUID, centralized services, Snowflake, ThreadLocal, and Atomic classes—detailing their principles, advantages, drawbacks, and suitable use cases for high‑concurrency systems.
This article explains how a comprehensive, full‑stack security approach using Spring Security—covering request sanitization, parameterized queries, and built‑in authentication, authorization, CSRF and session safeguards—can dramatically reduce XSS and SQL injection vulnerabilities to near zero.
This article explains how to implement precise sliding‑window rate limiting using a Redis Lua script and a Spring‑based Java component, compares it with fixed‑window and token‑bucket approaches, and provides advanced techniques, production tips, and performance optimizations.
The article explains the fixed‑window rate‑limiting algorithm, details a thread‑safe Java implementation, shows how to realize distributed limiting with Redis Lua scripts, compares advantages and drawbacks, provides performance benchmarks, and offers practical usage scenarios and production recommendations.
This tutorial explains Java 8 parallel streams, their performance trade‑offs, and how to run them with a custom ForkJoinPool to improve speed while avoiding memory leaks, including code examples and best‑practice recommendations.
This article explains how to let users upload a JAR containing a custom implementation of a predefined Java interface, then hot‑deploy the new implementation using either Spring annotation‑based injection or pure reflection, covering interface definition, bean registration, and cleanup.
This article examines a puzzling code condition where a variable appears to satisfy contradictory checks, presents creative JavaScript and Java solutions that exploit language quirks, and reflects on the broader learning value of such unconventional programming challenges.
This article walks through Spring Bean Validation fundamentals, demonstrating how to apply built‑in constraints, create custom validators, use group validation, perform cascading request validation, and enable method‑level checks, all with clear code examples and best‑practice recommendations.
This tutorial walks you through constructing a lightweight ReAct agent using Java, explaining the Thought‑Action‑Observation loop, providing a 200‑line code example, and demonstrating a real‑world approval workflow with prompts, tool definitions, and step‑by‑step interaction logs.
This article explains why code quality matters in growing Java projects and introduces five essential static analysis tools—Alibaba Java Coding Guidelines, CheckStyle, PMD, FindBugs, and SonarLint—covering their purpose, installation steps, usage instructions, and key features to help developers reduce bugs and improve review efficiency.
This article walks through the design and implementation of a Java rule engine, illustrating how to abstract rules, create a reusable executor with AND/OR logic, and demonstrates the full code, while discussing its advantages, drawbacks, and practical usage in real‑world applications.
This tutorial demonstrates how to use Spring Batch in Spring Boot 3 to read Excel files with PoiItemReader, map rows to Java objects, process and write data, and optimize memory usage by switching to StreamingXlsxItemReader for large datasets, complete with full code examples and configuration details.
This guide walks you through configuring Spring Boot 3 with Spring Security OAuth2 Authorization Server to enable OpenID Connect, covering bean setup, client registration, token retrieval, user info customization, and accessing the OpenID configuration endpoint, complete with code examples and essential notes.
This guide explains what Spring Task is, shows how to add the dependency, enable scheduling annotations, write cron‑based methods, and covers common use cases, pitfalls, and performance tricks for building reliable backend scheduled jobs in Java.
This article explains why static fields injected with @Autowired in Spring can become null, causing NPEs in production, and presents six practical solutions—including removing static fields, using @PostConstruct, static setters, ApplicationContext, singleton patterns, and @Lazy loading—to ensure reliable static dependency injection.
This article explains the hidden pitfalls of Lombok’s @Builder annotation, why it often violates the Builder pattern, and presents @Accessors and manual fluent setters as safer, more flexible alternatives for Java backend development.
This article introduces the five most common Reactor error‑handling operators—onErrorReturn, onErrorResume, doOnError, retry, and blockOptional—explains their distinct behaviors, appropriate scenarios, and common pitfalls, and provides concise code examples for each within Spring WebFlux.
This article introduces ten practical Spring Boot 3 starter libraries—ShedLock, p6spy, Logbook, Jasypt, Bucket4j, gRPC, Retrofit, MapStruct‑Plus, Redisson, and Resilience4j—detailing their purpose, Maven coordinates, configuration snippets, core usage code, and links to official documentation, helping developers quickly enhance performance, security, and reliability in backend projects.
This article demystifies Spring Boot's auto‑configuration by breaking it into four layers—annotation composition, loading engine, conditional assembly, and property binding—providing clear explanations, code examples, and common pitfalls to help developers ace interview questions and master backend development.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and reliably send Kafka messages either immediately or after transaction commit, illustrated with a payment‑system use case and complete code examples.
An in‑depth comparison of three popular Java low‑code admin frameworks—JeecgBoot, RuoYi, and Renren‑fast—covers their advantages, drawbacks, feature richness, learning curve, typical use cases, and provides clear recommendations on which platform best fits enterprise, medium‑scale, or lightweight projects.
This article presents seven practical Spring Boot performance tuning techniques—including asynchronous execution, Tomcat connection tuning, component scanning, switching to Undertow, BufferedWriter usage, DeferredResult handling, and AsyncHandlerInterceptor interception—each illustrated with concise Java code examples to help developers boost application speed and scalability.
This article explains why the @Transactional annotation fails in multithreaded Spring batch insert scenarios, demonstrates the problem with code examples, and shows how to use SqlSession for manual commit and rollback to guarantee atomicity across all threads.
This article, part of an async‑programming series, explains how Spring WebFlux’s non‑blocking Mono model can replace traditional Spring MVC blocking calls, presents common business scenarios, provides ready‑to‑use code templates, and demonstrates the performance benefits of reactive programming for high‑throughput Java backends.
This article explains the concept of state machines, why traditional if‑else logic is problematic, compares popular Java state‑machine frameworks, provides performance benchmarks, walks through a complete Spring Statemachine implementation for order processing, and offers practical optimization and monitoring tips for high‑throughput scenarios.
This article presents a comprehensive Spring Boot 3 tutorial that integrates Apache Camel, explains the ProducerTemplate API, demonstrates route definitions, shows code examples for sending messages, file writing, bean processing, and AI chat integration, and includes test result screenshots.
This article explains common constructor mistakes such as starting threads, calling overridable methods, and using too many parameters, demonstrates how the Builder pattern and default-value constructors can dramatically reduce boilerplate, improve readability and performance, and offers practical guidelines for safe constructor design.
This article explains how backpressure works in Spring WebFlux, outlines the built‑in Reactor strategies, provides practical code examples for handling slow consumers, and offers guidance on choosing and monitoring the right approach to keep reactive applications resilient under load.
This article explains the concept of backpressure, its implementation in Spring WebFlux, and presents practical strategies—including buffering, dropping, latest, and error handling—along with code samples to help developers manage data flow efficiently in reactive backend applications.
MyBatis-Flex is a lightweight, high‑performance MyBatis enhancement framework that offers flexible CRUD, powerful query capabilities, extensive database support, and significant speed advantages over MyBatis‑Plus, with detailed feature comparisons, performance benchmarks, and a step‑by‑step quick‑start guide.
Explore the seven most commonly used encryption algorithms—including MD5, SHA families, HMAC, AES, DES/3DES, RSA, and DSA—detailing their principles, Java implementations, performance, and practical security guidelines, while highlighting real-world attack scenarios and best‑practice recommendations for robust information protection.
This article explains Spring Boot 2.3's built‑in graceful shutdown feature, how to enable it with server.shutdown=graceful, configure timeout‑per‑shutdown‑phase, compare container behaviors, use the Actuator /shutdown endpoint, and provides code examples and practical steps to avoid data loss during termination.
During massive daily imports of up to one million reconciliation records, MySQL deadlocks can cripple performance; this article dissects the four classic deadlock conditions, then presents a systematic “One‑Order Four‑Split” strategy—ordered writes, transaction splitting, index management, partitioning, and gap‑lock removal—backed by benchmarks, code samples, and configuration tweaks that cut lock rates by up to 90% and reduce batch times to under ten minutes.
This article shows how to replace inefficient front‑end polling with a Spring WebFlux server‑sent events (SSE) solution that pushes file‑import progress to the browser in real time, providing complete code for the progress service, import logic, controller, and a vanilla‑JS front‑end example, plus deployment tips.
This article explains microbenchmarking concepts, demonstrates how to use the Java Microbenchmark Harness (JMH) to accurately measure and compare the performance of specific code snippets such as synchronized methods, and provides practical guidance for integrating JMH into Java projects for reliable performance testing and regression analysis.
The article analyzes a critical service outage caused by missing initialization checks for a core dependency, leading to uncaught ExceptionInInitializerError, thread pool exhaustion, and unresponsive HSF services, and outlines the investigation steps, root cause, and three concrete remediation actions.
This article explains nine practical techniques—including narrowing component scans, enabling lazy initialization, excluding unused auto‑configurations, using a component indexer, tuning the database pool, avoiding heavy bean init tasks, leveraging CDS, running exploded jars, and employing GraalVM native images—to dramatically reduce Spring Boot 3 application startup time.
This article explains the fundamentals of Domain-Driven Design, compares it with traditional MVC, details DDD’s layered architecture, core concepts such as entities, value objects, aggregates, services and events, and walks through a complete SpringBoot demo project with code, directory layout, database schema and deployment steps.
This article provides a comprehensive guide to Spring Batch, covering its purpose, architecture, core components such as Job, Step, ItemReader/Writer/Processor, chunk processing, skip strategies, and practical tips for configuring and optimizing batch jobs in Java applications.
This article introduces 24 essential Spring Boot utility classes—covering bean handling, AOP support, core framework helpers, and common I/O and conversion tools—providing concise explanations and runnable code snippets that demonstrate how each utility simplifies everyday backend development.
This article provides a comprehensive, step‑by‑step analysis of Java's ConcurrentHashMap, covering its evolution from JDK 7’s segment‑lock design to JDK 8’s bucket‑level CAS and synchronized approach, complete with macro diagrams, microscopic source‑code walkthroughs, hash calculations, resizing mechanisms, and practical usage tips.
This article walks through creating a server‑side license‑plate recognition solution using Java SpringBoot 3.x, Tesseract OCR, and OpenCV, covering project goals, Maven dependencies, image‑processing services, special‑plate handling, and a REST API for real‑time plate detection.
This article explains the differences between static and dynamic proxies in Java, demonstrates how to implement static proxies, JDK dynamic proxies, and CGLib proxies with complete code examples, and compares their advantages, limitations, and typical use cases in backend development.
The article first examines how large tech companies are shifting away from short‑term performance cycles to encourage long‑term strategic work, then presents LeetCode problem 670 “Maximum Swap” with detailed explanations and implementations in Java, C++, Python, and TypeScript, including complexity analysis.
