This article explains MyBatis dynamic SQL concepts, details the nine dynamic tags (if, where, set, choose, trim, foreach, sql, include, association), provides complete XML mapper examples with code snippets, and demonstrates one‑to‑many, many‑to‑one, and many‑to‑many association queries for Java backend development.
This article explains how JD ElasticSearch has integrated the high‑performance ZSTD compression algorithm, details the motivations behind its adoption, presents benchmark results comparing it with LZ4 and best_compression, and provides step‑by‑step instructions and code snippets for configuring and using the new jd_zstd codec in Elasticsearch.
This tutorial shows how to install HashiCorp Vault, configure its secret engines, encrypt and decrypt data, store KV secrets programmatically, and integrate Vault with Spring Boot to protect sensitive configuration such as database credentials.
This article introduces the design and implementation of a remote hot‑deployment component (Mark42/Jarvis) built on Java Agent and an IDEA plugin, analyzes the challenges of dynamic compilation in Spring‑Boot fat‑jar environments, presents solution choices, and shares practical experiences and future directions.
This tutorial walks through setting up a Spring Boot backend, adding the Tess4J OCR library, creating a service and REST controller to recognize text from both local files and remote image URLs, and provides testing steps and deployment tips.
This article introduces the LMAX Disruptor library, explains its core concepts such as RingBuffer, Sequencer and WaitStrategy, and provides a step‑by‑step Java demo—including Maven dependency, model, event factory, handler, manager, service and test code—to build a fast, lock‑free producer‑consumer queue.
This tutorial demonstrates how to set up a SpringBoot Java service, expose its API through cpolar's internet‑penetration tunnel, configure a fixed sub‑domain, and use the cpolar listener to monitor and replay requests, providing a complete workflow for backend developers.
Discover ten IntelliJ plugins—including POJO‑to‑JSON, Cool Request, CamelCase, any‑rule, Grep Console, GenerateO2O, Smart Input, Squaretest, TONGYI Lingma, and Auto‑Filling Java Call Arguments—that streamline Java development, automate repetitive tasks, and enhance code quality for backend engineers.
Learn how Spring Boot 2.7.16 leverages ApplicationEvent and ApplicationListener for synchronous event handling, then explore two asynchronous approaches—using @Async with @EventListener and custom thread pools with a bespoke ApplicationEventMulticaster—complete with code examples and configuration details.
This article explains the LeetCode LRU Cache problem, detailing the required class interface, operational constraints, and provides a thorough Java solution using a HashMap combined with a doubly linked list to achieve O(1) time complexity for get and put operations.
This guide walks through creating a Spring Boot backend that accepts PDF, Word, and TXT uploads, extracts their text using Elasticsearch's ingest‑attachment plugin, stores metadata in MySQL, and provides fuzzy search and highlighted results via Elasticsearch queries.
This article showcases clever Lombok tricks—including @onConstructor, @Delegate, @Cleanup, @Singular, @Builder, and @With—demonstrating how they simplify Java code, improve readability, and integrate with Spring for dependency injection while warning against overuse.
This article explores the ten key architectural and implementation techniques—such as batch messaging, compression, Netty networking, zero‑copy I/O, sequential writes, efficient storage structures, asynchronous processing, batch handling, lock optimizations, and thread‑pool isolation—that together make RocketMQ a high‑performance message middleware.
This article provides a comprehensive guide to Spring 5.3.30 utility classes, covering resource handling, object and array utilities, number conversion, stream operations, system property resolution, collection helpers, AOP proxy tools, BeanFactory shortcuts, annotation processing, bean manipulation, validation, XML/HTML parsing, web utilities, and URI handling, all illustrated with clear code examples.
To prevent performance degradation during large MySQL data exports, this article presents a Java Spring implementation of a bounded FIFO export queue, detailing the ExportQueue class, abstract export handling with EasyExcel, concrete service and controller code, and test results demonstrating queue limits and concurrency considerations.
The article explains the concepts of cache penetration, cache breakdown, and cache avalanche, illustrates why they cause massive database load, and provides practical mitigation techniques such as parameter validation, storing null placeholders, Bloom filters, rate limiting, hot‑key pre‑warming, distributed locking, and cache pre‑warming strategies, with Java code examples.
This article explains how PageHelper's static ThreadLocal pagination parameters can be polluted by exceptions or thread reuse, leading to incorrect query results, and provides detailed analysis of the plugin's internals together with practical solutions such as invoking clearPage() via filters or aspects.
This tutorial walks through creating a Spring Boot application that integrates the OpenAI ChatGPT API, covering prompt concepts, API endpoint details, required request parameters, project setup, necessary dependencies, DTO definitions, RestTemplate configuration, and a REST controller to generate AI‑driven responses.
This article introduces the Hutool Java utility library, detailing its design principles and core features such as Convert, DateUtil, StrUtil, ReflectUtil, IdUtil, RandomUtil, BeanUtil, and JSONUtil, with code examples showing how each utility simplifies common development tasks and improves productivity.
This article explains how to implement custom asynchronous keywords in Java, addresses thread‑pool blocking when nested async tasks use a barrier, and presents a solution using a separate priority thread pool, atomic locks, and a linked‑blocking deque to prioritize high‑priority tasks.
This tutorial explains how Spring Boot's @ResponseStatus annotation works, demonstrates practical ways to throw ResponseStatusException, create custom exception classes, annotate controller methods, and replace the default error view with a custom JSON response, complete with code samples and diagrams.
This guide explains how to configure and use Spring Validation (JSR‑303) in Spring Boot, covering dependency setup, @Valid vs @Validated, request body and parameter validation, group, nested and collection checks, custom constraints, programmatic validation, fail‑fast mode, and underlying implementation details.
This tutorial walks through building custom Spring MVC core components—including a custom @PackEndpoint annotation, HandlerMapping, HandlerAdapter, and parameter resolver—complete with code examples and a test controller to demonstrate the full request handling flow.
This article explains several Java date‑time pitfalls—including leap‑year calculations, differences between YYYY/yyyy and HH/hh patterns, SimpleDateFormat initialization, Calendar hour fields, integer overflow in date arithmetic, thread‑unsafe usage of SimpleDateFormat, and daylight‑saving‑time handling—providing code examples and best‑practice recommendations.
This article compiles a comprehensive Java backend interview guide covering network protocols, HTTP characteristics, core data structures and algorithms, MySQL logging mechanisms, Elasticsearch full‑text search, Kafka reliability and deduplication, common micro‑service components, load‑balancing algorithms, and essential Spring concepts such as IoC, AOP, transactions, and MVC workflow.
This article explains the principle of internal network penetration, describes how to build a Java AIO‑based client‑service tunnel with separate modules for registration and data exchange, and provides complete source code and testing steps for remote access to locally deployed services.
This article describes how to achieve data environment isolation in a Java application by creating a custom MyBatis interceptor and annotation, allowing automatic SQL modification to handle env fields, reducing code changes, improving safety, and supporting flexible deployment across pre‑release, gray, and production environments.
This guide explains how to create and configure Spring Boot's RestClient, covering instance creation, request building, header and body handling, response retrieval, error processing, the exchange method, and available client request factories for robust synchronous HTTP communication.
This article explains the concept of delayed tasks, distinguishes them from scheduled tasks, and presents six practical Java implementations—including Quartz database polling, JDK DelayQueue, Netty's HashedWheelTimer, Redis sorted sets, Redis key‑space notifications, and RabbitMQ delayed queues—along with their advantages and drawbacks.
This article explains what constitutes a large Redis key, the performance problems it can cause such as CPU spikes, client timeouts and memory imbalance, and presents practical solutions including key cleanup, splitting, compression, pipeline usage, and alternative storage options.
This article walks through a real‑world order‑processing case, demonstrating how successive design‑pattern refinements—starting with the Chain of Responsibility, then adding Factory, Proxy, Template Method, Observer and distributed messaging—enable multi‑tenant, asynchronous, and scalable backend workflows.
This article examines the seemingly impossible condition "if(a == 1 && a == 12)" and demonstrates clever JavaScript and Java techniques that allow a single variable to satisfy multiple equality checks, turning a puzzling interview question into a fun exploration of language quirks.
This article analyzes the security, usability, performance, and scalability requirements of Java image captchas and proposes a technical solution covering generation, verification, and optimization to build a safe, efficient, and user‑friendly validation mechanism.
This article explores how Java's annotation mechanism, introduced in JDK 5.0, can be leveraged to address concurrency challenges by providing thread-safety, locking, timeout, and asynchronous execution annotations, and discusses their integration with AOP for enhanced thread management and performance.
This article details the migration from MyBatis to MyBatis-Plus in a Java project, explains the LocalDateTime conversion exception caused by MyBatis 3.5.1 and an outdated mysql‑connector‑java driver, and outlines the step‑by‑step fixes including driver upgrades and lessons learned from a separate file‑generation bug.
This article reflects on the author's journey with Java, explaining the immutable nature of the String class, its rich set of methods—including substring, indexOf, replace, and regex support—while also discussing its limitations and alternatives like StringBuilder.
This article explains how the Spring framework discovers and registers custom annotations by using @ComponentScan, ClassPathScanningCandidateComponentProvider, and TypeFilter mechanisms, guiding developers to configure package scanning, apply meta‑annotations, and optionally implement custom filters for flexible bean management.
This article introduces the Apache Commons Lang StringUtils class, demonstrating how its isEmpty, isNotEmpty, isAnyEmpty, isNoneEmpty, isBlank, isNotBlank, isAnyBlank, and isNoneBlank methods work with practical code examples and explains their behavior for different input scenarios.
This guide demonstrates how to integrate Tess4J OCR into a Spring Boot application, covering environment setup, Maven dependencies, adding language data, creating an OCR service class, building REST endpoints for local and remote image processing, and testing the solution.
This article analyzes why the total record count returned by PageHelper mismatches the actual number of rows, examines the underlying PageInfo and PageSerializable source code, and provides a concrete solution that avoids type conversion and directly constructs PageInfo from the mapper result to ensure accurate pagination.
This article demonstrates how to wrap EasyExcel within a Spring Boot + MyBatis‑Plus project to provide clean, reusable import and export APIs, covering environment setup, annotation usage, controller implementation, core service design, common pitfalls, and solutions for date and template handling.
This article explains the core concepts of high cohesion and low coupling, introduces common Java design patterns, demonstrates how Spring applies these patterns such as Singleton, Factory, Proxy, Observer, Chain of Responsibility, and Template Method, and provides practical code examples for real‑world scenarios.
This article introduces Java 8's CompletableFuture class, compares it with Future, demonstrates basic Future usage, then explores advanced asynchronous patterns—including CompletionService, chaining, exception handling, combining tasks, and various utility methods—providing code examples and execution results to illustrate each concept.
This article walks through the design and implementation of a simple, thread‑safe object pool in Java using a LinkedBlockingQueue, explains the underlying concepts such as factory pattern and queue trimming, and provides a complete code example with a test script and output analysis.
The article announces a Chinese patent (CN112905176B) for a SpringBoot‑based backend implementation method, outlines its technical steps and benefits, briefly introduces SpringBoot, and also includes promotional material for a ChatGPT‑focused community offering resources and exclusive offers.
This article walks through the One Billion Row Challenge, explaining the problem, baseline solution, and a series of progressive Java optimizations—from parallel streams and better JVMs to custom hash tables, Unsafe, SWAR, and statistical tuning—that shrink execution time from minutes to under two seconds.
A port alarm revealed a missing Java process, which was later traced to an OOM kill triggered by vim loading a 37 GB nginx log into an 8 GB container, illustrating how editor behavior and Linux's OOM killer can unexpectedly terminate critical services.
This article examines how anonymous inner classes and lambda expressions differ in their handling of outer class references, analyzes compiled bytecode to reveal potential memory leak risks, and demonstrates how explicit references affect lambda behavior in Java Android development.
This article introduces Spring Cloud Gateway as a powerful tool for building scalable microservice gateways, explains its reactive architecture and advantages, and provides a step‑by‑step tutorial—including Maven dependency, route configuration, custom filter code, and deployment instructions—plus suggestions for advanced features.
This article walks through the challenges of sharing a single database across pre‑release, gray, and online environments, explains how to add an env field for isolation, and shows a custom MyBatis interceptor and annotation‑driven AOP solution that rewrites SQL to automatically handle environment filtering and insertion while keeping business code untouched.
This guide shows how to integrate Apache Tika into a Spring Boot application, covering Maven dependencies, XML configuration, a Spring @Configuration class, and usage of Tika’s detection and parsing APIs for processing various document formats.
This article explains the concept and benefits of rate limiting, reviews popular Java libraries, and walks through a custom implementation using maps, locks, and atomic counters, complete with full source code and a test script demonstrating a 2‑requests‑per‑2‑seconds policy.
This article explains the key changes when upgrading to Spring Boot 3, covering URL matching deprecation, HTTP header size configuration, removal of Apache HttpClient support, Actuator endpoint sanitization, and various property and dependency updates for a smooth migration.
This article explains the purpose and benefits of rate limiting, reviews popular Java rate‑limiting libraries, and provides a step‑by‑step guide with complete source code for building a simple, thread‑safe custom rate limiter using maps, ReentrantLock, and AtomicInteger.
This article walks through the background, core concepts, and a complete hands‑on demo of LMAX Disruptor, showing how to configure Maven, implement ring buffers, event factories, handlers, producers, and a test suite to achieve high‑throughput, lock‑free messaging in Java.
This article introduces the lightweight yet powerful LiteFlow rule engine, explains its architecture, component types, EL rule files, data context handling, configuration, and demonstrates a practical e‑commerce workflow with hot‑deployment capabilities.
This guide demonstrates how to add Apache Tika to a Spring Boot project by declaring the tika‑bom, core and parser dependencies, providing a custom tika‑config.xml, creating a @Configuration class that builds a Tika bean, and then injecting the bean to detect, parse, or translate documents.
This article explains three practical Spring Boot approaches—scheduled tasks, delayed RabbitMQ queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with ready‑to‑use Java code examples.
This article presents 18 practical code review guidelines covering comments, logging, naming, parameter validation, exception handling, modularity, concurrency, testing, formatting, compatibility, security, transaction, idempotency, middleware, code smells, and remote calls, offering concrete examples and best‑practice recommendations for Java developers.
This guide explains how to handle large file uploads in Java by using instant (秒传) upload, chunked (分片) upload, and breakpoint resume techniques, detailing the underlying Redis state tracking, server‑side file writing with RandomAccessFile or MappedByteBuffer, and practical implementation steps for both front‑end and back‑end.
This article reviews the most widely adopted Java language enhancements introduced from Java 8 through Java 20, including local‑variable type inference, switch expressions, text blocks, records, pattern‑matching instanceof, sealed classes, and improved NullPointerException messages, providing examples and reference links for each feature.
The article presents a Java Spring solution that uses a custom URLClassLoader to dynamically load, register, and unload governance task JARs as Spring beans and XXL‑Job handlers at runtime, with configuration persistence via YAML or Nacos and Maven Shade packaging for seamless updates without service restarts.
This article explains why invisible token refresh is needed, describes backend automatic token renewal using Java JWT, provides full Maven dependencies and JwtUtil implementation, shows unit‑test examples, and discusses frontend token extension strategies and edge‑case handling.
This article explores the advantages of combining Java, Spring Boot, and Vue for full‑stack web development, outlining the technology selection, step‑by‑step development workflow, best practices for code quality, testing, debugging, performance optimization, and deployment using containerization.
This article introduces Java’s origins, key characteristics, environment setup, basic syntax, object‑oriented concepts, exception handling, common libraries, and simple practice projects, providing beginners with a comprehensive foundation to start programming in Java.
The article explains how Java's annotation mechanism, including @ThreadSafe, @NotThreadSafe, @GuardedBy, and @Immutable, can be applied to clarify and manage concurrent behavior, helping developers resolve the timing uncertainties inherent in multithreaded programming.
This article introduces the String class, covering its immutable nature, essential methods such as substring, indexOf, replace, concatenation techniques, formatting, comparison, sorting, and search capabilities across languages like Java and Python, highlighting its fundamental role in text processing.
This article examines how bitmap data structures and multithreading can dramatically accelerate blacklist filtering in large‑scale marketing systems, reducing processing time from tens of minutes to milliseconds while saving memory and improving overall system performance.
This article explains how to integrate Spring Boot with Minio to enable direct client‑side file uploads by generating time‑limited presigned credentials on the backend, covering environment setup, Maven dependencies, configuration classes, REST endpoints, response fields, and complete front‑end examples including chunked and resumable uploads.
Graceful Response is a Spring Boot component that provides unified response wrapping, global exception handling, and custom error codes, helping developers reduce boilerplate, improve code readability, and accelerate API development while maintaining consistent error responses.
The article explains how to execute parallel tasks with CompletableFuture, why @Async cannot guarantee transactional integrity in a multi‑threaded Spring environment, and presents a programmatic transaction approach—including copying transaction resources between threads—to achieve consistent commit or rollback across concurrent operations.
This article explains why JVM tuning matters, identifies scenarios that require tuning such as performance bottlenecks, memory overflows, and concurrency issues, and then details monitoring and diagnostic tools—including JDK command‑line utilities and third‑party solutions—followed by a comprehensive guide to JVM parameters, garbage‑collector selection, and practical ways to apply these settings in production environments.
This article presents a real‑world case study of optimizing massive batch‑processing tasks in an ad‑platform by applying query‑level improvements, cursor‑based pagination, shard‑aware batch updates, JVM‑tuned garbage collection, and distributed load‑balancing, ultimately reducing CPU usage from 80% to under 2% and cutting query‑per‑minute volume from millions to a few thousand.
This guide explains the five ThreadPoolExecutor rejection policies in Java—AbortPolicy, CallerRunsPolicy, DiscardPolicy, DiscardOldestPolicy, and custom handlers—detailing their behavior, use‑cases, and providing concrete code examples for each.
This guide explains how JVM determines heap size on physical machines versus containers, compares behavior of different JDK releases, and provides concrete Docker commands and JVM flags—such as -Xms/-Xmx, -XX:+UseCGroupMemoryLimitForHeap, and MaxRAMPercentage—to reliably control memory usage in containerized Java applications.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.
This tutorial walks you through creating a custom Spring Boot Starter, from Maven project setup and dependency configuration to defining auto‑configuration classes, registering them, and writing comprehensive unit tests to verify conditional behavior.
This article introduces the open‑source Disruptor library, explains its core concepts such as Ring Buffer, Sequence, Sequencer and Wait Strategy, and provides a step‑by‑step Java demo—including Maven dependency, event model, handlers, configuration, producer, and test code—to show how to build a fast in‑memory message queue.
This article introduces J2Cache, a two‑level caching framework for Spring Boot, explains its L1 (Caffeine/Ehcache) and L2 (Redis/Memcached) architecture, and provides a complete hands‑on example covering Maven dependencies, configuration, core service classes, REST controller, and testing procedures.
The article chronicles Sun Microsystems' birth, its breakthrough with workstations, the development of SPARC CPUs and Solaris OS, the rise to market dominance, and the eventual decline caused by strategic missteps and competition from Linux and Intel, offering insights into technology‑driven business management.
This tutorial explains how to integrate Elasticsearch into a Spring Boot application, covering project setup, dependency addition, configuration, entity and repository creation, service and controller implementation, and testing to enable efficient full‑text search for large data sets.
Facing rapid business expansion, Huolala’s quality assurance team tackled redundant code, high regression costs, and lack of coverage metrics by designing an intelligent automated testing framework that analyzes effective code, provides smart test case recommendations, visualizes progress, and integrates monitoring, resulting in significant coverage improvements and efficiency gains across services.
The article clarifies Java processes and threads using a game analogy, then demonstrates three thread‑creation techniques—extending Thread, implementing Runnable, and implementing Callable with FutureTask—while covering run vs start, thread control methods such as sleep, join, and daemon settings.
This article thoroughly explains OpenFeign’s core architecture, including its dynamic proxy mechanism, seven essential components, the process of building and executing HTTP calls, and how Spring Cloud integrates and configures OpenFeign through annotations, factories, and property settings.
This article explains Spring Boot’s @MatrixVariable feature, covering its RFC 3986 basis, practical usage scenarios, multiple code examples, and the underlying request‑mapping mechanism, helping developers efficiently pass multi‑dimensional parameters within URI paths.
This article analyzes typical reasons why Java backend services experience sustained 100% CPU usage—such as bulk data retrieval, Kafka auto‑acknowledgement, infinite loops, excessive multithreading, massive file synchronization, deadlocks, inefficient regular expressions, and heavy real‑time calculations—and offers practical mitigation strategies.
This guide walks you through setting up the Java environment, downloading Apache RocketMQ 5.1.4, installing its NameServer, Broker, and optional Proxy components on an Ubuntu 20.04 cloud instance, and configuring both local and cluster deployment modes with optional visual dashboard tools.
This tutorial explains how to create a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration class creation, registration via spring.factories, and comprehensive unit testing to ensure correct conditional behavior.
Learn how to set up Camunda, a flexible Java-based BPMN 2.0 workflow engine, within a Spring Boot application by generating a project, configuring dependencies, defining data models and REST endpoints, designing a simple process diagram, and testing the workflow end‑to‑end.
Discover how the low‑code Java framework Erupt enables rapid creation of full‑stack admin applications without writing front‑end code, by using annotations to generate CRUD pages, integrating with SpringBoot, configuring dependencies, and extending with modules for scheduling, code generation, monitoring, NoSQL, and magic‑API.
This article explains how to integrate Spring Retry into a Spring Boot project to gracefully handle third‑party API failures, covering annotation‑based retries, asynchronous retries, exception filtering, fallback handling, and an optional Hystrix circuit‑breaker extension for comprehensive fault tolerance.
This article introduces LiteFlow, a powerful rule‑engine framework for Spring Boot, explains its advantages, shows how to define rules in XML/JSON/YML, and provides a complete end‑to‑end example with code snippets and hot‑swap components for flexible business logic.
This article explains the differences between DTO, BO, PO, and VO in backend development, illustrates their roles with Java code examples, and shows how to configure global settings to filter null fields in DTOs, reducing the need for separate VO objects.
Spring Boot offers several ways to validate request parameters—including the @Valid and @Validated annotations and custom validation annotations—each with its own strengths, allowing developers to enforce data integrity, improve code quality, and enhance user experience across different scenarios.
This article explains how to design and implement a two‑level caching architecture in Spring Boot by combining a local Caffeine cache with a remote Redis cache, covering manual approaches, annotation‑driven management with Spring Cache, and a custom AOP solution to minimize code intrusion.
This article explains pagination rationalization in SpringBoot using MyBatis PageHelper, illustrates common unreasonable pagination scenarios, demonstrates a bug caused by page deletion, and shows how a simple two‑line configuration or per‑query setting resolves the issue while detailing the underlying implementation.
This article examines eight common reasons why Java backend services experience 100% CPU usage—such as fetching excessive data, automatic Kafka acknowledgments, infinite loops, multithreaded imports, massive file syncs, deadlocks, inefficient regular expressions, and heavy real‑time calculations—and provides practical mitigation strategies.
This guide explains how Spring Boot automatically registers Servlet, Filter, and Listener beans, how to customize their mappings with registration beans, configure the embedded servlet container, and handle JSP limitations, providing code examples and practical tips for backend developers.
This guide walks through systematic troubleshooting of Java applications by checking CPU, disk, memory, and network layers, using tools like jstack, jmap, vmstat, iostat, and tcpdump to pinpoint and resolve performance and stability problems.
This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.
