This article explains how to configure Spring Boot's built‑in ThreadPoolTaskExecutor, customize its core parameters, and use it together with Java 8 CompletableFuture to run asynchronous tasks, including a performance comparison with a synchronous implementation.
This guide shows how to add a retry mechanism to Spring Boot applications using Spring Retry, covering dependency setup, enabling @EnableRetry, defining @Retryable with custom back‑off settings, handling failures with @Recover, writing unit tests, and observing behavior with different retry counts and exception filters.
This guide walks through integrating Spring Data Elasticsearch into a Spring Boot application, covering entity mapping annotations, repository creation, service layer implementation, and unit tests to perform create, read, update, delete, and fuzzy search operations on Elasticsearch indices.
Learn how to set up and integrate the Camunda BPMN 2.0 workflow engine into a Spring Boot application, covering project initialization, Maven dependencies, configuration files, creating a simple user task process, and testing the workflow via Camunda’s web interface.
This guide explains how to implement a searchable user‑story interface using PostgreSQL tables with btree and gin indexes, Java record models, Spring Boot data access, and REST controllers to support range and full‑text queries efficiently.
This tutorial walks you through adding OpenAI's generative capabilities to a Spring Boot application with Spring AI, covering project setup, API key configuration, controller creation, simple and advanced prompt usage, and how to test the resulting AI-powered endpoints.
This article explains how to design a standardized JSON response format, implement a unified result class and enum, handle global exceptions with @ControllerAdvice, and configure comprehensive Logback logging for Spring Boot applications, providing complete code examples and best‑practice guidelines.
This tutorial explains how to integrate Gemini's free API and long‑context capabilities into a Spring Boot starter to recognize image captchas, handle interference lines, and solve arithmetic challenges, providing code samples, configuration steps, and best practices for improving automation efficiency.
This guide explains why upgrading from Spring Boot 2.x to 3.x is essential, outlines the required JDK 17 migration, Spring Boot version bump, configuration property changes, Jakarta EE transition, and updates to Spring Security, Kafka, RestTemplate, and OpenAPI integration, providing code examples for each step.
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 article explains how to integrate Lua scripts into Spring Boot applications using Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation, error handling, security considerations, and best practices for optimizing backend services.
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.
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.
Learn how to seamlessly integrate Spring Data Redis Repositories in a Spring Boot 2.7 environment, covering object mapping, CRUD operations, indexing with @Indexed, query‑by‑example, batch saves, and setting expiration using @TimeToLive, complete with code examples and visual data representations.
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.
Cache warming, a technique used in high‑concurrency systems, involves preloading frequently accessed data into memory before traffic spikes to improve hit rates, reduce cold‑start latency, prevent cache breakdowns, and lessen backend load, with various strategies such as startup loading, scheduled jobs, manual triggers, Redis tools, and Caffeine loaders demonstrated through Spring Boot code examples.
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 guide demonstrates how to use Spring Boot 2.7 with Redis 6.2 to implement Pub/Sub messaging, transactional operations, pipelined commands, and Lua‑based distributed locks, providing code examples, configuration details, and explanations of each feature’s advantages and limitations.
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 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 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 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 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.
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.
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 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.
Celebrating the Lunar New Year, this roundup shares essential Java 21 updates, Spring Boot 3.2 enhancements, domestic open‑source innovations, and other hand‑picked tools and articles, providing developers with quick links to explore new APIs, performance improvements, and cutting‑edge Java ecosystem resources.
This tutorial walks through enabling Spring MVC, configuring type conversion, validation, interceptors, content negotiation, custom YAML message converters, view controllers, view resolvers, and static resource handling in a Spring Boot 2.7.12 application, complete with code examples and output screenshots.
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 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 compares Spring Boot 3.2's virtual‑thread support with traditional Tomcat thread pools and reactive WebFlux, showing configuration steps, code examples, JMeter load‑test results, and database access benchmarks to illustrate throughput, CPU and memory impacts.
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 the five major extension points in Spring Boot—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, where they are invoked during the startup lifecycle, and how to implement custom ones with 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 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 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 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 explains how combining Spring Boot 2.7 with JDK 17 can improve Java application performance, outlines the new language and runtime features, details migration challenges, provides configuration and code examples, and shares practical deployment guidance for cloud‑native environments.
This article provides a step‑by‑step tutorial on deploying the Ctrip Apollo configuration center, creating projects and namespaces, integrating Apollo with a Spring Boot application, configuring environments, clusters and namespaces, and testing dynamic configuration updates in Kubernetes, covering all essential concepts and practical code examples.
This article demonstrates how to integrate Spring Expression Language (SpEL) with custom annotations and AOP in Spring Boot to create a highly flexible, maintainable permission‑checking mechanism that can handle various complex access scenarios without scattering hard‑coded logic throughout the codebase.
This tutorial explains when to choose XML over JSON, compares their characteristics, and provides step‑by‑step Spring Boot 3.1.7 examples—including Jackson XML configuration, custom root elements, XML view rendering, and JAXB marshalling—to produce XML responses from REST endpoints.
This article presents the 20 most common Spring Boot interview questions, covering fundamentals, features, configuration, performance, security, microservices, and deployment, to help job seekers prepare effectively for Spring Boot related positions in the industry.
Easy-Es is a Java ORM framework built on Elasticsearch's RestHighLevelClient that simplifies search‑engine development, offers Mybatis‑Plus‑like usage, provides configuration and dependency details, and includes complete code examples for creating indexes and performing CRUD operations within Spring Boot applications.
This guide explains why Spring Boot applications consume memory, shows how to configure the JVM and Tomcat settings, and demonstrates using Docker‑compose to apply these tweaks, enabling developers to reduce local memory usage by more than 40% and speed up development cycles.
This tutorial walks through creating a complete Spring Boot 2.7 project that integrates Apache Dubbo for RPC, covering environment setup, Maven dependency management, interface definition, provider and consumer implementations, configuration with Nacos, and testing the end‑to‑end service.
This guide walks through configuring the ELK stack (Elasticsearch, Logstash, Kibana) for Spring Boot applications, integrating Logback via logstash-logback-encoder, setting up Filebeat in Docker containers to collect Nginx logs, and creating Kibana index patterns for efficient log querying.
This article demonstrates a step‑by‑step method for exporting a list of unknown Java objects to an Excel/CSV file by leveraging reflection to dynamically generate headers and rows, complete with Maven dependencies, utility code, usage examples, and an extensible annotation‑based approach.
This tutorial explains why enterprise applications need multiple data sources, outlines the scenarios such as business isolation, migration, performance and maintainability, and provides a step‑by‑step implementation of dynamic data source routing in Spring Boot using custom context holders, routing classes, annotations, aspects, configuration, and web‑request control.
This article explains how Spring Boot 3's Http Interface feature enables declarative HTTP service calls by defining Java interfaces, covering dependency setup, interface definition, token handling, configuration, controller integration, testing with Postman, and a brief discussion of its WebFlux dependency.
This guide walks through setting up Spring Authorization Server on Spring Boot 3.1 with JDK 17, covering environment setup, required dependencies, custom security filter chains, in‑memory user and client configurations, JWT signing, endpoint settings, consent service, and step‑by‑step testing of the authorization code flow.
This article walks through creating a standardized JSON response structure with a Result enum and wrapper class, demonstrates how to return it from controllers, implements a @ControllerAdvice‑based global exception handler with custom exceptions, and configures Logback for comprehensive logging in Spring Boot applications.
This guide explains how to use Nacos as a centralized configuration center in Spring Boot micro‑services, covering common pitfalls of static configs, best‑practice namespace/group/DataId design, dependency setup, YAML examples, security annotations, role‑based access, Dockerfile tweaks, CCE deployment, database schema, and Kubernetes manifests for test and production environments.
Spring Boot 3.2.2 brings a comprehensive update with 50 bug fixes, documentation improvements, and a long list of dependency upgrades ranging from MySQL and Kotlin to Netty and Tomcat, helping developers keep their backend services stable and up‑to‑date.
This guide walks through implementing a two‑level cache in Spring Boot 2.7 using Lettuce’s CacheFrontend together with Caffeine, covering dependency setup, configuration, custom CacheAccessor, bean definitions, and sample endpoints that demonstrate automatic synchronization and eviction between local JVM cache and Redis.
This article explains why retry mechanisms are essential for unstable third‑party API calls, introduces Spring Retry, demonstrates how to configure synchronous and asynchronous retries, handle exception inclusion/exclusion, integrate circuit‑breaker fallback with Hystrix, and provides performance testing guidance, all with practical code examples.
This article examines a performance comparison of Spring Boot applications using physical threads, Java virtual threads, and WebFlux for JWT verification with MySQL, detailing test setup, code examples, benchmark results across various concurrency levels, and concluding that virtual threads perform worst due to MySQL driver incompatibility.
This guide walks through installing APISIX, defining security and functional requirements, developing a Java decryption plugin and a Lua body‑rewrite plugin, configuring them with Docker and APISIX, and setting up route rules to enable encrypted API traffic in a cloud‑native environment.
This article walks through the complete process of implementing a custom login authentication in Spring Boot, including custom authentication filters, success/failure handlers, a token stored in Redis, role‑based URL security, and detailed configuration of Spring Security headers and session handling.
This article explains cache prewarming—its purpose, benefits, and various strategies such as startup loading, scheduled tasks, manual triggers, and cache loaders—while providing concrete Spring Boot and Redis examples, including code snippets for ApplicationReadyEvent, CommandLineRunner, InitializingBean, @PostConstruct, @Scheduled, and Caffeine cache loader.
This article explains the concepts, architecture, and practical usage of Liteflow, a lightweight Java rule engine that integrates with Spring Boot, supports various rule file formats, multiple component types, data contexts, and configuration options for building complex workflow processes in backend applications.
This guide demonstrates how to retrieve command‑line arguments, use JSON‑encoded properties, load external configuration files, encrypt values, parse YAML, generate random properties, handle internationalization, customize the banner, and configure the application context in Spring Boot 3.0.9, providing code examples for each feature.
This article walks Java and Spring Boot developers through installing Camunda, configuring dependencies, setting up the database, creating a simple BPMN process with user and service tasks, and testing the workflow via the Camunda web interface, providing code snippets and screenshots for each step.
This article explains how to replace repetitive try‑catch blocks in Java Spring applications with a unified exception handling strategy using @ControllerAdvice, custom Assert utilities, and enum‑based error codes, providing clean, maintainable code and consistent API responses.
This guide walks you through setting up Spring Cloud Task on Spring Boot 2.7 with Spring Cloud 2021, covering environment requirements, Maven dependencies, configuration files, task annotations, ApplicationRunner implementation, database schema, task listeners, and advanced task configuration options.
This article explains three Spring Boot approaches—using @Scheduled tasks, RabbitMQ delayed queues, and Redis key‑expiration events—to automatically cancel orders that remain unpaid for 30 minutes, complete with code samples and configuration guidance.
This article explains the core extension points of Spring Boot—including ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, registered in spring.factories, and invoked during the application startup lifecycle.
This article explains how to use Spring Boot Security for authentication and improve performance by caching user details in Redis, covering dependency setup, security configuration, Redis integration, testing endpoints, and optimization tips for a robust backend authentication solution.
This guide explains how to use Spring Integration's LockRegistry for distributed locking, covering both database‑based and Redis‑based implementations, complete with Maven dependencies, configuration snippets, bean definitions, and comprehensive test cases to ensure reliable synchronization across multiple nodes.
This article explains the concept of SQL injection, demonstrates a vulnerable query example, and provides a step‑by‑step Spring Boot and MyBatis implementation—including table creation, Java controller, service, DAO, mapper, and configuration—to illustrate how proper parameter handling prevents injection attacks.
This tutorial walks you through creating a Spring Boot project, configuring OpenAI credentials, building a controller, and using Spring AI's Prompt and PromptTemplate classes to integrate generative AI capabilities into your backend application.
This article explains the core concepts, architecture, and implementation details of Xxl-Job, a lightweight distributed task scheduling platform, covering the scheduler center, executor, job handling, demo setup, routing strategies, trigger mechanisms, and result callbacks.
This article explains why MQ is needed beyond in‑process event listeners, details the required dependencies for Spring Boot 3, shows how to configure RocketMQ, provides code snippets for producer, consumer, and testing, and offers practical tips for handling async, batch, and one‑way messaging.
This guide explains how to secure Spring Boot API responses using RSA asymmetric encryption, covering the theory of RSA, practical scenarios, Maven setup, annotation‑based encryption/decryption, configuration files, and a JavaScript front‑end example for encrypting request payloads.
This article introduces the MyBatis‑Plus Generator UI, a highly customizable web‑based code generation framework that supports multiple databases, explains its core features, provides step‑by‑step integration with Spring Boot, and demonstrates how to extend templates and configure naming conventions for efficient backend development.
This article evaluates the performance of Spring Boot 3.2's virtual threads when serving static files, comparing them with traditional platform threads across various concurrency levels, and concludes that platform threads slightly outperform virtual threads in this I/O‑bound scenario while suggesting better use cases for database‑driven workloads.
This guide explains how to protect Spring Boot production packages from decompilation by using the ClassFinal Maven plugin for code encryption, configuring machine‑bound startup, and comparing it with ProGuard obfuscation, including detailed plugin setup, launch commands, and observed decompilation results.
This article explains why duplicate form submissions occur, the risks they pose, and demonstrates a Spring Boot solution that uses a custom @RequestLock annotation together with Redis SETNX to generate a unique key and block rapid repeated requests, complete with project setup, code examples, and usage instructions.
This article provides a step‑by‑step guide to building a Spring Boot starter that abstracts Amazon S3‑compatible object storage services such as Alibaba Cloud OSS, Tencent COS, Qiniu OSS, and MinIO, covering dependency setup, configuration properties, template interfaces, implementation, auto‑configuration, packaging, and testing.
This article explains why scheduled jobs run twice in a multi‑node deployment, shows how to isolate the timing logic into a single service, and demonstrates using ElasticJob with Zookeeper for sharding, distributed locks, and high‑availability to ensure each task executes exactly once.
This article explains how to implement API request rate limiting in Spring Boot by creating a custom @RequestLimit annotation, using Redis to track request counts, and configuring a HandlerInterceptor and WebMvcConfig to enforce limits on controller methods.
This tutorial explains why BeanUtil.copyProperties is discouraged in Java projects and shows how to install and use the Bean Converter IDEA plugin to automatically generate setter injection code, streamlining bean mapping and improving development efficiency.
This guide walks developers through upgrading from Spring Boot 2.x to 3.x, covering JDK 17 migration, pom.xml changes, configuration property updates, Jakarta EE transition, security reconfiguration, Kafka template adjustments, and OpenAPI integration, with code examples for each step.
This article summarizes a video tutorial that introduces Spring AI, a new project enabling generative AI in Spring Boot applications, demonstrates adding dependencies, configuring OpenAI or Azure OpenAI API keys, using prompts, templates, output parsers, and showcases converting AI responses into domain objects.
To achieve fast bulk inserts in MyBatis, open a session with ExecutorType.BATCH and insert records individually (letting JDBC batch them), limit foreach‑generated statements to about 20‑50 rows, or use MyBatis dynamic‑SQL or plain JDBC batch, avoiding massive SQL parsing and CPU overload.
This article explains how to use Maven profiles and the Maven Assembly Plugin to create environment‑specific Spring Boot zip packages and provides a reusable shell script (shenniu_publish.sh) for extracting, starting, stopping, and restarting the packaged JAR on Linux, improving deployment efficiency.
This article explains the Server‑Sent Events (SSE) technology behind ChatGPT's streaming responses, compares SSE with WebSocket, outlines its core implementation steps, and provides a complete Spring Boot example for pushing live stock prices to browsers.
This article explains ten practical techniques for implementing robust parameter validation in Spring Boot applications, covering built‑in annotations, custom constraints, server‑side checks, internationalization, validation groups, cross‑field rules, exception handling, testing, and the importance of complementary client‑side validation.
This article explains why traditional LIKE queries fail on encrypted sensitive fields, analyzes common scenarios, and presents four practical solutions—including tokenized ciphertext mapping—along with environment setup, Maven dependencies, and complete Spring Boot code to enable secure fuzzy searches on encrypted data.
This guide explains why and how to create a custom HttpMessageConverter in Spring Boot 2.7.12, covering the implementation of the converter, its registration in the MVC configuration, testing with Postman, and the underlying request‑response processing mechanism.
This guide walks through integrating MyBatis‑Plus with Spring Boot, covering dependency setup, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑data‑source support, and testing with concrete code examples and detailed explanations.
This article introduces mybatis-plus-generator-ui, a highly customizable web‑based code generator built on MyBatis‑Plus that supports multiple databases, offers interactive UI for generating Entity, Mapper, Service, Controller and other layers, and provides detailed usage, configuration, and extension instructions for Java backend developers.
This article presents mybatis-plus-generator-ui, a web‑based code generation framework that wraps MyBatis‑Plus, explains its features, shows how to integrate it via Maven and a Spring Boot entry point, demonstrates customization through templates and NameConverter, and provides guidance for building the UI frontend.
Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.
