This tutorial explains how to integrate Feign‑reactive into a Spring Boot 2.7 application, covering dependencies, reactive interface definitions, fallback handling, custom configurations, timeout, load‑balancing, and circuit‑breaker settings with complete code examples.
The article details a step‑by‑step investigation of a Spring Boot service that failed to meet a 500 requests/second target, analyzes slow SQL, thread‑pool misconfiguration, excessive logging, and high CPU usage, and presents concrete optimizations that roughly doubled throughput.
This release note summarizes Spring Boot 3.2.1's extensive bug fixes, documentation updates, and a comprehensive set of dependency upgrades, providing developers with essential information to upgrade their applications safely and efficiently.
This article explains how to classify interface exceptions, implement unified handling using Spring Boot's @ControllerAdvice and custom ErrorController, and provides practical code examples for business, system, client, and filter exceptions, including redirect and error page strategies.
This article walks through multiple ways to add text or image watermarks to PDF files in a Spring Boot application, covering Apache PDFBox, iText, Ghostscript command‑line, Free Spire.PDF, and Aspose.PDF, with Maven dependencies, step‑by‑step code examples, and practical tips for preserving original documents.
This article explains how to set up WebSocket communication in Spring Boot 2.7.12, covering the protocol basics, handshake process, custom HandlerMapping, annotation-driven routing, and a reactive WebFlux handler with code examples, plus deployment considerations behind reverse proxies.
This article explains how to build a high‑performance file chunk (slice) upload system using Spring Boot and MinIO, covering project setup, MinIO configuration, controller and service implementation, front‑end integration with Thymeleaf, and performance optimizations such as parallel uploading and resumable transfers.
This article introduces the MyBatis-Plus Generator UI, a web‑based tool that streamlines Spring Boot code generation for entities, mappers, services, and controllers, explains how to integrate it via Maven, configure databases, customize templates, and extend its functionality with custom name converters.
This guide introduces Spring Boot 3.2's new JdbcClient, explains how to add the dependency, inject it, and perform fluent, chainable CRUD operations—including queries by ID, custom conditions, named parameters, map parameters, row mapping, and inserts—while highlighting its advantages over traditional ORM tools.
This guide demonstrates five practical Spring Boot 3 techniques—including using @ConfigurationProperties with validation, handling missing @Value entries, defining custom property sources, enforcing required properties, and parsing YML files—to ensure robust configuration management and prevent startup failures.
This article demonstrates how to use Spring Boot 3.2 with Java 21, enabling virtual threads and GraalVM native images, providing step‑by‑step setup, configuration, and sample code for controllers, async tasks, and scheduled jobs, and discusses performance benefits and considerations.
This article explains the default Tomcat settings in Spring Boot 2.7.10, detailing connection queues, thread pool parameters, timeout configurations, and internal threading architecture, and provides practical examples and testing results for various concurrent connection scenarios.
This guide explains why Spring Boot 2.7 is the optimal bridge to JDK 17, details the new language and performance features, provides step‑by‑step deployment and configuration instructions for JD Cloud, and shares practical compatibility fixes and IDE tips for a smooth migration.
This article analyzes the inefficiencies and duplication in typical Spring Boot controller code, introduces the Graceful Response library, and provides step‑by‑step instructions—including Maven integration, annotation setup, controller and service examples, exception mapping, validation handling, and response style configuration—to achieve cleaner, unified API responses.
This guide explains how to protect Spring Boot production packages from reverse engineering by applying code obfuscation with ProGuard and full encryption using the ClassFinal Maven plugin, including configuration steps, encrypted startup commands, machine‑binding activation, and the resulting decompilation behavior.
This article introduces mica-auto, an annotation‑processor‑based tool that automatically generates Spring Boot starter configuration files—including spring.factories, AutoConfiguration.imports, and java SPI settings—enabling seamless compatibility with Spring Boot 3.x without maintaining separate branches.
This guide walks you through building a Spring Boot application that calls the OpenAI ChatGPT API, covering prompt concepts, API request details, required dependencies, configuration of RestTemplate with authentication, DTO definitions, controller implementation, and example use cases.
This article explains the concept of idempotency, presents several strategies to achieve it, and provides a complete Spring Boot implementation using Redis, a custom @AutoIdempotent annotation, token generation and verification, interceptor configuration, and test cases to ensure only the first request succeeds.
This article explains how to retrieve and handle various Spring Boot API parameters—including query, path, request body, header, and file uploads—covers parameter type handling such as dates and lists, demonstrates validation annotations, and provides complete code examples for each scenario.
This guide walks through configuring a Spring Boot 2.4.12 project with Elasticsearch 7.8, creating index templates, implementing bulk write operations, and testing the setup with sample code and endpoints, enabling automatic index creation and efficient data ingestion.
This article explains the CQRS pattern, its origins, benefits, and pitfalls, then details how to implement CQRS and event sourcing in Spring‑based microservices using Axon and Kafka, while discussing architectural considerations, scalability, consistency, and tooling.
This article explains the concept of graceful shutdown, outlines the essential steps, and demonstrates a practical Kubernetes‑Spring Boot‑Nacos case study, including PreStopHook handling, terminationGracePeriodSeconds tuning, and further optimizations for message queues, scheduled tasks, and traffic control.
Graceful Response is a Spring Boot library that provides unified response wrapping, global exception handling, and customizable error codes, reducing boilerplate code, improving readability, and streamlining validation for Java web APIs.
Learn how to integrate Spring Boot WebFlux with R2DBC for reactive database operations, covering R2DBC basics, driver selection, configuration, entity and service implementation, controller endpoints, repository usage, optimistic locking, and practical code examples to build high-performance, non-blocking backend applications.
This guide explains how Spring Boot 3.2 leverages the OpenJDK CRaC project to create and restore JVM checkpoints, dramatically reducing application startup time through automatic and manual checkpoint techniques, complete with required dependencies, installation steps, and performance results.
This article provides a step‑by‑step guide on integrating Spring Batch with Spring Boot, covering business scenarios, database setup, Maven dependencies, configuration of JobRepository, JobLauncher, Job, Step, ItemReader, ItemProcessor, ItemWriter, listeners, validators, execution via REST endpoints, troubleshooting with Druid and switching to HikariCP, and demonstrates processing CSV and database data in large batches.
This article explains the concept of idempotency, outlines common strategies, and provides a complete Spring Boot implementation that uses Redis, a custom @AutoIdempotent annotation, token generation, and a web interceptor to ensure each API request affects the database only once.
This tutorial walks through advanced Spring Cloud Function features—including handling HTTP request parameters, function mapping and filtering rules, functional bean definitions, visualization via Actuator, and package scanning—providing code examples and configuration tips for Spring Boot 2.7.15 projects.
This article walks through the complete process of adding Dataway to a Spring Boot application, covering Maven dependencies, configuration properties, database schema creation, data source setup, Hasor module integration, enabling Hasor in Spring, and finally creating and testing API endpoints using both SQL and DataQL, all illustrated with concrete code snippets and log output.
This article explains the underlying principles and step‑by‑step configuration for integrating Spring Boot with MyBatis to manage multiple data sources, covering BeanFactory, FactoryBean, SqlSessionFactoryBean setup, datasource properties, mapper scanning, and sample controller code for accessing distinct databases.
This article explains the Spring MVC return‑value handling mechanism, demonstrates how to implement a custom HandlerMethodReturnValueHandler, register it correctly in a WebMvcConfigurer, and troubleshoot why the default processor may override custom handlers.
Graceful Response is a Spring Boot component that unifies response wrapping, global exception handling, and custom error codes, helping developers reduce boilerplate, improve readability, and accelerate API development while supporting validation and customizable response styles.
This article demonstrates how to enable and use Coordinated Restore at Checkpoint (CRaC) in Spring Boot 3.2 with the Spring Petclinic example, covering required dependencies, JVM setup, automatic and manual checkpoint creation, performance measurements, and best‑practice considerations for backend developers.
Redis serves as a powerful in‑memory key‑value store for distributed caching, offering various data structures, persistence options, deployment modes, eviction policies, and update strategies, while addressing consistency challenges, cache miss scenarios, and failure modes such as penetration, breakdown, and avalanche.
This tutorial demonstrates how to create a universal CSV/Excel export utility in Java that can handle objects of any class by using reflection to generate headers and rows, leveraging Apache POI and Spring Boot for seamless file generation.
This article explains why caching is crucial for Spring Boot applications, examines its impact on microservice architectures, outlines criteria for selecting the right cache—usability, speed, availability, observability—and compares local, distributed, and hierarchical caches with practical strategies and code examples.
This article provides a detailed overview of Druid, a high‑performance Java database connection pool, covering its core concepts, Maven dependencies, extensive configuration options, monitoring filters, SQL slow‑query logging, and methods to customize or remove the built‑in advertisement page.
This article explains how to implement unified exception handling in Spring Boot applications using @ControllerAdvice, custom Assert utilities, and enum-based error codes, demonstrating code examples, response structures, and best practices for reducing try-catch clutter, improving readability, and handling various HTTP and business exceptions consistently.
This article explains how Spring Boot packages applications as executable Fat JARs, embeds a web server, uses a special launcher, and defines a main class so the JAR can be run with a simple java -jar command, eliminating the need for separate deployment servers.
This guide explains how to use Spring's ResponseBodyAdvice to create a unified response wrapper for RESTful APIs, improving consistency, readability, and extensibility while handling common pitfalls such as String return type errors.
This tutorial introduces Spring Cloud Function, explains its core concepts and benefits for serverless development, and walks through a complete example—including configuration, code snippets, HTTP endpoints, function composition, custom routing, and deployment—so readers can quickly build and test function‑based applications.
This article explains how to achieve automatic request idempotency in Spring Boot applications by using Redis for token storage, custom @AutoIdempotent annotation, and a web interceptor that validates tokens, providing code examples, configuration steps, and testing procedures.
This guide explains RabbitMQ fundamentals—including brokers, virtual hosts, connections, channels, exchanges, queues, producers, and consumers—covers common messaging patterns, provides step‑by‑step Java code for creating connections, declaring exchanges and queues, publishing and consuming messages, handling acknowledgments and confirmations, and shows how to integrate RabbitMQ with Spring Boot.
This article explains the three JVM termination modes, how to use shutdown hooks and Spring's lifecycle events to implement graceful shutdown of HTTP, RPC and MQ entry points, manage thread‑pool termination, and avoid resource‑leak or inconsistent state during service redeployment.
This tutorial explains how to extend Spring MVC's HandlerMapping by implementing a custom RequestCondition that matches requests based on an x-token header and a custom @AKF annotation, covering code implementation, configuration, testing, and the underlying request‑matching mechanism.
This guide explains Druid's core concepts, how to add Maven dependencies, configure properties, enable monitoring filters, customize the admin servlet, remove built‑in ads, and retrieve runtime statistics, providing a complete tutorial for integrating Druid with Spring Boot applications.
The article explains that Spring Boot 3.x drops support for Java 8, causing IntelliJ IDEA’s Spring Initializr to list only JDK 17 or higher, and shows how developers can still create Java 8 Spring Boot projects by switching the Initializr URL to Alibaba Cloud’s start service.
This article demonstrates how Spring Boot 3.2 leverages the OpenJDK CRaC project to dramatically cut application startup time, covering required JVM, dependencies, Zulu JDK setup, automatic and manual checkpoint creation, performance benchmarks, and restoration steps, all using the Petclinic example.
This article introduces Resilience4j, a lightweight fault‑tolerance library for Spring Boot, explaining its core decorators—CircuitBreaker, TimeLimiter, Bulkhead, and RateLimiter—along with configuration examples, annotation usage, fallback handling, and practical test code to improve system stability and resilience.
This article evaluates the startup speed, memory consumption, and request‑handling performance of a simple Spring Boot "Hello World" service when run on the traditional JVM compared with a GraalVM‑compiled native binary, using a MacBook M1 and Bombardier for load testing.
This tutorial demonstrates how to prompt Tencent Hunyuan’s large‑model API to generate a Spring Boot project configured for MySQL, create a user table, and implement full JPA‑based CRUD layers—including entity, repository, service, and REST controller—while addressing common null‑field errors and testing the endpoints.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.
This guide explains how to create a Spring Boot custom HTTP message converter and argument resolver, register them, and use a @Pack annotation to parse a simple 'name:张三,age:20' request body into a Users object, enhancing backend flexibility.
This article provides a thorough overview of Java interview topics, covering core language fundamentals, collection frameworks, concurrency mechanisms, Spring Boot transaction handling, database indexing strategies, and network protocol comparisons, all presented in clear English with code examples and diagrams.
This article demonstrates how to implement unified user login permission checks, centralized exception handling, and consistent response formatting in Spring Boot using AOP, HandlerInterceptor, @ControllerAdvice, and ResponseBodyAdvice, providing step‑by‑step code examples and configuration details.
This article explains the CQRS architectural pattern, its benefits and challenges, and provides a step‑by‑step guide to implementing CQRS, event sourcing, and asynchronous communication with Spring Boot, Axon, and Apache Kafka in microservice environments.
This article explains how to create a reusable Maven archetype for Spring Boot applications, covering the definition and benefits of scaffolding, step‑by‑step template preparation, archetype generation, artifact adjustments, publishing to a repository, and using the scaffold to quickly start new microservice projects.
This article explains how to combine Spring AOP and Spring Security in a Spring Boot 2.7.12 application to implement permission verification, covering concepts, required dependencies, custom filters, annotations, aspect logic, global exception handling, test endpoints, JWT token handling, and extensions for SpEL‑based role checks.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, guiding you through installation, configuration, sample code, and performance benefits of running a Spring application on virtual threads and native compilation.
This article provides a comprehensive guide to Flowable, a Java-based BPMN 2.0 workflow engine, covering its concepts, BPMN elements, installation, configuration, code examples, and database schema, enabling developers to design and implement employee leave approval processes.
This article explains how to use Spring Boot's YAML configuration files to define and manage simple properties, collections, maps, nested objects, and complex data structures, providing code examples and a complete sample to help developers efficiently handle intricate configuration scenarios.
Spring Boot 3.2, released shortly after Java 21, brings a host of enhancements such as virtual thread support, CRaC checkpoint restore, SSL bundle reloading, improved observability, new RestClient and JdbcClient, Jetty 12, Pulsar, Kafka and RabbitMQ SSL, redesigned nested JAR handling, Docker image build upgrades, and a comprehensive video walkthrough by Josh Long.
This article explains every Spring Boot startup event, from ApplicationStartingEvent to ApplicationFailedEvent, showing when each occurs, how to customize them, and providing clear code examples to help developers extend and debug their applications effectively.
This guide explains how to implement read‑write separation in Spring Boot applications by configuring master and slave databases, creating dynamic routing data sources, using custom annotations and AOP, integrating HikariCP and MyBatis, and handling thread‑local context for optimal performance.
This article explains how to enable and configure Spring Boot's @Async annotation, provides code examples for thread‑pool setup and asynchronous service methods, and discusses important caveats such as calling async methods from the same class, transaction incompatibility, blocking issues, and exception handling.
This tutorial walks you through adding MongoDB dependencies to a Spring Boot project, configuring the connection, defining entity and repository classes, implementing service and controller layers, and optionally setting up sharding or replica‑set architectures for scalable data management.
This article explains how to implement a memory-efficient sign-in system and continuous-sign-in statistics using Redis BitMap, covering basic BitMap commands, Spring Boot integration, core source code, and a BitMap-based approach to mitigate cache-penetration attacks.
This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, configure Maven and Tomcat, implement REST endpoints, run JMeter load tests, and compare response times between traditional and virtual threads to showcase significant performance improvements.
Redis Sorted Sets, powered by skip lists, provide O(log n) operations for ranking and range queries; this article explains their internal structure, core commands, and demonstrates how to implement a real‑time leaderboard in Spring Boot using Redis, complete with configuration, entity design, and service methods.
This article explains the concepts of pessimistic and optimistic locking, compares their use cases, demonstrates version‑based and CAS implementations, and shows a complete Spring Boot example with retry‑enabled optimistic lock handling using AOP and custom annotations.
This article explains the concept and inner workings of Spring Boot Starters, demonstrates how they simplify dependency management and auto‑configuration, and provides a step‑by‑step guide to creating and using a custom Starter with full code examples.
This article compares Spring Boot and Quarkus, detailing their architectures, reactive capabilities, native image support, and performance metrics from JMeter and VisualVM tests, while also offering migration guidance for developers moving from Spring to the Kubernetes‑native Quarkus framework.
This article compares Spring Boot and Quarkus across startup time, memory usage, CPU consumption, and response latency, presents benchmark results from JMeter and VisualVM tests, and provides practical guidance for migrating Java developers from Spring to the cloud‑native Quarkus framework.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, bundling a local JRE, and creating a user‑friendly installer with Inno Setup, providing step‑by‑step screenshots and configuration details for non‑technical end users.
Spring Boot 3.2 introduces Java 21 virtual thread support, SSL hot‑reload for embedded servers, GraalVM native image improvements, and a preview of Spring AI, marking a major evolution for Java backend development and performance optimization.
This article explains how to simplify Spring MVC interface calls by defining custom annotations, implementing a custom HandlerMapping, configuring it in Spring Boot 2.6.12, and demonstrating usage with example code, while also covering related handler adapters and underlying principles.
This step‑by‑step guide shows how to download, configure, and launch SkyWalking with Spring Boot, connect it to Elasticsearch, instrument a sample service and Redis calls, and view real‑time monitoring data through the SkyWalking UI and Kibana.
This article explains how to enable and configure Spring Boot's @Async annotation, demonstrates proper thread‑pool setup, highlights common mistakes such as calling async methods within the same class or mixing with @Transactional, and provides guidance on handling blocking tasks and exceptions for robust asynchronous execution.
This article compares Spring Boot and Quarkus, detailing their architectures, performance benchmarks—including startup time, memory usage, CPU, and response latency—both in JVM and native modes, and provides guidance on migrating Spring applications to Quarkus with code examples and best‑practice tips.
This article explains why Elasticsearch is fast, outlines its key features, and provides a complete Spring Boot 2.4 tutorial—including dependencies, configuration, data model, repository usage, and test code—for building a distributed search service.
This article explains why a Spring Boot application runs with the configured port when packaged as a JAR using the embedded Tomcat, but switches to Tomcat's default port and context path when deployed as a WAR, and provides step‑by‑step instructions to package and deploy both formats along with historical context and technical differences.
Anson from Tencent Cloud describes how the 微搭 low‑code platform uses a hybrid‑cloud architecture that separates public‑cloud design from private‑cloud deployment, employing a split‑able micro‑service design that can be merged into a single pod, cutting resource usage by up to 90 % and eliminating version‑related O&M issues.
This article explains the concept of open interfaces and signature verification, outlines the end‑to‑end signing and verification flow, and provides a complete Spring Boot implementation including configuration properties, a signature manager, custom annotation, AOP aspect, request‑caching filter and utility classes, all illustrated with code snippets.
This article explains how to use Debezium's change data capture (CDC) capabilities to monitor MySQL binlog events, compares Canal and Debezium, outlines typical CDC use cases, and provides a complete Spring Boot integration guide with configuration, code examples, and testing procedures.
This article compares the Spring Boot and Quarkus Java frameworks by examining their architectures, running reactive test applications, measuring startup time, memory usage, CPU consumption and response latency for both JVM and native builds, and provides practical guidance for migrating Spring developers to Quarkus.
Learn how to implement comprehensive parameter validation in Spring Boot 2.6.12 using JSR‑303 Bean Validation, covering simple checks, validation groups, single‑parameter validation, nested objects, custom utilities, internationalization, and unified AOP‑based handling with practical code examples and configuration steps.
This guide explains Spring Validation in Spring Boot 2.6, covering its lightweight features, configuration of Bean Validation providers, injection of validators, practical examples, custom annotation creation, method‑level validation, and additional configuration options with clear code samples.
This article explains how to integrate Lua scripts into Spring Boot projects for Redis, covering Lua fundamentals, performance benefits, practical use cases, step‑by‑step implementation with code examples, error handling, security considerations, and best‑practice recommendations for backend developers.
This guide walks through adding Camunda 7 to a Spring Boot project, covering Maven dependencies, configuration files, database schema, BPMN modeling, task types, gateways, API usage, variable handling, listeners, and deployment, providing a complete end‑to‑end workflow solution.
This article introduces Java virtual threads, compares them with traditional platform threads, demonstrates multiple creation and execution patterns, showcases performance benefits through code examples, and explains structured concurrency as a preview feature for building high‑throughput, scalable backend applications.
After migrating a project to the MDP framework based on Spring Boot, the author observed swap overuse and physical memory far exceeding the 4 GB heap; using JVM native memory tracking, gperftools, strace, pmap, and a custom allocator, they traced a native‑memory leak to Spring Boot’s ZipInflaterInputStream during JAR scanning and resolved it by limiting scan paths.
This guide explains why and how to encrypt sensitive information in Spring Boot configuration files using Spring Cloud's built‑in encryption, Jasypt, command‑line parameters, and demonstrates the underlying implementation classes for secure application deployment.
This article explains Spring Boot's auto‑configuration mechanism, covering how @EnableAutoConfiguration loads configuration classes, the role of @AutoConfigurationPackage and @Import, the processing of spring.factories and metadata files, and how the main application class is registered in the IoC container.
This article introduces Redisson, a Java framework built on Redis for distributed systems, detailing its extensive features such as distributed objects, locks, rate limiters, and task scheduling, and provides step‑by‑step guidance on integrating Redisson’s distributed lock into Spring Boot applications with code examples.
This guide explains how to use Spring's Formatter SPI and AnnotationFormatterFactory to create, register, and test custom type converters and annotation‑based formatters in a Spring Boot 2.6.12 application, complete with code samples and endpoint demonstrations.
This article introduces Easy-Es, a Java ORM framework built on Elasticsearch's RestHighLevelClient that simplifies query construction and CRUD operations, provides step‑by‑step setup including Maven dependencies, configuration, entity and mapper definitions, controller examples, and advanced features such as condition builders, index management, logging, and aggregation queries.
This tutorial demonstrates how to integrate Activiti workflow engine event listeners into a Spring Boot application, covering task assignment, task completion, and process completion events with code examples, testing steps, and important configuration details.
This guide shows how to extend a Spring Boot application with Activiti to query historic process data, generate highlighted process diagrams, and expose endpoints that display real‑time workflow progress, including code snippets for service methods, configuration, utilities, and a controller for image rendering.
Explore the fundamentals and advanced techniques of asynchronous programming in Java, from basic thread creation and thread pools to Future, FutureTask, CompletableFuture, and Spring Boot’s @Async annotation, including practical code examples, event handling, and message queue integration for high‑throughput systems.
The article details a week‑long investigation of a sandbox environment where Spring Boot APIs became unresponsive due to Redis connection pool blocking, describing the use of system tools, JVM thread analysis, and code inspection to identify mis‑configured pool settings and recommending proper connection handling with Spring's RedisTemplate.
