This article explains how to design and implement a fixed-size FIFO export queue in a Spring Boot backend, using synchronized methods, EasyExcel for large data exports, and a test controller to simulate concurrent export requests, while discussing performance considerations and future enhancements.
This tutorial walks through setting up Spring AI 0.8.1 with Spring Boot 3.1.1, configuring Alibaba Tongyi model access, and implementing chat, streaming, image, and audio generation endpoints using Java code and vector database integrations.
This article demonstrates how to implement image anti-hotlinking in a Spring Boot application by creating a configurable interceptor, registering it, and providing flexible YAML settings, while discussing limitations such as referer spoofing and potential false positives.
This article presents a complete Netty TCP client demo for an IoT project, explaining the project background, architecture, modules, business flow, and detailed Java code—including a local queue, thread pool, client initialization, handler logic, and test controllers—along with deployment notes and source links.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system case study and complete code examples.
This article introduces the RSocket binary protocol, explains its four interaction models, highlights key features such as back‑pressure and lease, and provides step‑by‑step Spring Boot 2.7 examples for Request‑Response, Request‑Stream, Channel, and Fire‑and‑Forget communication.
In Spring Boot, using @Transactional and @Async on the same service method does not invalidate the transaction, but the asynchronous execution runs in a separate thread with its own transaction, isolated from the original thread's transaction due to AOP interceptor ordering.
This tutorial walks through configuring Spring Cloud OpenFeign with Spring Boot, covering basic setup, advanced capabilities like Micrometer metrics, Redis caching, @SpringQueryMap, @MatrixVariable, and @CollectionFormat, and shows how to view metrics via Prometheus or Actuator.
This tutorial demonstrates adding JsonPath to a Spring Boot project, using DSL‑style expressions to extract authors, titles, counts and filtered data from a sample JSON payload, and shows how to drive the extraction dynamically via configurable mappings with fastjson and hutool.
This article demonstrates how to use Java reflection in Spring Boot projects to automatically enforce naming conventions and coding standards, thereby enhancing code quality, maintainability, and scalability while providing practical demo steps and code examples.
This article explains how the @JsonView annotation in Spring Boot lets developers define multiple JSON views to selectively expose fields based on client needs, user roles, API versions, or data aggregation requirements, providing code examples and practical usage tips.
This article introduces Flyway as a database migration tool, explains its migration types and common commands, demonstrates how to integrate Flyway with Spring Boot using Maven and YAML configurations, provides example SQL migration scripts and logs, and briefly mentions related community promotions.
This tutorial explains how to deploy Graylog using Docker‑Compose for centralized log aggregation in a microservices environment and shows step‑by‑step integration of Graylog with a Spring Boot application via Logback‑GELF, including configuration, code examples, and basic log search queries.
This article provides a step‑by‑step tutorial on installing Flowable‑UI, designing BPMN diagrams, setting up a Spring Boot backend project, configuring the database tables, and using Flowable engine APIs with complete code examples and deployment instructions.
This article introduces Spring Cloud Gateway as a high‑performance, reactive API gateway for microservice architectures, explains why it is chosen, details Maven and YAML configuration, demonstrates routing predicates and filters with code examples, and evaluates its performance impact compared to alternatives.
This article explains why a Spring Boot 2.0.3 application creates two UserManager beans when both @Configuration + @Bean and @Component are used, how the container decides which instance is injected, and how newer Spring versions allow developers to control bean‑definition overriding via configuration.
This tutorial explains Lua scripting fundamentals, why Lua is ideal for Redis, common use cases, and step‑by‑step integration of Lua scripts into Spring Boot applications—including dependency setup, configuration, code examples, performance benefits, error handling, security considerations, and best‑practice recommendations.
This article analyzes how Redis pipelining works, compares Lettuce and Redisson clients under Spring Boot, presents performance benchmarks for batch inserts, discusses practical pitfalls, and explains the internal implementation of pipeline support in both clients to help developers avoid common issues.
mica-mqtt is a lightweight, low‑latency, high‑performance open‑source MQTT component built on Java AIO, offering full MQTT v3.1/v3.1.1/v5 support, WebSocket, REST API, client/server capabilities, clustering via Redis, GraalVM native compilation, Spring Boot starter integration, and extensive customization for IoT and messaging scenarios.
This tutorial walks through setting up a simple Spring Boot project, adding MyBatis‑Plus dependencies, configuring MybatisX in IntelliJ IDEA, generating entity, mapper, service, and controller code, and handling common connection issues, providing a complete end‑to‑end example of rapid MyBatis development.
This guide shows how to integrate the lightweight LiteFlow rule engine into a Spring Boot application, split complex business logic into reusable components, configure rule files, and use various component types—including switch, condition, and parameterized components—to achieve dynamic orchestration, hot‑reloading, and high scalability.
This article explains how to prevent duplicate submissions in Java backend services by implementing request debouncing using Redis caching and Redisson distributed locks, detailing the design of request lock annotations, unique key generation, and practical code examples for robust idempotent APIs.
This guide explains how Spring Boot 3.1.10 discovers and loads external configuration files from classpath and filesystem locations, how to customize file names and paths with spring.config.name, spring.config.location, and spring.config.additional-location, and demonstrates merging, profile-specific files, optional prefixes, wildcards, imports, and handling missing resources.
This guide walks you through setting up Spring AI, configuring model providers and vector stores, initializing a Spring Boot project, adding OpenAI credentials, and running a complete RAG (Retrieval‑Augmented Generation) demo with code snippets and sample API calls.
When converting Date parameters in OpenFeign calls, the client serializes them to strings using the local CST timezone, causing a 14‑hour discrepancy that can be resolved by using timestamps, @DateTimeFormat, or custom formatters on both client and server sides.
This tutorial walks through configuring Spring Batch on Spring Boot 2.7.16 to read data from one database, process it, and write to another, covering dependency setup, job and step beans, asynchronous execution, multithreading, job restart, and repeated launches with code examples.
The article examines how Spring Boot’s Lettuce and Redisson clients implement Redis pipelining, explains the batch‑request principle, benchmarks 100 000 set inserts showing pipeline speeds of 0.5–1.4 seconds versus 162 seconds for single commands, demonstrates Spring Data Redis callback usage, warns of high‑cost command pitfalls, and details Redisson’s RBatch internals, concluding that pipelining dramatically boosts throughput when command costs are modest.
This article explains how to analyze and optimize Spring Boot Docker images by using the new layer‑building feature in Spring Boot 2.3, restructuring Dockerfiles, and employing multi‑stage builds to eliminate duplicate layers, dramatically shrink image size, and speed up image pushes.
MyBatis-Plus, an enhanced MyBatis toolkit, simplifies CRUD operations and injects dynamic SQL to boost productivity; this guide outlines its core features, important upgrade notes—including MyBatis 3.5.16 and JSqlParser 4.9 versions—provides a detailed changelog, and shows Maven dependencies for Spring Boot 3.x and 2.x.
This article examines why HikariCP, the default Spring Boot 2.0 connection pool, achieves high performance by exploring its design concepts such as dual HikariPool instances, FastList, custom ConcurrentBag, thread‑local caching, and bytecode optimization, and includes sample Maven configuration and Java code.
This guide explains how to implement a robust, re‑entrant distributed lock using Redisson in a Spring Boot 2.7 application, covering basic and asynchronous APIs, Maven dependency setup, YAML configuration, custom annotation, AspectJ implementation, and comprehensive test cases.
Learn how Cross-Origin Resource Sharing (CORS) works, when it’s needed, the role of preflight requests, essential HTTP headers, and step-by-step Spring Boot solutions—including @CrossOrigin annotations, global configuration, and custom filters—to securely enable cross-domain calls in your applications.
This article explains how to build a reusable Spring Boot starter that automatically encrypts response data and decrypts request payloads using Hutool-Crypto's AES utilities, covering request stream handling, validation, custom starter configuration, and example code for controllers and entities.
This article introduces WeBlog, a Spring Boot + Vue 3.2 based front‑and‑back end blog, details its core features, module structure, technology stack, provides repository links and demo credentials, and showcases screenshots of the admin dashboard and user interface.
This article presents Liteflow, a lightweight yet powerful Java rule engine that supports XML/JSON/YAML rule files, multiple storage backends, and hot‑deployment, and demonstrates its components, configuration, and a real‑world e‑commerce workflow example with code snippets.
Graceful Response is a Spring Boot library that provides unified response wrapping, global exception handling, custom error codes, validation support, and configurable response styles, enabling developers to write cleaner controller code, reduce boilerplate, and improve API consistency.
This article explains how to integrate Lua scripts with Redis in a Spring Boot application, covering Lua basics, performance benefits, common use cases, step‑by‑step configuration, Java code examples, error handling, security considerations, and best practices for reliable backend development.
This article provides an in‑depth overview of WebSocket, covering its definition, advantages and disadvantages, protocol details, connection lifecycle, message format, JavaScript and Java APIs, Spring Boot integration, performance considerations, and future development directions.
This guide shows how to integrate the open‑source Tesseract OCR engine into a Spring Boot application using the Tess4J Java wrapper, covering Chinese language data setup, Maven dependency configuration, bean creation, service implementation, and a unit test to verify image text extraction.
This article explains how to integrate Lua scripts into Spring Boot applications for Redis, covering Lua fundamentals, performance benefits, common use cases, step‑by‑step implementation with Spring Data Redis, error handling, security considerations, and best‑practice recommendations.
This article explains the five major Spring Boot extension points—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how to register custom implementations via SPI, where they are invoked in the startup flow, and providing code examples for each.
This guide explains how to configure logging in Spring Boot, handle EnvironmentChangeEvent updates, use @RefreshScope limitations, encrypt properties with Spring Cloud, leverage Actuator endpoints for environment refresh, and create custom property sources via spring.factories, providing code examples throughout.
This article explains how to achieve zero‑downtime releases for Java applications by using JVM shutdown hooks, Spring context events, and service‑registry tricks for both monolithic and microservice architectures, with concrete code samples, configuration details, and Kubernetes probes to ensure seamless online upgrades.
This article explains the concept of graceful shutdown, walks through a Kubernetes pod termination flow, demonstrates a Spring Boot + Nacos example with PreStop hooks, identifies common pitfalls, and provides practical optimizations—including MQ handling, scheduled tasks, traffic control, and actuator shutdown—to achieve reliable, zero‑downtime service termination.
A single overly long line in /etc/hosts caused Spring Boot to hang while fetching Apollo configuration on CentOS 6, and splitting the line into shorter entries resolved the issue, highlighting a subtle hosts‑file limitation in older Linux kernels.
This article explains how to integrate Apache Kafka into a Spring Boot project, covering dependency setup, producer and consumer configuration, code examples, and optimization tips to build a high‑throughput, reliable message processing system.
This tutorial introduces the EasyCode IntelliJ IDEA plugin, explains how to install it, connect a database, configure generation settings, and automatically produce Java CRUD components such as entities, DAOs, services, and controllers, concluding with integration steps in a Spring Boot application.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua basics, advantages of Lua in Redis, practical use cases, step‑by‑step implementation with code examples, performance optimization, error handling, security considerations, and best practices for reliable backend development.
This article explains how Spring Boot's @Conditional annotations—covering class, bean, property, resource, web application, and SpEL expression conditions—can be used to conditionally load configuration and beans, with examples and guidance on custom conditions.
This article explains the concept of graceful shutdown, demonstrates it with Kubernetes‑SpringBoot‑Nacos case studies, analyzes common issues, and provides optimization strategies such as adjusting terminationGracePeriodSeconds, using PreStop hooks, handling MQ and scheduled tasks, and leveraging actuator shutdown for reliable service termination.
This guide walks you through creating a Spring Boot project, integrating the Druid connection‑pool, configuring its WebStatFilter and StatViewServlet for full SQL monitoring, testing the setup, and removing the built‑in advertisement via a custom filter.
This article explains Spring Web MVC.fn's functional programming model, covering HandlerFunction, immutable request/response contracts, parameter validation, routing predicates, nested routes, filters, and provides complete code examples for building functional endpoints in Spring Boot 2.7.
This article introduces Spring 6's new HTTP Interface feature, walks through building a Spring Boot project with a User entity, a REST controller, an HTTP Interface definition, and a test using WebClient, while explaining related annotations and the need for Spring Reactive Web dependencies.
This tutorial explains how to let users upload PDF, Word, or TXT files, install the Elasticsearch Ingest Attachment Processor Plugin, create an ingest pipeline and index mapping, convert files to Base64, and perform fuzzy searches with highlighted results using Spring Boot and Java code examples.
This article walks you through creating a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration classes, registration via spring.factories (or the new imports file), and comprehensive unit testing strategies to ensure reliable conditional behavior.
This tutorial shows how to install HashiCorp Vault, configure its secret engines, encrypt and decrypt data, store KV secrets programmatically, and integrate Vault with Spring Boot to protect sensitive configuration such as database credentials.
This article introduces the design and implementation of a remote hot‑deployment component (Mark42/Jarvis) built on Java Agent and an IDEA plugin, analyzes the challenges of dynamic compilation in Spring‑Boot fat‑jar environments, presents solution choices, and shares practical experiences and future directions.
This tutorial walks through setting up a Spring Boot backend, adding the Tess4J OCR library, creating a service and REST controller to recognize text from both local files and remote image URLs, and provides testing steps and deployment tips.
This article explains how to replace repetitive manual if‑else checks with Spring Boot’s built‑in Bean Validation, demonstrating the use of @Valid, @Validated, custom constraint annotations, group validation, and global exception handling to achieve clean, reusable, and maintainable parameter validation across controllers and services.
Learn how Spring Boot 2.7.16 leverages ApplicationEvent and ApplicationListener for synchronous event handling, then explore two asynchronous approaches—using @Async with @EventListener and custom thread pools with a bespoke ApplicationEventMulticaster—complete with code examples and configuration details.
This guide walks through creating a Spring Boot backend that accepts PDF, Word, and TXT uploads, extracts their text using Elasticsearch's ingest‑attachment plugin, stores metadata in MySQL, and provides fuzzy search and highlighted results via Elasticsearch queries.
This tutorial walks through creating a Spring Boot application that integrates the OpenAI ChatGPT API, covering prompt concepts, API endpoint details, required request parameters, project setup, necessary dependencies, DTO definitions, RestTemplate configuration, and a REST controller to generate AI‑driven responses.
This tutorial explains how Spring Boot's @ResponseStatus annotation works, demonstrates practical ways to throw ResponseStatusException, create custom exception classes, annotate controller methods, and replace the default error view with a custom JSON response, complete with code samples and diagrams.
This article demonstrates how to boost the insertion speed of over two million records by configuring a Spring Boot ThreadPoolTaskExecutor, integrating it with MyBatis‑Plus and PostgreSQL, and measuring multi‑threaded versus single‑threaded performance to determine the optimal thread count.
Learn how to implement a two‑level caching architecture in Spring Boot using Caffeine as a local cache and Redis as a remote cache, covering manual implementations, annotation‑driven approaches with @Cacheable/@CachePut/@CacheEvict, and a custom @DoubleCache annotation to minimize code intrusion while improving response times.
This article explains the concept of graceful shutdown, outlines the standard steps, and presents detailed Kubernetes, Spring Boot, and Nacos case studies, followed by optimization techniques, code examples, and practical recommendations for handling MQ, scheduled tasks, and traffic control during service termination.
This guide explains how to use @InitBinder and @ControllerAdvice in Spring Boot 2.7.16 to customize WebDataBinder for request parameter conversion, demonstrates practical examples in controllers and global configuration, and shows how to register converters for flexible data binding.
This guide demonstrates how to integrate Tess4J OCR into a Spring Boot application, covering environment setup, Maven dependencies, adding language data, creating an OCR service class, building REST endpoints for local and remote image processing, and testing the solution.
This article demonstrates how to integrate Spring Boot with Minio, covering two upload strategies—backend‑mediated storage and direct client uploads with presigned credentials—while providing complete configuration, Java code, and a Vue‑based frontend example that includes chunked, instant, and resumable upload techniques.
This guide shows how to integrate Apache Tika into a Spring Boot application, covering Maven dependencies, XML configuration, a Spring @Configuration class, and usage of Tika’s detection and parsing APIs for processing various document formats.
This article explains the key changes when upgrading to Spring Boot 3, covering URL matching deprecation, HTTP header size configuration, removal of Apache HttpClient support, Actuator endpoint sanitization, and various property and dependency updates for a smooth migration.
This article introduces the lightweight yet powerful LiteFlow rule engine, explains its architecture, component types, EL rule files, data context handling, configuration, and demonstrates a practical e‑commerce workflow with hot‑deployment capabilities.
This guide demonstrates how to add Apache Tika to a Spring Boot project by declaring the tika‑bom, core and parser dependencies, providing a custom tika‑config.xml, creating a @Configuration class that builds a Tika bean, and then injecting the bean to detect, parse, or translate documents.
This article explains three practical Spring Boot approaches—scheduled tasks, delayed RabbitMQ queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with ready‑to‑use Java code examples.
This article explores the advantages of combining Java, Spring Boot, and Vue for full‑stack web development, outlining the technology selection, step‑by‑step development workflow, best practices for code quality, testing, debugging, performance optimization, and deployment using containerization.
This article explains how to integrate Spring Boot with Minio to enable direct client‑side file uploads by generating time‑limited presigned credentials on the backend, covering environment setup, Maven dependencies, configuration classes, REST endpoints, response fields, and complete front‑end examples including chunked and resumable uploads.
Graceful Response is a Spring Boot component that provides unified response wrapping, global exception handling, and custom error codes, helping developers reduce boilerplate, improve code readability, and accelerate API development while maintaining consistent error responses.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.
This tutorial walks you through creating a custom Spring Boot Starter, from Maven project setup and dependency configuration to defining auto‑configuration classes, registering them, and writing comprehensive unit tests to verify conditional behavior.
This article introduces J2Cache, a two‑level caching framework for Spring Boot, explains its L1 (Caffeine/Ehcache) and L2 (Redis/Memcached) architecture, and provides a complete hands‑on example covering Maven dependencies, configuration, core service classes, REST controller, and testing procedures.
This tutorial explains how to integrate Elasticsearch into a Spring Boot application, covering project setup, dependency addition, configuration, entity and repository creation, service and controller implementation, and testing to enable efficient full‑text search for large data sets.
This article explains Spring Boot’s @MatrixVariable feature, covering its RFC 3986 basis, practical usage scenarios, multiple code examples, and the underlying request‑mapping mechanism, helping developers efficiently pass multi‑dimensional parameters within URI paths.
This tutorial explains how to create a custom Spring Boot Starter, covering project setup, Maven dependencies, auto‑configuration class creation, registration via spring.factories, and comprehensive unit testing to ensure correct conditional behavior.
Learn how to set up Camunda, a flexible Java-based BPMN 2.0 workflow engine, within a Spring Boot application by generating a project, configuring dependencies, defining data models and REST endpoints, designing a simple process diagram, and testing the workflow end‑to‑end.
This article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, advantages of Lua in Redis, practical use cases, step‑by‑step implementation, performance optimization techniques, error handling, security considerations, and best practices for reliable backend development.
This article explains how to integrate Spring Retry into a Spring Boot project to gracefully handle third‑party API failures, covering annotation‑based retries, asynchronous retries, exception filtering, fallback handling, and an optional Hystrix circuit‑breaker extension for comprehensive fault tolerance.
This article introduces LiteFlow, a powerful rule‑engine framework for Spring Boot, explains its advantages, shows how to define rules in XML/JSON/YML, and provides a complete end‑to‑end example with code snippets and hot‑swap components for flexible business logic.
Spring Boot offers several ways to validate request parameters—including the @Valid and @Validated annotations and custom validation annotations—each with its own strengths, allowing developers to enforce data integrity, improve code quality, and enhance user experience across different scenarios.
This article explains how to design and implement a two‑level caching architecture in Spring Boot by combining a local Caffeine cache with a remote Redis cache, covering manual approaches, annotation‑driven management with Spring Cache, and a custom AOP solution to minimize code intrusion.
This article provides a comprehensive guide to Spring Cloud, covering Spring Boot fundamentals, service discovery with Eureka, gateway routing, load balancing, Feign, Ribbon, circuit‑breaker patterns with Hystrix and Sentinel, configuration management via Nacos, tracing with Sleuth/Zipkin, security mechanisms, gray releases, and performance tuning for production microservices.
This guide explains how Spring Boot automatically registers Servlet, Filter, and Listener beans, how to customize their mappings with registration beans, configure the embedded servlet container, and handle JSP limitations, providing code examples and practical tips for backend developers.
This article explains how Spring's @ConfigurationProperties and @PropertySources annotations work, compares their purposes, and provides step‑by‑step examples for binding external configuration to Java beans and loading multiple property files in a Spring Boot application.
This article explains the fundamentals of Aspect‑Oriented Programming (AOP) in Spring, describes its core concepts such as pointcuts, advice, aspects, join points and weaving, and provides multiple Spring Boot examples—including simple @GetMapping logging, custom permission annotations, and the use of various AOP annotations—complete with full source code snippets.
This article explains how to use Spring Boot's @EnableScheduling and @Scheduled annotations to create cron, fixed‑delay, and fixed‑rate tasks, and demonstrates a lightweight approach for dynamically updating or disabling cron expressions at runtime without external schedulers.
This article presents several approaches for generating unique, scalable order numbers in Spring Boot, including UUIDs, database sequences or auto‑increment IDs, timestamp‑based strings with random components, and distributed Snowflake IDs, each accompanied by Java code examples and discussion of their advantages and drawbacks.
This guide walks through essential Spring Boot 2.7.16 features—including bean lifecycle annotations, dependency injection methods, Java‑based configuration, conditional beans, event listeners, AOP, scheduled tasks, data access with Spring Data JPA, caching, exception handling, security, SpEL, configuration management, performance monitoring, and micro‑service components—providing concise code examples for each.
This article compares the performance of Log4j2 and Logback in Java, explains their relationship with SLF4J, presents benchmark results under various thread counts, and provides detailed configuration and usage guidelines for both Spring Boot and plain Java projects.
This article evaluates the performance of Spring Boot 3.2's virtual threads versus traditional platform threads when serving static files, using a MacBook Pro M2, Bombardier load testing, and detailed latency and throughput metrics across multiple concurrency levels.
This article explains the differences between confidential and public OAuth2 clients, illustrates the authorization‑code interception risk, and provides a step‑by‑step Spring Boot 3 implementation of PKCE—including configuration, code verifier generation, and token exchange—to harden security.
A week‑long API freeze in a sandbox environment was traced to Redis connection pool misconfiguration, where threads waited indefinitely for a Jedis resource, leading to Tomcat request threads blocking and 500 errors, and the issue was resolved by adjusting pool settings and using proper connection release patterns.
