This article shares practical lessons from real‑world production incidents, explaining why graceful shutdown, proper listener registration timing, consistency requirements, retry mechanisms, idempotency, and traffic control are essential when using Spring Event in Java backend systems.
This article explains Java's CompletableFuture, its advantages over the traditional Future API, demonstrates common methods with code examples, and shows how RocketMQ leverages CompletableFuture to coordinate asynchronous disk flush and replica synchronization tasks.
This article provides a step‑by‑step guide to Java concurrency, covering core concepts such as threads, runnables, thread lifecycle, synchronization primitives, wait/notify patterns, volatile variables, ThreadLocal storage, and how to design immutable objects for thread‑safety, all illustrated with concrete code examples and detailed explanations.
The IntelliJ IDEA 2024.1 EAP 5 release brings powerful enhancements for Spring and other Java frameworks, richer HTTP client capabilities, improved GitHub Actions support, and various productivity tweaks such as JSON schema handling and automatic header completion, all aimed at boosting backend developers' efficiency.
This article explains how to use Spring Boot's @InitBinder annotation in @Controller and @ControllerAdvice classes to customize WebDataBinder for parameter binding, type conversion, and formatting, and provides five practical examples demonstrating custom editors, converters, global binders, and field restrictions.
This tutorial explains how to add Redis dependencies to a Spring Boot project, configure connection settings, use RedisTemplate for basic operations, enable Spring Cache, employ Redisson for distributed locks, and fine‑tune connection pool and timeout parameters, providing complete code examples.
This guide walks Java developers through essential keytool commands on CentOS 7, covering keystore creation, key pair generation, CSR creation, certificate import, listing entries, and exporting certificates to simplify SSL/TLS handling.
Spring Boot, an evolution of the Spring framework, simplifies project setup, offers built-in web servers, provides production-ready features, and enhances development efficiency, distinguishing it from traditional Spring which requires extensive XML configuration and external servlet containers, making Boot the preferred choice for modern Java backend development.
This article demonstrates how to use Spring Data R2DBC with Spring Boot 3 to perform reactive 1‑to‑1 and 1‑to‑many database operations, covering environment setup, entity definitions, repository queries, custom converters, and unit testing for full‑stack backend development.
The article explains the root causes of frequent OutOfMemoryError in a Java backend service, analyzes how MyBatis’s SQL building can exhaust heap memory, demonstrates a reproducible test case, and offers practical recommendations to prevent and resolve such memory leaks.
This article explains the fundamentals of finite state machines, introduces Spring Statemachine's features, and provides a step‑by‑step guide—including code samples, persistence options, testing, and AOP‑based error handling—to implement reliable order processing flows in Java backend applications.
This article explains the classic State design pattern, demonstrates a traffic‑light example, compares Spring State Machine with COLA, and walks through building a complete order‑status workflow in Spring Boot using enums, configuration, listeners, services, and a test controller, while highlighting trade‑offs and alternatives.
This article explains why the @Transactional annotation fails in Spring when using multithreading, demonstrates a failing example, and provides a solution using manual SqlSession management to guarantee that all database changes are rolled back if any thread encounters an exception.
This article explains the fundamentals of finite state machines, demonstrates how to model order states using Spring Statemachine, shows persistence options with in‑memory and Redis stores, and provides advanced techniques such as exception handling, extended state tracking, and AOP‑based result logging for reliable state transitions.
The article shows how to generically export any Java object's data to an Excel‑compatible CSV file by using reflection to convert objects into maps, building headers (optionally via a @JcExcelName annotation) and writing the result with a reusable utility class and Maven‑managed Apache POI, FastJSON, and Commons‑IO dependencies, illustrated through SpringBoot controller and main‑method examples.
The article explains Xxl‑Job’s lightweight distributed scheduling architecture—detailing its Scheduling Center, Executor, and Task components, demo installation steps, Maven configuration, executor bean setup, job‑handler types, scheduling logic, thread‑pool and routing strategies, blocking policies, result callbacks, and overall HTTP‑based communication flow.
This article explains MyBatis caching mechanisms, detailing the scope, implementation, configuration, and differences between first-level (SqlSession) and second-level (mapper) caches, and how they improve query performance while outlining their default behaviors and usage considerations.
This article documents a month‑long investigation and tuning of a Java backend server, detailing how FullGC frequency was cut from dozens per day to a handful by adjusting heap parameters, fixing a memory‑leak caused by anonymous inner‑class listeners, and optimizing metaspace settings.
This tutorial explains how to secure a Spring Boot REST API using API key authentication, covering the addition of Maven dependencies, creating a custom filter, extending AbstractAuthenticationToken, configuring the security filter chain, and testing the protected endpoint with curl commands.
This tutorial explains how to use Spring Cloud Gateway for unified API routing, metrics collection, metadata handling, timeout settings, fluent Java route definitions, service‑discovery routing, and troubleshooting techniques in microservice architectures.
This article explains how to guarantee transactional integrity when importing a 100,000‑row Excel file with asynchronous threads in Spring, covering double‑async optimization, Future and CompletableFuture handling, @Transactional pitfalls, manual transaction control, and a complete solution for cross‑thread transaction management.
This article explains fundamental XML concepts, DTD and entity definitions, demonstrates common XXE attack scenarios such as file reading, internal network probing, DoS and XInclude exploitation with Java code examples, and provides practical security hardening techniques including disabling XInclude, DTD parsing, and external entity resolution.
The solution introduces a plug‑in architecture that uses a custom URLClassLoader to load governance task JARs at runtime, registers their Spring beans and @XxlJob handlers with XXL‑Job, and provides unload logic to deregister jobs, destroy beans, and update configuration via YAML or Nacos without restarting the service.
This article demonstrates how to automate CRUD operations in a Spring Boot application by leveraging MyBatisPlus, creating utility methods, a generic BaseController, pagination configuration, and extending it in concrete controllers, providing reusable code for rapid backend development.
Cache warming, a technique used in high‑concurrency systems to preload frequently accessed data before traffic spikes, improves hit rates, reduces latency, prevents cache breakdowns, and eases backend load, with methods ranging from startup loading and scheduled jobs to Spring Boot listeners, Redis tools, and Caffeine loaders.
Passing a HttpServletRequest to a regular thread in Spring Boot causes Tomcat to recycle the request after the servlet returns, making parameters unavailable and yielding null values, so you must use the servlet async API (startAsync and complete) to keep the request alive.
This article examines why scheduled tasks are needed, outlines common Java scheduling frameworks for both single‑machine and distributed environments, and provides a detailed side‑by‑side comparison of Elastic‑Job, X‑Job, Quartz and other solutions, highlighting their architectures, clustering, sharding, monitoring, scaling and failure‑handling strategies.
This article explains how to obtain return values from asynchronous Java methods using FutureTask, covering its AQS foundation, execution flow, get() behavior, and provides concrete source code examples for practical implementation.
Unexpected duplicate registrations, truncated query results, and password‑reset SQL errors in a Java backend were traced to PageHelper’s ThreadLocal pagination state persisting across requests when startPage() is called without immediate query execution, so developers should ensure immediate execution or manually clear the ThreadLocal to prevent stale LIMIT clauses.
This article explains the Snowflake algorithm—a Twitter‑originated distributed ID generator—detailing its 64‑bit structure, key benefits such as uniqueness and high throughput, its main drawback of clock‑dependency, and provides guidance on implementing it in Java.
This article explains why exceptions from tasks submitted to a Java ThreadPool using submit are not printed, how execute shows them, and presents three practical approaches—try‑catch within the task, a custom Thread.setDefaultUncaughtExceptionHandler, and overriding afterExecute—to reliably obtain and handle those exceptions.
This article explains Kafka as a distributed publish/subscribe messaging system, detailing its core functions, architecture, advantages, deployment methods, common use cases, and provides Java consumer and producer code examples for real‑time data processing.
This article explains how Spring Data REST automatically exposes Spring Data repositories as RESTful endpoints, covering setup, entity and repository definitions, exposure strategies, custom base paths, CRUD operations, field projection, event handling, and visual tools for Spring Boot 3.0.5 with JDK 17.
This article walks through a real‑world scenario of adding symmetric encryption to Spring MVC endpoints for Android, iOS and H5 clients, detailing the requirements, code implementation of request and response interceptors, serialization pitfalls with enums and LocalDateTime, and the final solution using Jackson's ObjectMapper to keep encrypted and non‑encrypted responses consistent.
This article provides a comprehensive analysis of Spring's @Autowired annotation, covering its usage, the bean lifecycle stages where it operates, the core classes and methods that implement it, and a comparison with other injection annotations such as @Resource, all illustrated with runnable code examples.
This comprehensive guide walks you through the most useful Spring framework utility classes—including Assert, StringUtils, CollectionUtils, ObjectUtils, ClassUtils, BeanUtils, ReflectionUtils, Base64Utils, SerializationUtils, HttpStatus, and HtmlUtils—showing practical code examples and explaining when and how to use each to streamline Java backend development.
Storing IPv4 addresses as a 32‑bit UNSIGNED INT instead of VARCHAR saves storage space, reduces index size, enables faster range queries, and leverages MySQL’s built‑in INET_ATON/INET_NTOA functions, while the trade‑offs include reduced readability and the need for conversion code, as demonstrated with benchmarks and Java examples.
This article explains how to implement dynamic loading, upgrading, and unloading of data‑governance tasks in a Java Spring application using a custom URLClassLoader, integrate the tasks with the XXL‑Job scheduler, manage Spring bean registration, and persist configuration changes via local YAML or Nacos.
New Relic’s 2023 State of the Java Ecosystem report reveals a 430% surge in Java 17 adoption, declining use of older LTS releases, Amazon Corretto overtaking Oracle as the leading JDK provider, and a dominant shift toward containerized Java workloads, while the article also promotes a ChatGPT community and related services.
This article explains why containerizing Java applications with Docker is beneficial, outlines the steps to create a Dockerfile, build and run the image, and demonstrates using Docker Compose (and briefly Kubernetes) to manage a Spring Boot service, providing full code examples.
This article explains Java's parent delegation mechanism—a core part of the JVM class‑loading process—detailing its purpose, three main benefits (avoiding duplicate loading, ensuring security, improving efficiency), and the step‑by‑step loading workflow illustrated with diagrams.
This article introduces LiteFlow, a lightweight Java workflow engine, explains its core features, demonstrates rule syntax for serial, parallel, switch, and conditional orchestration, and provides step‑by‑step integration examples—including Maven dependencies, configuration, component implementation, and controller usage—to simplify complex business processes.
This article walks through the classic interview problem of merging two non‑decreasing integer arrays directly into the first array, compares a naïve extra‑array solution with an optimal in‑place two‑pointer algorithm, and provides full Java implementations.
This article provides an in‑depth tutorial on Spring Validation, covering simple usage, requestBody and requestParam/PathVariable validation, unified exception handling, advanced techniques such as group, nested, collection and custom validation, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms within Spring MVC and Hibernate Validator.
This article introduces ten powerful online utilities—including a Java Spring Initializr, code generators, JSON formatters, cron expression builders, regex testers, nginx formatters, and visual data tools—that streamline backend and frontend development workflows and dramatically improve productivity.
This tutorial explains how to use Spring Retry in a SpringBoot 2.7 application, covering both annotation‑based @Retryable usage and programmatic RetryTemplate configuration, with complete code examples, listener implementation, and execution results.
This article demonstrates how to apply the Strategy pattern combined with a simple factory in a Spring Boot application, showing interface definition, multiple arithmetic strategy implementations, a factory that registers beans, a service invoking strategies via a map, and a REST controller for testing, highlighting extensibility.
This article explores the evolution of business operation logging in a Java backend, starting from a simple AOP‑annotation approach, advancing to AOP combined with Spring Expression Language for richer context, and finally leveraging MySQL binlog with time‑window processing to achieve comprehensive, low‑intrusion audit trails.
This article demonstrates how to create a custom insertable annotation processor in Java to automatically inject the jar version into component constants at compile time, eliminating manual updates and enabling Prometheus monitoring of library usage across versions.
This article walks through a step‑by‑step interview scenario where a candidate solves the classic Two Sum problem, starting with a naïve nested‑loop approach, then improving it using a hash‑map to achieve linear time complexity, and discusses edge cases and code refinements.
This article details how to dramatically speed up the import of massive Excel files (over 100,000 rows) into a Java backend by switching to EasyExcel, caching database lookups, using batch VALUES inserts, and parallelizing the write operations with functional utilities.
This article explains the concept of AVL self‑balancing binary search trees, outlines their height‑balancing property, and provides step‑by‑step Java code examples defining a Node class implementing Comparable and an AVLTree class with height, balance factor calculations, and rotation methods for insertion and deletion.
This article explains the concept of idempotency, identifies which API requests are naturally idempotent, discusses why idempotency is essential for retries, asynchronous callbacks, and message queues, and provides a step‑by‑step Java Spring implementation using custom annotations, AOP, and Redis for token management.
This article provides a step‑by‑step guide on integrating the lightweight distributed task scheduler XXL‑JOB into a SpringBoot application, covering prerequisite installations, Maven dependency configuration, property settings, JobHandler implementation, and registration to enable scalable and reliable job execution.
Aspect-Oriented Programming (AOP) separates cross‑cutting concerns such as logging, transactions, and security from core business logic, improving modularity, maintainability, and reusability, and the article explains its concepts, benefits, implementation methods (dynamic/static proxies, dedicated languages) and provides a Spring AOP code example.
This article explains how to design a plug‑in style architecture for data‑governance tasks by creating a custom URLClassLoader, dynamically loading JARs into a Spring context, registering and deregistering XXL‑Job handlers, updating configuration via YAML or Nacos, and finally unloading resources without restarting the service.
This article explains the problems of traditional session management in multi‑service environments, introduces session replication and centralized storage (using Redis), and demonstrates a complete CAS‑based single sign‑on solution with Java code examples for user, controller, filter, and configuration components.
This article demonstrates how to create a dynamically configurable thread pool in a Spring Boot backend by using Nacos as a configuration center, covering Maven dependencies, YAML configuration files, Nacos data IDs, Java implementation with listeners, a REST controller for testing, and practical verification steps.
This article walks through the practical application of Domain‑Driven Design to a large‑scale pricing system, detailing business understanding, strategic and tactical design, context integration, layered architecture, and concrete Java implementations that illustrate how DDD improves modularity, testability, and maintainability.
This guide demonstrates how to set up a Maven project with the Fabric8 Kubernetes Java client, configure minimal kubeconfig or ServiceAccount credentials, and use sample code to list namespaces, illustrating essential steps for connecting Java applications to a Kubernetes cluster with minimal configuration.
This article introduces Easy-Es, an ORM framework built on Elasticsearch's RestHighLevelClient, explains its architecture and advantages, and provides step‑by‑step instructions—including Maven/Gradle setup, configuration, entity and mapper creation, and full CRUD test examples—so developers can quickly integrate powerful search capabilities into Spring Boot applications.
This article examines why API requests fail, explains the importance of retry mechanisms, compares linear, exponential and randomized back‑off strategies, discusses maximum attempt considerations and idempotency, and provides a detailed Spring Boot implementation using Spring Retry along with alternative approaches.
This guide walks through setting up a Spring Boot project, adding Tess4J dependencies, configuring language data, implementing an OCR service class, exposing REST endpoints for local and remote image recognition, and testing the OCR functionality end‑to‑end.
This guide explains how Spring Security configuration changed after version 5.7, covering the shift from WebSecurityConfigurerAdapter to SecurityFilterChain beans, multiple filter chain setup, in‑memory user definitions, custom authorization decisions, and shared authentication components, with full code examples.
This article demonstrates how to build a hot‑pluggable AOP solution in Spring by dynamically adding and removing Advice at runtime, covering the required concepts, core implementation code, a complete demo, and practical considerations for backend Java developers.
Spring Boot, emerging as the preferred Java framework for microservices, differs from traditional Spring by offering automatic configuration, simplified Maven setup, embedded containers, production-ready features, and streamlined Spring MVC, which together accelerate development, ease deployment, and improve cloud integration compared to the more complex, slower-starting classic Spring.
Bloom filters are space‑efficient probabilistic structures that test set membership using multiple hash functions, offering fast, low‑memory checks with a controllable false‑positive rate, and can be implemented manually in Java, via Guava’s library, or deployed at scale with RedisBloom for distributed applications.
The article shows how to build a reliable Redis‑based distributed lock in a Spring Boot 2.7 application by storing a unique UUID token, acquiring the lock with SET NX PX, releasing it atomically via a Lua script, and providing a clean Lock interface, factory component, and JUnit example.
This article explains how to build a clean and maintainable Spring Boot controller layer by separating responsibilities, unifying response structures, applying comprehensive parameter validation (including custom rules), and implementing centralized exception handling to keep business logic concise and robust.
This article introduces Java 8 functional interfaces—including Function, Supplier, Consumer, and Runnable—explains their signatures, demonstrates how they can replace traditional if‑else statements for exception handling, branch processing, and null checks, and provides concrete code examples and usage tips.
This article explains how the LiteFlow rule engine can be used to design and execute serial, parallel, switch, and conditional business flows by defining components, EL rule files, data contexts, and configuration settings, and demonstrates its application with an e‑commerce order‑processing example.
This article explains the core concepts of Spring's @Autowired dependency injection, illustrates common mistakes such as unresolved circular dependencies and bean name collisions, and provides detailed solutions including constructor injection, qualifier usage, and bean priority annotations.
This article introduces the most useful Spring framework utility classes—including Assert, StringUtils, CollectionUtils, ObjectUtils, ClassUtils, BeanUtils, ReflectionUtils, Base64Utils, SerializationUtils, HttpStatus, and HtmlUtils—providing clear explanations, code examples, and practical tips to improve development efficiency and code quality.
This article explains how to implement multi‑rule rate limiting in a distributed Java application using Redis, covering String‑based counters, Zset timestamp storage, Lua scripts for atomic checks, custom @RateLimiter annotations, key generation logic, and an AOP interceptor that enforces the limits.
This article explains Java 8's lambda expressions and functional interfaces, demonstrates common functional interfaces with code examples, and shows how to use Stream API operations such as filter, map, flatMap, collect, max/min, count, reduce, and advanced collectors for efficient backend development.
This article explains how to use a MyBatis interceptor to cheaply improve database stability for high‑growth tables, compares common archiving and sharding solutions, and provides a complete, code‑driven implementation of date‑based horizontal sharding with binlog‑driven double‑write to handle critical‑point data continuity.
This article explains how to implement a robust distributed retry mechanism using message queues, annotations, and AOP, providing configurable options, visual monitoring, and code examples to help developers achieve eventual consistency with minimal boilerplate.
This article demonstrates how to implement small file uploads, large file chunked uploads, breakpoint resume, and instant upload using Spring Boot 3.1.2 on the backend and native JavaScript with spark‑md5 on the frontend, covering configuration, code examples, and practical considerations.
This guide explains how to import, configure, and apply the CheckStyle plugin in IntelliJ IDEA, covering common annotation, formatting, naming, logical, and import‑order issues, and provides step‑by‑step screenshots to help Java developers enforce coding standards efficiently.
This article explains the main Java JVM garbage collectors—including Serial, Parallel, CMS, G1, ZGC, Epsilon, and Shenandoah—detailing their architectures, pause characteristics, suitable workloads, and key advantages, helping developers choose the right collector for different application sizes and latency requirements.
This article explains why and how to replace OpenFeign with native Spring HttpInterface alternatives such as Apache HttpClient, OkHttp, and RestTemplate, covering security motivations, configuration details, code examples, and practical recommendations for microservice remote calls.
This article explains how to create a Spring Boot fat‑jar that externalizes its dependencies by configuring the spring‑boot‑maven‑plugin and maven‑assembly‑plugin to produce a ZIP layout, then uses the PropertiesLauncher with loader.path to load libraries from a separate libs directory at runtime.
This article explains how upgrading Java and Groovy dependencies caused an IllegalAccessException in Caffeine's asynchronous cache due to module encapsulation, and details the attempted fixes including JVM '--add-opens' arguments and dependency version adjustments.
This article explains how to protect Java server-side code from decompilation by applying ProGuard shrinking/obfuscation and Xjar/ClassFinal encryption, provides detailed Maven plugin configurations, sample pom.xml snippets, command‑line launch options, and demonstrates the resulting protected JARs with screenshots.
This article explains multiple backend optimization methods for Spring Boot, including asynchronous execution with @Async and CompletableFuture, increasing embedded Tomcat connection limits, using @ComponentScan, switching to Undertow, applying BufferedWriter, employing DeferredResult, and intercepting async calls with AsyncHandlerInterceptor, accompanied by concrete code examples.
This article explains Spring WebFlux's reactive programming model, compares it with Spring MVC, describes its concurrency advantages, and provides complete code examples for building a reactive Spring Boot application, helping developers decide when to adopt WebFlux.
This article explains the Nacos architecture, the principles of service registration, how Spring Cloud integrates with Nacos for automatic registration, the implementation details of NacosServiceRegistry, heartbeat mechanisms, registration via Open API/SDK, service address querying, and dynamic service discovery using HostReactor.
This article explains how to protect Java applications from decompilation by configuring a ProGuard file and adding the ProGuard Maven plugin, then building the project to generate an obfuscated JAR, complete with step‑by‑step instructions and sample configuration code.
This article explains how to control Spring bean initialization and destruction using interfaces and annotations, inject prototype beans into singleton controllers, implement various BeanPostProcessor extensions, dynamically register beans, use @Import, Runner interfaces, global exception handling, custom type conversion, BeanFactoryAware, web interceptors, and default AOP proxy creation.
This article explains why request debounce is essential for preventing duplicate submissions, outlines which APIs need protection, and walks through two distributed‑lock solutions—shared Redis cache and Redisson—showing concrete annotations, key‑generation logic, and Spring‑AOP code with full test results.
This article demonstrates how to implement API request throttling in a Spring Boot application using a custom Interceptor and Redis, covering basic principles, configuration, custom annotations, reflection for per‑endpoint limits, handling path parameters, and addressing timing logic nuances.
The author recounts a two‑year journey as a Java developer, describing experiences across three companies, the challenges of CRUD‑focused work, the need to learn front‑end skills, and insights on balancing technical growth with business understanding in both large and small firms.
This article introduces Easy-Es, an Elasticsearch ORM that mimics MyBatis‑Plus syntax, explains its key features, shows how to integrate it into a Spring Boot project, and provides comprehensive code examples for index management, CRUD, simple and advanced product searches, recommendation and aggregation functionalities.
This article explains why a naïve sequential export of hundreds of gigabytes of images from a database can take many hours, and demonstrates how adding indexes, using asynchronous processing, multithreading, and eliminating unnecessary decryption and local storage can reduce the runtime to minutes.
This article examines common scenarios that cause Spring transaction management to fail—such as non‑public methods, swallowed exceptions, incorrect rollback settings, self‑invocation, final methods, wrong propagation, asynchronous threads, unsupported database engines, and misuse of @Transactional—and provides concrete code‑level solutions to ensure reliable transactional behavior.
This tutorial demonstrates how to automate CRUD functionality in a Spring Boot application by introducing MyBatisPlus, creating a reusable utility class, configuring pagination, and implementing a generic BaseController that can be extended by concrete controllers for any entity.
This article demonstrates how to build a Spring‑based API rate‑limiting solution using an Interceptor and Redis, covering the basic principle, project setup, code implementation, custom annotation with reflection for flexible limits, handling path‑parameter keys, real‑IP acquisition, and practical considerations for production use.
This article explains the differences between CPU‑intensive and I/O‑intensive workloads, provides optimization strategies such as multithreading, caching, and load balancing, and presents Java code examples and formulas for calculating the optimal thread‑pool size based on core count, target CPU utilization, and blocking factors.
This article provides a comprehensive analysis of SpringBoot's run method, explaining its overall flow, the creation of SpringApplication objects, argument parsing, environment preparation, context refresh, and key extension points, while offering code examples to help developers understand the startup process.
This article explains how to implement a hot‑pluggable AOP mechanism in Spring by dynamically adding or removing Advice through custom endpoints and event listeners, covering core concepts, implementation code, a demonstration, and best‑practice considerations for backend developers.
