This article introduces the evolution of Java workflow engines, explains core BPMN concepts, and provides a comprehensive tutorial on integrating Flowable with Spring Boot—including Maven dependencies, database configuration, BPMN diagram creation, service task implementation, diagram viewing API, and unit testing.
Spring Boot enables modular backend development by placing each feature in its own Maven module and using @Import (or custom annotations, ImportSelector, ImportBeanDefinitionRegistrar, and @ConditionalOnProperty) to load configuration classes, scan components, and conditionally register beans while keeping the application a single monolithic program.
This article explains Spring Boot’s asynchronous processing mechanism, covering its purpose, the @Async annotation, configuration steps, custom thread pool setup, handling return values, and typical use cases, enabling developers to improve performance and responsiveness in backend applications.
This article examines why many large‑scale systems avoid the traditional delayed double‑delete cache‑invalidation strategy, explains its critical drawbacks, and presents alternative lease‑based and version‑based approaches with Lua scripts and Java wrappers for Redis to achieve stronger consistency.
This article introduces Apache Commons Lang 3, explains its key utilities, and demonstrates how to integrate the library with Maven and employ DiffBuilder and ReflectionDiffBuilder to compare Java objects, generate detailed difference reports, and simplify debugging and testing processes.
This guide explains how to efficiently and elegantly handle null pointer checks in Java by identifying data types, selecting the right utility classes such as StringUtils, ObjectUtils, Arrays, Collections, and applying their isEmpty methods to reduce repetitive code.
Explore the contrast between declarative and imperative programming, dive into Java Stream fundamentals, benchmark parallel versus sequential execution, and understand the role of annotations, offering practical insights for writing cleaner, more efficient backend code.
This article explains why plugin mechanisms improve modularity, extensibility, and third‑party integration, then walks through practical Java SPI implementations, custom configuration loading, and Spring Boot’s spring.factories approach, providing complete code examples and step‑by‑step guidance for building a robust plugin system.
This article explains Java 8's StampedLock—its optimistic and pessimistic read/write modes, internal state handling, source‑code walkthrough, typical usage scenarios, and a performance comparison with ReentrantLock and ReentrantReadWriteLock—providing concrete code examples and detailed analysis for developers.
The article surveys popular Java expression engines—including Spring Expression Language, OGNL, Aviator, and MVEL2—detailing their key features and providing lightweight utility wrappers, and highlights Hutool’s unified façade that can encapsulate these engines to simplify dynamic rule evaluation in backend applications.
This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the parameter list, executing the sub‑queries concurrently with a custom Spring AOP annotation, and merging the results using a configurable thread pool and return‑handling strategy.
This article explains how to improve performance of massive IN‑list queries in PostgreSQL by splitting the list, executing sub‑queries in parallel using a custom Spring AOP annotation, and merging the results with a configurable handler, providing a reusable solution for Java backend services.
This article presents ten practical MyBatis techniques—including dynamic SQL, resultMap, foreach, pagination, annotation proxies, second‑level cache, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—to help Java developers write cleaner, safer, and more performant data‑access code.
This article breaks down Java's three memory regions—Heap, Off‑Heap, and No‑Heap—detailing their definitions, management mechanisms, performance impacts, typical use cases, and provides concrete code samples for allocating each type of memory.
This article explains why thread execution order is nondeterministic and presents eight Java techniques—join, single‑thread executor, CountDownLatch, CyclicBarrier, Semaphore, synchronized with wait/notify, and Lock with Condition—to reliably enforce sequential execution, complete with clear code examples for each method.
Java developers can parse JSON using six popular approaches—Jackson for high‑performance, annotation‑driven serialization; Gson for a lightweight, easy‑to‑use API; FastJSON for speed; JsonPath for XPath‑style nested extraction; org.json for simple utility; or manual parsing for full control—each suited to different performance and complexity needs.
This article explains how to integrate Spring Boot with MyBatis, configure a single Druid data source, implement a dynamic routing data source for multiple databases, and use custom annotations and AOP to switch databases at runtime, including full code examples and transaction management.
This article introduces and compares several Java expression engines—including Spring Expression Language, OGNL, Aviator, MVEL, and Hutool's expression facade—detailing their key features, typical use cases, security considerations, and providing utility class examples with code snippets for each engine.
This article provides a step‑by‑step tutorial on using Maven for Java backend projects, covering repository configuration, basic POM structure, dependency declaration, scope handling, exclusion, variable properties, multi‑module management, dependencyManagement, and common build plugins such as jar, assembly, and shade.
This article explains what Java enums are, why they are preferable to constants, demonstrates basic and custom enum definitions, shows how to compare, switch, and extend enums with properties, methods and constructors, and explores advanced uses such as EnumSet, EnumMap, Singleton and Strategy patterns, including Java 8 stream examples and JSON serialization.
This article introduces Java 8's Optional class as a robust solution for avoiding NullPointerException, explains its creation methods, demonstrates common operations such as get, isPresent, ifPresent, filter, map, flatMap, orElse, orElseGet, orElseThrow, and provides practical usage scenarios and cautions for developers.
This article describes how a legacy SSM‑based backend reporting service was refactored by archiving log data, leveraging Redis for hourly counters, and scheduling synchronization tasks to dramatically reduce query time for millions of records without adding external processing frameworks.
The article explains that in Java's SimpleDateFormat the lowercase y pattern (year‑of‑era) should be used for calendar dates, because the uppercase Y pattern represents a week‑based year which can incorrectly roll over to the next year near year‑end, causing bugs.
This article explains how to handle massive Excel‑DB import/export tasks in Java by comparing POI workbook types, selecting the right implementation, and leveraging EasyExcel with batch queries, sheet splitting, and JDBC batch inserts to process over three million rows efficiently.
This article introduces Java's java.util.concurrent.atomic package, detailing the core atomic classes—AtomicBoolean, AtomicInteger, AtomicLong, and LongAdder—including their constructors, key methods, typical use cases, and performance considerations in high‑concurrency scenarios for developers seeking efficient thread‑safe operations.
This article explains the Fork/Join model and ForkJoinPool in Java, covering divide‑and‑conquer theory, RecursiveTask implementation, task submission methods, work‑stealing queues, common pool pitfalls, and performance testing with code examples to help developers choose and tune parallel execution strategies.
This article presents a comprehensive guide to Spring's utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—detailing their purpose, usage patterns, and code examples, while also containing promotional material for related services.
Beyond the JDK, modern Java backend development relies on a core toolkit—including SpringBoot, Netty, Guava or Hutool utilities, JUnit 5 with Mockito, JMH, OkHTTP, HikariCP or Druid pools, Caffeine cache, Hazelcast, SLF4J + Logback, Jackson, Jolokia, Hibernate‑Validator, and FreeMarker—to build robust, high‑performance enterprise services.
This article introduces several Chinese open‑source AI platforms, shows how to import their Java SDKs, obtain API keys, run test demos, encapsulate a reusable AI module with Spring Boot configuration, and apply prompt‑engineering techniques to generate AI‑driven questionnaire content.
This article explains Java virtual threads, compares them with regular threads, shows how to enable them in SpringBoot, and presents performance tests that reveal up to a 200‑fold reduction in latency for IO‑bound workloads.
This article explains why Java's BigDecimal can guarantee lossless precision in financial calculations by examining its class definition, internal fields, example usage, and the detailed implementation of its add method, including scaling and long‑integer arithmetic.
This article compares six popular Java JSON parsing approaches—Jackson, Gson, FastJSON, JsonPath, org.json, and manual parsing—detailing their features, code samples, advanced options, and pros and cons to help developers choose the right tool for their projects.
This article explains how Java HotSpot uses a card‑table memory set to efficiently detect and handle cross‑generational references during young‑generation GCRoot scans, avoiding full old‑generation scans and significantly improving garbage‑collection performance.
This article explains six typical techniques—@RequestParam, @PathVariable, @MatrixVariable, @RequestBody, @RequestHeader, and @CookieValue—for extracting request data in Spring Boot APIs, providing usage scenarios and concrete code examples for each method.
To remediate CVE‑2023‑6378 in a Spring Boot 2.7.x application, you must replace the default logging starter with a direct Logback 1.2.x dependency (e.g., 1.2.13), because Spring Boot 2.7 cannot use Logback 1.3.x due to the removed StaticLoggerBinder class; the only other option is to upgrade the whole stack to Spring Boot 3.x, Logback 1.4.x, and JDK 11.
This article explains the challenges of thread synchronization in distributed systems, introduces the concept of distributed locks, compares common implementations such as Redis, Zookeeper, and databases, and provides robust Java and Lua solutions to ensure atomicity, avoid deadlocks, and support lock renewal.
Spring Boot 3.4 introduces extensive updates—including RestClient and RestTemplate auto‑configuration, revised HTTP client factories, refined bean validation, graceful shutdown defaults, a new Paketo tiny builder for OCI images, deprecations, and numerous configuration and observability enhancements—providing developers with a comprehensive guide to upgrade and leverage the latest features.
This article presents a curated list of 31 IntelliJ IDEA plugins—including translation tools, language packs, UI themes, code navigation, version control, code quality, and productivity enhancers—that together streamline Java backend development and improve developer efficiency.
This article explains various plugin implementation approaches in Java, including SPI, ServiceLoader, custom configuration, and Spring Boot's spring.factories, providing detailed code examples and step‑by‑step guidance for building extensible backend systems that can be dynamically loaded and configured at runtime.
This article explains how to prevent duplicate data submissions in a Spring Boot application by designing an idempotent mechanism using AOP and Redis, covering the concept, design strategy, custom annotation, aspect implementation, and a simple test controller.
The 2024 Java trend report analyzes JDK adoption rates, AI tooling, the rise of the Commonhaus Foundation, Spring and Jakarta EE evolution, virtual thread adoption, and community insights, offering guidance for technical leaders and developers planning their future investments.
This article explores the role of WebSocket in IoT, detailing its advantages over HTTP, comparing Java implementations, presenting a Netty‑based architecture for smart devices, and providing complete code examples for connection handling, authentication, and message processing to achieve real‑time communication.
This article provides a comprehensive tutorial on Apollo, covering its basic concepts, architecture, four-dimensional configuration model, client design, high‑availability considerations, and step‑by‑step instructions for creating a Spring Boot project, integrating Apollo dependencies, configuring environments, testing dynamic updates, and deploying the application on Kubernetes.
This article compares Java and Go across syntax, type systems, object‑oriented features, pointer usage, error handling, concurrency models, and reflection, providing code examples to illustrate the practical differences and trade‑offs for developers transitioning between the two languages.
This article details how a legacy reporting module suffering from slow page loads was refactored by archiving log data, caching hourly counts in Redis, and using scheduled synchronization to dramatically improve query performance without adding new middleware.
The article investigates a mysterious "prevent gc" comment in RocketMQ's source, explains how Thread.sleep(0) forces a JVM safepoint to mitigate long GC pauses, and demonstrates that changing loop counters from int to long eliminates the need for the hack.
A senior developer recounts switching from C# and Python to Java for web projects and higher pay, illustrating Java’s evolution from a “toy” language with early JVM limits to an enterprise powerhouse driven by JIT, Spring Boot, and robust performance that now rivals C++.
This article provides a comprehensive overview of Domain-Driven Design (DDD), explaining its core principles, layered architecture, domain model components such as entities, value objects, aggregates, and bounded contexts, and includes Java code examples to illustrate implementation.
This article introduces Java Stream API introduced in JDK 8, explains its pipeline concept, and demonstrates practical operations such as traversal, filtering, deduplication, type conversion, collection‑to‑map transformations, pagination, matching, and parallel processing with clear code examples.
This article explains how the i++ and ++i operators are implemented at the JVM bytecode level, using concrete code examples and step‑by‑step analysis of each instruction to show why i++ can output 8 while ++i yields 9.
This guide walks through building Spring Boot controller endpoints, standardizing request parameters, applying unified status codes with ResultVo, leveraging @Validated for bean validation, and using @RestControllerAdvice to globally handle exceptions and automatically wrap responses.
This article explains how Java's garbage collectors work, covering generational memory spaces, major algorithms such as mark‑sweep, mark‑compact, and copy, the most common collectors for young and old generations, safe points, throughput calculations, and tuning parameters.
This article walks through migrating an old MySQL‑5.7 project from MyBatis 3.5.0 to MyBatis‑Plus 3.1.1, explains the "Conversion not supported for type java.time.LocalDateTime" exception, shows how upgrading mysql‑connector‑java resolves the issue, and shares lessons learned from a production bug caused by an over‑optimistic validation change.
This article explains how to refactor the Spring MVC controller layer by introducing a unified response format, using ResponseBodyAdvice for automatic wrapping, fixing String conversion issues, applying JSR‑303 validation, creating custom validators, and handling exceptions globally to keep controller code clean and maintainable.
This article provides a comprehensive analysis of Spring's @Autowired annotation, explaining its purpose, usage in constructor, field, and method injection, and detailing the underlying bean post‑processor logic, dependency resolution, and candidate selection that enable automatic dependency injection.
This article presents a step‑by‑step guide to building a Netty‑based WebSocket server in Java, covering server initialization, channel configuration, custom handlers, push‑message services, testing procedures, and includes complete source code, while also containing promotional material for unrelated AI services.
This tutorial explains how to combine Spring Boot, MyBatis, and multiple databases using Druid connection pools, dynamic routing data sources, custom annotations, and AOP, providing complete configuration examples, code snippets, and best‑practice guidance for backend developers.
This article explains how to make Spring AOP logging configurable at runtime by dynamically adding or removing Advice objects through custom endpoints, event listeners, and plugin management code, and demonstrates the approach with a complete example including service, controller, and aspect jar.
The article examines the performance impact of excessive logging in large‑scale Java systems and proposes request‑level sampling with cross‑thread identifier propagation, offering practical component‑based solutions, implementation considerations, and a concrete code example for backend developers.
Log volume can cripple high-throughput Java systems, especially during traffic spikes, so this article explores practical strategies for request-level log sampling, cross-thread trace propagation, and component-based APIs to balance observability with performance, including code examples and implementation considerations.
Fast‑Retry is a high‑throughput Java retry library that enables asynchronous, non‑blocking retries for massive task volumes, offering programmable and annotation‑based APIs, custom retry policies, and significant performance gains over traditional synchronous frameworks like Spring‑Retry and Guava‑Retry.
This article explains a long‑standing JDK bug where Arrays.asList().toArray() returns an Object[] that causes ArrayStoreException when modified, analyzes the underlying implementation differences between java.util.ArrayList and Arrays$ArrayList, and describes how the issue was finally fixed in JDK 9.
This article introduces OAuth2.0 concepts, outlines its roles and grant types, and provides a step‑by‑step Spring Boot implementation of an authorization server, resource server, and test client, followed by test results and promotional information.
This article explains how to prevent brute‑force password attempts by locking an IP after three failed logins using a Spring Boot backend, Redis for distributed counters, and a Lua script to ensure atomic increment and expiration, while also providing a simple HTML login page for the front end.
The article explains LeetCode 491, requiring all non‑decreasing subsequences of length ≥2 from an integer array, and details a depth‑first search approach that uses a per‑level set to skip duplicates, with complete example implementations in Java, C++, C, and Python.
This article introduces Java 21 virtual threads, explains their lightweight, high‑concurrency and automatic management advantages, demonstrates basic and delayed usage with code examples, shows how to enable them in Spring Boot, and compares their performance against traditional threads in various scenarios.
This article explains the origins of big‑data technologies, details the architecture and read/write mechanisms of Hadoop's HDFS, describes the MapReduce programming model, and provides complete Java code examples for a simple distributed file‑processing job using Maven dependencies.
This chapter introduces advanced Java multithreading concepts, explaining thread safety, the synchronized keyword, various synchronization techniques, and practical code examples such as object‑level, class‑level, method‑level synchronization and double‑checked locking to help solve concurrency problems in performance testing.
This article explains the principles of object pooling in Java, introduces the Commons Pool 2 library and its use in Redis client Jedis, compares pool and non‑pool performance with JMH benchmarks, and details the fast HikariCP database connection pool along with configuration tips and interview questions.
This article provides a comprehensive overview of Spring and Spring Boot's extensible interfaces, detailing each extension point, its lifecycle stage, usage scenarios, and sample code, enabling developers to better understand and customize bean initialization within the backend framework.
This article provides an in‑depth overview of Java’s Collections Framework, detailing the core interfaces (List, Set, Queue, Deque, Map), their major implementations, performance characteristics, thread‑safety considerations, iterator usage, utility classes, and concurrent collection options, illustrated with code examples and diagrams.
This article explains how Spring Boot uses Tomcat by default, introduces Undertow as a high‑performance alternative, provides step‑by‑step Maven configuration to switch containers, compares Tomcat and Undertow on throughput and memory usage, and recommends Undertow for high‑concurrency Java web applications.
This article explains how to replace Shiro with jCasbin for permission management in Spring Boot, covering Maven dependency setup, configuration files, Enforcer initialization, custom policy handling, and a simple servlet filter for runtime authorization checks.
FastExcel, a Java‑based open‑source library announced after EasyExcel's discontinuation, offers fast, memory‑efficient Excel read/write, full compatibility with EasyExcel, simple APIs, MIT licensing for commercial use, easy Maven/Gradle integration, and clear code examples that have already attracted over 2,000 GitHub stars.
This article demonstrates how to replace tightly‑coupled if‑else or switch‑case logic with the Service Locator Pattern in a Spring application, allowing new file‑type parsers such as XML to be added without modifying client code, thereby adhering to the Open/Closed principle.
This article explains how a CDP system tackles the storage and set‑operation challenges of billions of user‑ID tags and groups by adopting bitmap techniques, especially RoaringBitmap, to dramatically reduce space usage and enable fast union, intersection, and difference calculations.
This article presents twelve practical MyBatisPlus optimization techniques—including avoiding isNull checks, specifying select fields, batch operations, using EXISTS, safe ordering, LambdaQuery, between, index-aware sorting, pagination, null handling, performance tracking, enum mapping, logical deletion, optimistic locking, and increment/decrement—to write cleaner, faster, and more maintainable backend code.
FastExcel, the newly renamed successor to EasyExcel, offers high‑performance Excel read/write, full compatibility, new features like row‑specific reading and PDF conversion, and provides detailed migration instructions with Maven/Gradle dependencies and code examples for Java developers.
This guide walks through identifying Java processes that cause high CPU load, extracting the hottest threads with top and jstack, analyzing JVM memory regions, interpreting GC logs, and applying practical JVM tuning parameters and tools such as jmap, jstat, and MAT to resolve performance bottlenecks.
This article introduces the motivation, architecture, technology choices, and key implementation details of a lightweight, highly extensible distributed job scheduling framework built on gRPC, Protobuf, a custom name‑server, and a bespoke message‑queue, addressing limitations of existing solutions like Quartz, XXL‑Job, and PowerJob.
This article explains the concept of idempotency in distributed systems, its importance for preventing duplicate orders in e‑commerce, outlines a solution using unique request identifiers, and provides a Java code example illustrating how to implement idempotent order creation.
This article compares Java and Go across syntax simplicity, type systems, object‑oriented features, pointers, error handling, concurrency, reflection, and community culture, providing concrete code examples and practical insights to help Java developers transition smoothly to Go.
This article explains the Knuth-Morris-Pratt (KMP) string‑matching algorithm, describes how the next array is built to capture prefix‑suffix information, shows Java implementations of the search and next‑array construction, and discusses common optimizations to reduce redundant comparisons.
This article introduces a free, low‑code web tool that lets backend developers instantly generate a functional admin‑type frontend UI from database schemas or Java/SQL description files, requiring only minimal configuration and no front‑end coding skills.
Discover ten powerful MyBatis techniques—from dynamic SQL and resultMap customization to batch operations, pagination, annotation‑based mappers, caching, dynamic table names, custom type handlers, logging, and multi‑datasource configuration—that can dramatically improve Java backend development efficiency and code quality.
This article explains why data desensitization is essential for modern enterprises, compares masking, obfuscation and encryption techniques, and provides step‑by‑step implementations for database, log, and output layers using MyBatis interceptors, Fastjson filters, and Spring MVC configuration.
Java’s ubiquitous NullPointerException stems from Tony Hoare’s 1965 introduction of the null reference—a design he later called his ‘billion-dollar mistake’—and the JVM mitigates its cost by forgoing proactive checks, instead relying on OS signals like SIGSEGV to detect nulls and throw the exception only when they actually occur.
The article announces the rebranding of EasyExcel‑Plus to FastExcel, outlines its high‑performance features, provides migration instructions and code samples for Maven and Gradle, and additionally promotes a ChatGPT community and related services.
This article proposes an asynchronous timeout implementation for CompletableFuture in JDK 8, addressing the lack of built-in timeout interruption capabilities and providing a solution for precise task timeout control.
This article explains why JDK 8's CompletableFuture lacks built‑in timeout interruption, analyzes common usage patterns and their limitations, and presents a custom asynchronous timeout solution that works in both JDK 8 and JDK 9 environments, complete with reusable utility code.
This article walks through the design and implementation of symmetric AES encryption for both GET and POST API endpoints in a Spring Boot application, covering requirement analysis, data model definition, custom RequestBodyAdvice and ResponseBodyAdvice, serialization challenges with FastJSON vs Jackson, and final configuration to ensure consistent JSON output across encrypted and non‑encrypted responses.
This article explains how to plan capacity, choose the appropriate garbage collector, allocate heap and non‑heap memory, and configure JVM flags—including Xms, Xmx, Xmn, Xss, and GC‑specific options—to reliably support a service node with 8 GB RAM handling one million login requests per day.
This article explains the concept of request debouncing, identifies which API endpoints need it, and provides a detailed tutorial on implementing distributed debounce using shared Redis cache or Redisson locks in a Spring Boot backend, complete with annotation design, unique key generation, and code examples.
This article compares seven practical approaches—DelayQueue, database polling, Redis queues, Redis key expiration callbacks, RabbitMQ delayed messages, scheduled task frameworks, and event‑stream processing—for automatically cancelling unpaid orders, outlining their suitable scenarios, code examples, advantages, disadvantages, and optimization tips.
Java developers should avoid ten common thread‑pool mistakes—such as using unbounded queues, misconfiguring thread counts, neglecting shutdown, ignoring rejection policies, swallowing task exceptions, submitting blocking work, overusing pools, lacking monitoring, and missing dynamic tuning—by configuring bounded queues, proper sizes, explicit policies, exception handling, and runtime adjustments.
The article compares using Optional.ofNullable with map() versus a traditional null‑check ternary operator for retrieving a Hyperlink's link property, evaluates their readability, performance, and suitability, and extends the discussion to native versus utility‑based collection‑empty checks in Java.
The article introduces the Cool Request IDEA plugin, explains its tracing capabilities for arbitrary packages, automatic MyBatis function monitoring, customizable timing colors, script-based environment manipulation, and provides a Java code example for handling responses, highlighting its usefulness for backend developers.
This article explains why using the == operator on two Integer objects in Java can yield true for some values and false for others, covering Integer caching, the role of Integer.valueOf, and the correct way to compare Integer values with equals.
The article announces EasyExcel's shift to maintenance mode, introduces its successor FastExcel with high‑performance features, and provides detailed migration steps, dependency configurations, and code examples for reading and writing Excel files in Java.
By configuring MySQL’s rewriteBatchedStatements=true, pre‑generating primary keys, adjusting MyBatis executor settings, and employing asynchronous multithreaded batch inserts, this guide demonstrates how to accelerate MyBatis‑Plus saveBatch operations from seconds to milliseconds, achieving up to a 2000% performance gain in large‑scale data scenarios.
