This article explains how to design a multi‑level workflow approval system using the Activiti engine, covering process diagram creation, deployment, task handling, variable management, exclusive gateways, and complete project configuration with Spring Boot and an H2 database.
This article explains how to dynamically load JAR files in a Spring Boot application, covering core concepts, benefits, usage of SpringBootClassLoader, creation of JARs, and alternative third‑party OSGi‑resource‑locator approaches with full code examples.
This article walks through four advanced Spring Boot Starter design patterns—Customizer, Enable/ConditionalOnProperty, SPI file migration, and AOP interception—showing concrete code examples, the reasoning behind each approach, and practical tips for learning and applying these techniques.
The article explains how to protect Spring Boot applications from XSS attacks by using custom annotations such as @XSS with an XssValidator and by implementing a request‑filter chain—including XssFilter and XssWrapper—to sanitize input, demonstrating through tests that both approaches reliably secure user data.
Learn how to create and register custom type converters for Spring Boot @ConfigurationProperties, enabling seamless binding of complex objects from property files using @ConfigurationPropertiesBinding and BeanFactoryPostProcessor techniques, including code examples, configuration snippets, and two registration approaches for practical implementation.
This article details a step‑by‑step investigation of a Spring Boot application that consumed far more physical memory than its 4 GB heap limit, revealing a native‑memory leak caused by MCC's package‑scanning using Reflections and the Spring Boot ZipInflaterInputStream, and explains how configuration changes and newer Spring Boot versions resolve the issue.
This article compiles practical advice for Java developers feeling out‑of‑practice, covering migration to JDK 21, Spring Boot 3.2 observability, new language features, community resources, and strategies to boost confidence and stay current with the evolving Java ecosystem.
This article walks through a Java Spring‑Boot implementation of a contract‑signing workflow, explains the original chain‑of‑responsibility design, shows its limitations, and demonstrates how to replace manual bean wiring with a strategy‑based annotation and enum configuration for flexible node management.
This article analyses thirteen common mistakes that cause Spring's @Transactional annotation to be ineffective or not roll back, covering unnecessary usage, private/final/static methods, self‑invocation, wrong propagation settings, async threads, unmanaged beans, exception handling and more, with concrete code demos and solutions.
This article builds a simple Spring Boot Greetings API, configures Maven profiles for Tomcat, Jetty, and Undertow, creates Docker images for each, runs load‑testing benchmarks across multiple concurrency levels, and analyzes startup time, CPU, memory, and response performance to determine the optimal embedded server.
This article explains the JSONP technique, demonstrates how to implement it in Spring Boot with a simple REST endpoint, custom JSONP wrapper, ResponseBodyAdvice, and a customized HttpMessageConverter, and shows how to test the solution using HTML script tags.
This article explains how to use the Activiti workflow engine to design a multi‑level leave‑approval process, covering BPMN diagram creation, Spring Boot configuration, deployment, Java code for starting instances, task handling, database schema, API overview, and tips for extending the workflow without additional code.
Learn how to simplify repetitive error-handling code in Spring Boot by creating a custom @ErrorHandler annotation that leverages Spring AOP to automatically log exceptions, with step-by-step instructions, required dependencies, annotation definition, aspect implementation, and usage examples.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts OSS object‑storage services via the Amazon S3 protocol, covering project setup, Maven dependencies, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
This tutorial explains how to implement API rate limiting in Spring Boot using the Bucket4j library, covering token‑bucket theory, Maven dependencies, Redis configuration, YAML rules, annotation‑based limits, custom responses, and conditional bypasses with complete code examples.
This article explains how to use SLF4J as a facade for Logback or Log4j2, shows Maven dependencies, demonstrates logback.xml and logback‑spring.xml configurations, covers Spring Boot's default logging setup, custom log levels, profile‑based settings, and how to switch to Log4j2 for higher performance.
Graceful Response is a Spring Boot component that offers one‑stop unified response packaging, global exception handling, and custom error code support, enabling developers to simplify controller code, reduce boilerplate, and improve readability and efficiency.
This article explores eight practical strategies for injecting prototype‑scoped beans into singleton‑scoped beans in Spring Boot, detailing each method's implementation, advantages, and drawbacks, and provides code examples to help developers choose the most suitable approach.
This article provides a comprehensive guide on integrating Spring Boot with the open‑source distributed scheduler XXL‑Job, covering installation, configuration of the admin console and executor, code examples, parameter details, comparison with other schedulers, and best practices for reliable task management.
Lock4j is a Java distributed lock library supporting Spring AOP, RedisTemplate, Redisson, and Zookeeper, offering simple usage, configurable properties, annotation-driven locking, custom executors, key generators, and failure strategies, with detailed setup, code examples, and advanced customization instructions.
This guide walks through eight Spring Boot property injection techniques—including @Value placeholders, SpEL expressions, @ConfigurationProperties, custom @PropertySource, YAML factories, Environment access, custom annotations, programmatic loading, and command‑line arguments—showing code examples and expected outputs for each method.
This article explains how to integrate JSON Schema validation into a Spring Boot application, covering dependency setup, schema definition, bean configuration, service implementation, controller exposure, and testing with curl to ensure JSON payloads conform to the defined rules.
This article explains why API debounce is essential, identifies the types of endpoints that need it, and provides two distributed solutions—shared Redis cache and Redisson lock—along with complete Java code examples and deployment tips for preventing duplicate submissions in a Spring Boot backend.
The article explains Java's virtual threads introduced in Java 19, compares them with traditional threads, and demonstrates how to configure Spring Boot to use virtual threads, including code samples and performance benchmarks that show dramatic latency reductions in both async services and HTTP requests.
This guide walks you through why Java remains vital, explains what Spring Boot is, outlines its core features, and provides a detailed learning roadmap covering Java fundamentals, Spring core concepts, web development, AOP, microservices, databases, security, DevOps tools, and deployment strategies for building robust enterprise applications.
The article compares messy Spring MVC controllers packed with try‑catch, field checks, and business logic to concise, well‑structured versions that use @Valid, service delegation, and global exception handling, and provides a step‑by‑step refactoring guide.
This tutorial explores Jackson's rich annotation set in Spring Boot 3.2.5, demonstrating how to serialize and deserialize JSON with built‑in annotations like @JsonAnyGetter, @JsonGetter, @JsonPropertyOrder, and @JsonIgnore, how to create custom annotations, and how to disable annotation processing for fine‑grained control.
This article explains the four common Redis cache pitfalls—cache penetration, avalanche, breakdown, and data inconsistency—demonstrates how they can crash high‑traffic systems, and provides practical Java/Spring Boot solutions such as empty‑object caching, Bloom filters, distributed locks, and delayed double‑delete strategies.
This article introduces the high‑performance Caffeine caching library for Spring Boot 3.2, explains its core features, demonstrates detailed performance benchmarks, and provides practical code examples covering synchronous and asynchronous operations, eviction policies, removal listeners, refresh mechanisms, and statistics collection.
This article walks through the complete process of creating a Spring Boot Starter that wraps the GrowingIO Java SDK, covering the motivation, project setup, property abstraction, auto‑configuration, custom logging, service implementation, and a simple test to verify the starter works in a Spring Boot application.
Learn how to elegantly process Java 8 date parameters, register custom converters, conditionally enable controllers, apply unified API prefixes, perform service‑layer validation, and control asynchronous request timeouts in Spring Boot 3.2.5 using annotations, configuration files, and programmatic WebMvcConfigurer techniques.
This guide explains why upgrading from Spring Boot 1.5 to 2.1 is essential for MongoDB transaction management, outlines version requirements, highlights key feature changes, and provides step‑by‑step instructions with code examples to enable reliable transactional operations in a Spring‑based backend.
This guide demonstrates how to integrate the open‑source kkFileView library into a Spring Boot 3.2.5 project to provide online preview for dozens of file formats—including Office documents, PDFs, images, 3D models, and media—by configuring a local resource handler, running the kkFileView server, and using base64‑encoded URLs.
This article explains a bug in Spring 6.1.11 where adding a servlet path prefix causes functional routing to throw an UnsupportedOperationException, demonstrates the issue with code and screenshots, and provides work‑arounds and the permanent fix introduced in Spring 6.1.12.
This guide shows how to implement end‑to‑end trace ID propagation across Spring Cloud gateways, downstream services, and asynchronous threads using a custom GlobalTraceFilter, a patched LogbackMDCAdapter with Alibaba TransmittableThreadLocal, and minimal configuration, avoiding heavyweight tracing libraries.
This article examines common pitfalls in Spring Boot controller design, showcases messy examples, then demonstrates cleaner implementations using @Valid for parameter validation, streamlined exception handling, and best‑practice refactoring to produce more maintainable backend code.
In Spring Boot you can customize JSON request and response handling by annotating fields with @JsonSerialize/@JsonDeserialize, registering a global ObjectMapper module, adding a PropertyEditor via @ControllerAdvice, creating a custom HttpMessageConverter, or using AOP interception, selecting the approach that matches your project’s complexity.
This article explains how the LiteFlow rule engine enables Java developers to define, configure, and execute complex serial and parallel business workflows using XML/JSON/YAML rule files, various node components, data contexts, and runtime parameters, with hot‑deployment and integration examples for Spring Boot projects.
This article demonstrates how to transform overly complex Spring Boot controllers—filled with try‑catch blocks, validation logic, and business code—into elegant, concise implementations by applying @Valid, separating concerns, and using global exception handling, illustrated with side‑by‑side code comparisons and practical tips for cleaner backend development.
This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their execution flow, configuration of thread pools, and scenarios where async processing improves throughput.
This article documents a production incident where multiple Spring Boot services each consumed around 12 GB of memory, explains how to diagnose the issue using jps and jmap, details default JVM heap size calculations, and provides recommendations for configuring JVM parameters to prevent excessive memory usage.
The article demonstrates how to mask sensitive Java backend data by using Hutool's DesensitizedUtil for common types and a custom @Desensitization annotation with a DesensitizationTypeEnum‑driven Jackson serializer (or Fastjson ValueFilter) to apply flexible masking rules during JSON serialization.
This tutorial shows how to instrument Spring Boot APIs using Actuator, a custom @Monitor annotation with AOP, and Prometheus to collect and visualize method execution times, providing a complete end‑to‑end monitoring solution.
Spring AI has added full support for OpenAI's structured output feature, enabling developers to define JSON schemas for AI responses, with example code showing how to configure prompts, response formats, and BeanOutputConverter for seamless JSON-to-Java bean conversion, plus Spring Boot starter configuration.
After a year of business coding, the author details the design, implementation, and migration strategy for splitting loan and repayment tables into 50 sharded tables using ShardingSphere with Spring Boot, covering schema design, data synchronization, dynamic switches, and practical pitfalls.
RabbitMQ is a lightweight, open‑source AMQP broker offering reliable, flexible routing, clustering, and multi‑protocol support; it can be installed via Homebrew, Windows installers, or source on CentOS, and, using the rabbitmq_delayed_message_exchange plugin, Spring Boot applications can configure custom exchanges, queues, and send delayed messages with an x‑delay header.
This guide shows how to enable detailed request/response logging, measure controller execution time, and customize 404 error responses in Spring Boot 3.2.5, providing practical code snippets and configuration tips for effective backend debugging and monitoring.
This guide explains how to use Spring Web MVC's WebMvc.fn functional model—including HandlerFunction, RouterFunction, ServerRequest, ServerResponse, predicates, nested routes, and filters—to build clean, immutable, and reactive APIs in Spring Boot 2.7.
This article demonstrates how to transform overly complex Spring Boot controllers—filled with repetitive validation, try‑catch blocks, and business logic—into clean, maintainable implementations by applying @Valid annotations, streamlined validation, and a centralized global exception handler.
This article explains how Spring Boot’s @Value annotation injects configuration values, covers basic usage, default values, nested properties, SpEL expressions, custom type converters, placeholder handling, custom meta‑annotations, and combining property placeholders for dynamic URLs, providing complete code examples.
This guide explains how to integrate JSON Schema validation into a Spring Boot application, covering dependency setup, schema definition, bean configuration, service implementation, controller handling, and testing with curl examples to ensure JSON payloads conform to the defined rules.
This article explains how to process multipart requests that combine JSON data, XML, and file uploads in Spring Boot using @RequestPart, covering backend controller setup, parameter validation, and the corresponding frontend FormData construction with code examples.
Spring Boot can emulate SPI plug‑in extensions by using native Java ServiceLoader, conditional bean registration with @ConditionalOnClass/@ConditionalOnProperty, custom FactoryBean implementations, or programmatic BeanDefinitionRegistryPostProcessor registration, each enabling dynamic service loading based on configuration or runtime conditions.
This article introduces Lock4j, a Java distributed lock library supporting RedisTemplate, Redisson, and Zookeeper, walks through its key features, dependency setup, configuration, annotation attributes, simple and advanced usage examples, and demonstrates custom executors, key builders, and failure strategies for robust concurrency control.
This article explains how to design a unified JSON response format for backend services, define clear status‑code conventions, encapsulate results in a Result class, and use a custom @ResponseResult annotation together with a ResponseBodyAdvice interceptor to automatically wrap controller outputs, improving readability and error handling.
This article explains the role of Controllers in Spring Boot, identifies common pitfalls such as duplicated validation and inconsistent responses, and demonstrates how to refactor them using a unified response structure, ResponseBodyAdvice, proper message converter ordering, JSR‑303 validation, custom validators, and centralized exception handling.
This article walks through the author's practical research on integrating WebSocket in Spring Boot, detailing step‑by‑step configurations for Javax, WebMVC, and WebFlux, comparing their APIs, highlighting pitfalls, and providing concrete code snippets and cold‑knowledge tips for both server and client implementations.
Learn how to dynamically manage Spring Boot 3.2.5 scheduled tasks by creating a custom @Task annotation, recording task metadata, extending ThreadPoolTaskScheduler to track and control tasks, and implementing start/stop APIs, complete with code examples and practical testing.
This guide walks through Spring Boot 3.2.5 troubleshooting with ConditionEvaluationReport, customizing the application context and environment via listeners and EnvironmentPostProcessor, building parent‑child containers, managing embedded Tomcat MBeans, returning XML responses, customizing the whitelabel error page, and adding multiple Tomcat connectors, all illustrated with code snippets and images.
This article outlines essential backend design principles such as single responsibility, high cohesion, low coupling, reusability, clear boundaries, moderate modularity, layered architecture, dependency inversion, testability and future adaptability, and demonstrates their application in a multi‑module Spring Boot project with detailed Maven configurations.
This article introduces Caffeine Cache, explains its W‑TinyLFU algorithm advantages over traditional FIFO, LRU, and LFU strategies, demonstrates manual, synchronous, and asynchronous loading methods, covers eviction policies, statistics, Spring Boot integration, and provides detailed configuration and code examples for Java developers.
This tutorial demonstrates how to integrate OpenHtmlToPdf with a Spring Boot 3.2.8 application, using Freemarker templates and custom fonts to render HTML content and deliver high‑quality PDF files via a REST endpoint, complete with code examples and configuration details.
This article demonstrates how to quickly build and benchmark a Spring Boot 2.x application as a native binary, compares its startup time, memory usage, and request throughput with equivalent implementations in Go and Rust, and concludes that AOT‑processed Java offers impressive performance despite longer compilation times.
This guide explains how to switch the embedded web server in Spring Boot 3.2.5, disable it, customize ports (including random and range ports), enable HTTP compression, configure SSL and HTTP/2, add servlets, filters, listeners, set up logging, and fine‑tune Tomcat and Undertow settings, all with practical code examples.
This article provides a comprehensive analysis of Spring Security 6's architecture, explaining how the framework uses a chain of servlet Filters, the DelegatingFilterProxy, and the SecurityFilterChain to implement authentication, authorization, and protection against common attacks, while also offering practical debugging tips and configuration guidance.
This tutorial explains how to configure, test, and dynamically modify the concurrency of RabbitMQ listeners in a Spring Boot application, covering dependency setup, YAML configuration, code examples, runtime adjustments, and best‑practice recommendations for optimal message processing.
This article explains the key changes in Spring Boot 3, outlines the new OAuth2 components, and provides a detailed design for secure microservice authentication and authorization using Spring Authorization Server, JWT, API Gateway, and client applications, complete with architecture diagrams and implementation steps.
This article demonstrates how to boost the insertion speed of over two million records by using Spring Boot with MyBatis‑Plus, a ThreadPoolTaskExecutor for multithreaded batch inserts, and detailed performance testing that shows a reduction from 5.75 minutes to 1.67 minutes.
This tutorial explains the STOMP protocol, its frame structure, and how Spring Boot 3 integrates STOMP over WebSocket, providing step‑by‑step code examples for enabling STOMP, sending and receiving messages, handling headers, asynchronous processing, exception handling, and simple publish‑subscribe without a controller.
This article explains the background, features, installation steps, core concepts, library definitions, rule set creation (wizard and script), decision tables, practical usage scenarios, and provides complete Java and configuration code examples for integrating the URule rule engine in a Spring Boot backend application.
This article provides a comprehensive guide to installing MinIO on CentOS 7, configuring it with Docker, integrating it into a Spring Boot application, and implementing file upload, download, and multipart upload features using MinIO's Java SDK, along with troubleshooting tips and code examples.
This article explores why a custom Advisor aspect may not work in Spring Boot 3.2, demonstrates how enabling @EnableAspectJAutoProxy and adjusting bean roles resolves the issue, and also covers advanced topics such as FactoryBean type conversion, version retrieval, SpringProperties, and the Spring SPI mechanism.
MapStruct is a powerful Java annotation‑based mapper that outperforms BeanUtils by generating compile‑time mapping implementations without reflection, supporting simple, nested, collection, and custom mappings, dependency injection, constants, expressions, and error handling, making object‑DTO conversions efficient and maintainable in Spring Boot projects.
This guide walks you through powerful Spring Boot 3 features—including the @Delimiter annotation for automatic collection parsing, custom type converters for @Value, loading YAML files via a FactoryBean, a suite of ordered filters, and using DeferredImportSelector for conditional configuration imports.
This article introduces MyBatis-Mate, an official MyBatis‑Plus extension offering enterprise‑level capabilities such as dictionary binding, field encryption, data masking, dynamic DDL maintenance, sharding, multi‑datasource switching, performance logging, and data permission control, with detailed Spring Boot integration examples.
This article explains how Spring Boot 3.2 can be accelerated with Class Data Sharing, virtual threads, GraalVM native images, ProblemDetail error handling, and new observability features, providing practical commands and code examples for faster startup, lower memory usage, and richer monitoring.
This article provides a step‑by‑step guide on combining Spring Boot with the open‑source XXL‑Job platform, covering its features, comparison with other schedulers, configuration of the admin console and executor, code examples, @XxlJob annotation parameters, and best practices for reliable distributed task management.
This article explains how to design a unified API response format in Spring Boot, defining a JSON result structure with code, message, and data, organizing status codes, using @ResponseResult annotation, implementing interceptors and ResponseBodyAdvice to automatically wrap controller outputs, and offers optimization tips for clean backend development.
This tutorial explains how to create a global response wrapper in Spring Boot 3.2.5 using ResponseBodyAdvice, covering the pros and cons of controller‑level wrapping, custom annotations, code examples, handling of String responses, and testing the unified output with sample requests.
This article explains the concept of plugin‑based development, outlines its benefits such as modular decoupling and extensibility, and provides detailed Java implementations using ServiceLoader, custom configuration loading, and Spring Boot’s spring.factories mechanism with complete code examples and practical deployment steps.
This tutorial walks through Spring Boot configuration techniques—including property classes, environment variable binding, validation, @Value usage, random ports, AOP proxy settings, lazy initialization, and handling circular dependencies—providing practical code examples for each feature.
Learn how to enable comprehensive observability in Spring Boot 3.2.5 by leveraging Micrometer’s @Timed, @Counted, and @MeterTag annotations, configuring Actuator endpoints, and customizing aspects to monitor method execution time, request counts, and parameters, complete with practical code examples and Prometheus integration.
This article explains the drawbacks of using Spring Boot's @Value for configuration injection, demonstrates how @ConfigurationProperties provides a cleaner, maintainable alternative, and shows how to add validation with @Validated and standard bean validation annotations.
This article demonstrates how to implement a high‑performance file upload system using Vue's Element Plus component on the frontend and Spring Boot on the backend, comparing single‑row inserts, batch inserts, and a multithreaded producer‑consumer approach to dramatically reduce MySQL insertion time.
This tutorial walks you through using the Lock4j distributed lock component in Spring Boot 3.2.5, covering its features, Maven dependencies, configuration, basic annotation usage, custom key generation, expiration settings, and advanced options like custom executors, key builders, failure strategies, and manual lock handling.
This article introduces Lock4j, a versatile Java distributed‑lock component supporting RedisTemplate, Redisson and Zookeeper, explains its key features, shows how to add dependencies and configure Redis, details the @Lock4j annotation attributes, provides simple and advanced usage examples with code snippets, and demonstrates custom executors, key builders, failure strategies, and manual lock handling.
This guide walks through configuring Spring Boot Actuator to expose health, environment, and custom application information, covering dependency setup, endpoint exposure, health grouping, multi‑datasource monitoring, and custom InfoContributor implementation for comprehensive runtime insight.
This article provides a comprehensive tutorial on MinIO, covering its features, application scenarios, Docker installation on CentOS 7, firewall configuration, Spring Boot integration, chunked upload implementation, and testing, complete with code examples and troubleshooting tips.
Explore three Spring AOP implementation methods—dynamic proxy, Java Agent, and AspectJ Maven plugin—by setting up a sample Service, defining aspects, configuring aop.xml and JVM arguments, and comparing their flexibility, performance impact, and compile‑time weaving within a Spring Boot 2.7 environment.
This tutorial demonstrates how to set up a simple MySQL database, create a Spring Boot project, add Mybatis-Plus dependencies, install the MybatisX plugin, configure the connection, generate entity, mapper, service, and controller code, and verify the integration with a sample REST endpoint.
This article explains how to design a clean Controller layer in Spring Boot, introduces a unified response format with Result and ResponseBodyAdvice, demonstrates parameter validation using JSR‑303 and Spring Validation, and shows custom validation annotations and global exception handling to keep controller code concise and maintainable.
This article explains what a service gateway is, why it is needed in microservice systems, and provides practical technology choices such as Java, Spring Boot, Netflix Zuul, Consul, JWT, Prometheus, and ELK to implement routing, filtering, security, monitoring, and logging.
This article demonstrates how to transform overly complex Spring Boot controllers—filled with repetitive try‑catch blocks and manual field checks—into clean, maintainable code by applying @Valid validation, reducing boilerplate, and implementing a centralized exception‑handling strategy.
This guide provides a comprehensive walkthrough of installing OpenCV, using its Java API for image and video face detection, implementing face comparison, creating custom GUI windows, and integrating the library into a Spring Boot application with detailed code examples and common troubleshooting tips.
This article walks through setting up MinIO, installing it via Docker on CentOS 7, configuring Spring Boot, and implementing chunked, instant‑resume, and resumable uploads for large files, complete with code examples, Docker commands, and troubleshooting tips.
Learn how to efficiently import large Excel files into a database using POI, JDBC, MyBatis, and Spring Boot, with step-by-step code examples, performance bottlenecks, and optimization techniques such as caching, asynchronous processing, multi-threaded batch inserts, and thread‑pool configuration for maximum throughput.
This guide shows how to activate Spring Boot's admin features via configuration, customize application shutdown with exit codes and DisposableBean, and monitor startup performance using ApplicationStartup and Actuator endpoints, all illustrated with practical code snippets and screenshots.
This article provides a comprehensive analysis of Spring Security 6.1, covering its core architecture, the role of FilterChainProxy, detailed authentication and authorization flows, key interfaces such as SecurityFilterChain, AuthenticationManager, and practical code examples to help developers understand and debug the framework.
This guide walks you through eight Spring Boot utilities—including ApplicationPid, ApplicationHome, JavaVersion, ApplicationTemp, SystemProperties, Instantiator, property loaders, and base package discovery—showing how to retrieve process IDs, directories, Java versions, temporary paths, system properties, instantiate beans, load resources, and inspect package information with concise code examples.
This article demonstrates how to add jCasbin to a Spring Boot project, covering Maven dependencies, configuration files, Enforcer initialization, custom policy objects, a servlet filter for authorization, and dynamic add‑remove permission APIs, enabling lightweight, database‑driven access control.
