This article explains how to improve PostgreSQL IN‑query performance in Spring Boot applications by splitting large IN parameter lists into smaller batches, executing them concurrently with a custom AOP annotation, and merging the results, providing a reusable annotation‑driven solution for high‑throughput backend services.
This guide shows how to integrate the Drools rule engine into a Spring Boot application to calculate e‑commerce discounts dynamically, covering Maven dependencies, configuration, model definitions, DRL rule creation, service and controller layers, and a simple test scenario demonstrating rule‑driven discount computation.
This article explains how to use Spring Boot's @Import annotation to modularize a monolithic application by splitting functionality into Maven modules, configuring component scanning, creating custom annotations, and leveraging ImportSelector and ImportBeanDefinitionRegistrar for dynamic bean registration and conditional loading.
This tutorial demonstrates how to implement flexible, module‑aware operation logging in Spring Boot 3 by combining custom @Log annotations, AOP aspects, and Spring Expression Language (SpEL) to capture dynamic data such as usernames, product names, and order totals.
This article presents a comprehensive guide to designing and implementing fine‑grained permission control for microservices using Apache Shiro, covering the architectural design, shared session handling with Redis, custom cache and session managers, realm implementation, and practical testing across user and video services.
This article explains why a private method in a Spring Boot @RestController cannot have its @Autowired service injected when an AOP aspect is present, demonstrates the issue with code examples, and clarifies the underlying proxy mechanism that causes the null‑pointer error.
This article explains how Spring AOP creates proxies using JDK dynamic proxies or CGLIB, outlines the limitations of each approach, and shows multiple ways—including XML, YAML, and annotations—to force CGLIB usage and resolve self‑invocation issues in Spring Boot applications.
This article explains the concept of idempotency, identifies which HTTP operations are naturally idempotent, describes why idempotency is needed in scenarios like timeout retries, async callbacks and message queues, and provides a complete Spring Boot implementation using a custom annotation, Redis storage, AOP interception, token generation and example controllers.
mica-mqtt is a simple, low-latency, high-performance open-source MQTT component built on Java AIO, supporting MQTT v3.1, v3.1.1, v5.0, WebSocket, HTTP API, client/server modes, clustering via Redis Stream, and easy integration with Spring Boot, Solon, and JFinal for diverse IoT and messaging scenarios.
This article introduces the Magic‑API framework for Java, explains its extensive features, walks through environment setup, dependency configuration, and demonstrates real‑world use cases such as data source management, pagination, SQL, MyBatis, HTTP calls, Redis integration, and inline Java execution within a Spring Boot 3 project.
This guide walks through installing the kkfileviewer container using Docker, building and running its image, then shows how to add MinIO support to a Spring Boot project by configuring dependencies, creating configuration and utility classes, and exposing upload and preview endpoints.
This article provides a comprehensive guide to data validation in Spring Boot 3, covering Bean Validation annotations, controller and service‑layer checks, JPA entity validation, custom constraints, validation groups, programmatic validation, and internationalized error messages with practical code examples and tests.
This article explains seven practical methods for loading property files in Spring Boot, covering default locations, external files, classpath resources, profile‑specific files, custom @PropertySource usage, and overriding via environment variables or JVM system properties.
This article explains multiple ways to apply a common URL prefix to all Spring Boot controllers, covering servlet‑context configuration, property settings, annotation‑based approaches, server‑side forwarding, and Nginx reverse‑proxy techniques, with code samples and discussion of their advantages and drawbacks.
This comprehensive guide explains what XXL-JOB is, why distributed task scheduling is needed, and walks through installing XXL-JOB with Docker, configuring it in a Spring Boot project, creating custom jobs, handling sharding, ensuring idempotency, and monitoring execution, all illustrated with code and diagrams.
This article demonstrates how to generate, store, and validate login tokens for both PC and mobile clients in a distributed micro‑service architecture using Spring Boot, Redis, custom annotations, AOP verification, and a Vue front‑end that manages token lifecycle and expiration.
This article walks through five practical Spring Boot 3.2.5 enhancements—including collection‑parameter validation, wildcard @PropertySource loading, improved method injection, custom thread‑pool scheduling, and robust Number‑type request handling—showing code examples, console output, and migration tips from older versions.
This article explains why the default Spring Boot show_sql setting only prints SQL to the console, demonstrates its limitations, and provides a reliable approach using Hibernate logging and a datasource‑proxy to capture full SQL statements, parameters, and batch execution details in log files.
This guide explains how to eliminate manual registration of XXL‑Job executors and job handlers by creating a Spring Boot starter that automatically registers them to the XXL‑Job admin console, covering analysis, code implementation, configuration, and testing steps.
This guide explains how to enable comprehensive request logging, use request/response wrappers, implement once‑per‑request filters, and define clean controller interfaces in Spring Boot 3.2.5, providing code examples and configuration tips for robust backend development.
A detailed post‑mortem of a three‑time service outage reveals how hidden bugs, frequent FullGC, a saturated connection pool, and an unindexed slow SQL query crippled a Spring Boot backend, and shows the step‑by‑step troubleshooting, temporary fixes, and lasting improvements applied.
This guide walks through initializing a Spring Boot project, handling IDE licensing hurdles, ensuring compatible Spring Cloud, Spring Boot, and Kafka versions, leveraging Maven for dependency management, and integrating essential utilities like global exception handling, logging, CORS, Swagger, and helpful development tools.
This article explains why excessive if‑else statements hurt Spring Boot code and presents six practical techniques—including strategy pattern, enums, polymorphism, lambda expressions, command pattern, and guard clauses—along with complete Java examples to make your backend more modular, readable, and maintainable.
This article explains how Spring Boot's request capacity is determined by Tomcat's configuration parameters, demonstrates the impact of min‑spare, max threads, max‑connections, and accept‑count through a small example, and discusses concurrency pitfalls caused by singleton beans.
This article walks through the complete troubleshooting process for a non‑functional logback‑spring.xml in a Spring Boot application, covering background, configuration steps, common pitfalls such as variable resolution and dependency conflicts, remote debugging techniques, and final recommendations to ensure proper log output.
This article explains why @Configuration classes can cause circular dependency and custom BeanPostProcessor issues in Spring Boot, and provides practical solutions such as enabling circular references, using static @Bean methods, and preferring constructor injection for reliable bean injection.
This guide walks through creating custom FailureAnalyzers, registering EnvironmentPostProcessors, configuring non‑web applications, switching profiles for YAML settings, altering the embedded web server, and customizing server factories in Spring Boot 3.2.5, complete with code examples and screenshots.
Spring Boot 3.3.1 introduces a comprehensive set of bug fixes, documentation updates, and numerous dependency upgrades, while also warning that the 3.0‑3.1 series has reached end‑of‑life, urging developers to migrate to the latest version for continued support.
This article demonstrates how a custom event published from a constructor in Spring Boot 3.2.5 can cause a deadlock, explains the underlying lock contention, and provides two solutions: using SmartInitializingSingleton to defer publishing and upgrading to Spring 6.2's multithreaded bean initialization.
This article explains what Java Class Data Sharing (CDS) is, provides detailed commands for training and using a CDS archive with a Spring Boot demo, and shows how startup time can be cut by nearly one second, helping developers choose the right Java startup optimization technique.
This article explains three common multi‑tenant implementation strategies—separate databases, separate schemas, and partitioned (discriminator) data—detailing their advantages, drawbacks, and practical Spring Boot 3.3 code examples for entity definition, tenant‑ID resolution, data source routing, and request interception to achieve secure, scalable SaaS applications.
This article explains the drawbacks of using Spring Boot's @Value annotation for configuration injection, demonstrates how @ConfigurationProperties can centralize and simplify config management, and shows how to add validation support for robust application settings.
This article explains the purpose, lifecycle, and configuration of Java Servlet Filters and Spring MVC Interceptors, compares their execution order with Spring AOP aspects, provides complete code examples for each component, and offers guidance on choosing the right mechanism for specific business requirements.
Learn how to configure Spring Boot 3.2.5 to let a single controller endpoint dynamically produce JSON, XML, or custom YAML responses using Accept headers, request parameters, path extensions, and custom HttpMessageConverters, with step‑by‑step code examples and necessary Maven dependencies.
This article walks through a Spring Boot solution for dynamically masking sensitive user data—such as names, ID numbers, phone numbers, and custom fields—by defining custom annotations, a configurable rule engine, a Redis‑backed context holder, and a Jackson serializer that applies masking at JSON serialization time, all while keeping performance overhead low.
This article walks through creating a server‑side license‑plate recognition system using Spring Boot 3.x, the open‑source Tesseract OCR library, and OpenCV for image preprocessing, covering project goals, Maven dependencies, core service implementations, special‑plate handling, and a REST API controller.
This article demonstrates how to integrate Spring Boot with Minio, compare uploading files via the backend versus direct client uploads with presigned credentials, and provides complete code examples for environment setup, configuration, presign endpoint, front‑end upload logic, chunked uploads, and server‑side file merging.
This guide walks you through installing Spring Boot Admin 3.2.3, configuring both server and client sides, securing the dashboard with Spring Security, and customizing the UI with external links, dropdown menus, and branding.
This article explains the key differences between Spring's @Validated and @Valid annotations, covering their origins, support for group validation, nested property handling, usage in Spring MVC, practical code examples, custom annotations, and the underlying validation mechanism.
This article walks through the five core Spring Boot extension points—ApplicationContextInitializer, ApplicationListener, Runner, BeanFactoryPostProcessor, and BeanPostProcessor—showing how they are discovered via SPI, where they are invoked in the startup flow, and how to implement and register custom extensions.
This guide explains why Docker is essential for Java developers and provides step‑by‑step best practices—including selecting the right base image, using multi‑stage builds, environment variables, health checks, Docker cache, .dockerignore files, and image labels—complete with ready‑to‑use Dockerfile examples for Spring Boot projects.
This article explains the principles of Spring Boot startup configuration, demonstrates how to intervene using ApplicationContextInitializer, SpringApplicationRunListener, ApplicationRunner, and CommandLineRunner, and provides practical optimization tips such as reducing dependencies, adjusting auto‑configuration, enabling lazy loading, compile‑time optimizations, log level tuning, and caching to speed up application startup.
This guide explains how to customize Spring Boot's default error handling—including enabling RFC‑7807 problem details, extending BasicErrorController, using @ControllerAdvice for JSON responses, creating custom HTML error pages, and registering error pages directly with the embedded servlet container.
This article explains the default Tomcat settings bundled with Spring Boot 2.7.10, details core parameters such as connection queues, thread pools, keep‑alive limits, and timeouts, and demonstrates how to monitor and test these settings with code examples and network tools.
The Spring Boot 3.2.3 update introduces Hibernate 6.4.4, advises GraalVM users to downgrade to 6.4.2, lists numerous bug fixes, upgrades dozens of dependencies, and notes that the PIG microservice now runs on SpringBoot3.2.3 and SpringCloud 2023.
This article introduces LiteFlow, a lightweight yet powerful rule engine that enables rapid development of complex workflow orchestration through XML/JSON/YAML rule files, supports various component types, data context handling, and hot‑deployment, and provides a complete Spring Boot integration example.
This tutorial explains how Redis optimistic locking works, demonstrates the WATCH, MULTI, EXEC, and DISCARD commands with live examples, and shows how to integrate the mechanism into a Spring Boot application using retry logic to handle concurrent updates safely.
This article explains how to package a Spring Boot application so that its dependencies are stored externally and loaded at runtime using Maven plugins and the PropertiesLauncher, enabling easy replacement of individual libraries without rebuilding the entire fat jar.
This article demonstrates how to create a customizable permission‑checking mechanism in Spring Boot by defining a @PreAuth annotation, an AOP aspect, and leveraging Spring Expression Language (SpEL) to express complex access rules such as role, time, and permission constraints.
This article demonstrates how to integrate Spring Boot with Redis to implement personal search‑history storage, a hot‑search ranking feature, and a DFA‑based sensitive‑word filtering mechanism, providing complete Maven dependencies, configuration, utility classes, service logic, and controller endpoints.
This guide shows how to eliminate manual SpringBoot Controllers by using the Lego‑Starter to automatically expose CommandService and QueryService as web endpoints, integrate with Swagger for dynamic API documentation, and provides step‑by‑step setup, code examples, and architectural design for unified controller handling.
This guide explains how to use Spring Boot configuration files and runtime APIs to change log levels on the fly, covering basic log level concepts, a practical controller example, dynamic endpoint implementation, disabling logs, and Spring Cloud integration for flexible logging management.
This article compares the delayed double‑delete method with an asynchronous binlog‑subscription approach using Canal and RabbitMQ, explaining their workflows, pitfalls, and code implementations for maintaining cache and database consistency under high concurrency.
This guide explains how to implement a dynamic feature‑toggle for Spring Boot API endpoints using custom annotations, resolver interfaces, and an AOP aspect, enabling flexible control, safety, logging, monitoring, and user‑friendly fallback responses.
This article demonstrates how to use Spring Boot 3.2 together with Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step setup, configuration, and code examples for controllers, async tasks, scheduled jobs, and native compilation.
Idempotency ensures that repeated requests produce the same outcome without side effects, and this article explains its concepts, necessity in microservices, relationship with concurrency, and presents six practical implementation methods—unique indexes, token, pessimistic and optimistic locks, distributed locks, and state machines—complete with Java Spring Boot code examples.
This article enumerates and explains sixteen Spring and SpringBoot extension interfaces, illustrates their positions in the bean lifecycle with a call‑order diagram, and provides concrete usage scenarios and code samples so developers can harness these hooks to write more elegant and maintainable applications.
This article explains the fundamentals of the Spring framework and its ecosystem—including Spring Boot, Spring Cloud, and Spring Cloud Alibaba—detailing their core concepts, advantages, and how they interrelate to simplify Java enterprise and micro‑service development.
This guide demonstrates how to leverage Spring Cloud Gateway's ProxyExchange utility in both Spring MVC and WebFlux applications, showing code examples for proxying requests, extracting path variables, adding headers, handling responses, and configuring sensitive headers.
This article outlines Java 21’s release as the next LTS, highlights its new standard, preview, and incubating features—including virtual threads, record patterns, and the Vector API—and provides a concise timeline of major enhancements from Java 8 through Java 20.
The article introduces mica‑mqtt, a simple, low‑latency, high‑performance Java AIO MQTT library for IoT, outlines its rich feature set, shared‑subscription modes, typical use cases, recent updates, and provides step‑by‑step Spring Boot and non‑Spring Boot integration examples with configuration and code snippets.
This guide walks you through Spring 6.1's new RestClient, covering project setup, global client creation, data retrieval, posting, deletion, error handling, and advanced exchange methods with clear code examples for modern Java backend development.
This article explains the default Tomcat configuration bundled with Spring Boot 2.7.10, details key parameters such as accept‑count, max‑connections, thread pool sizes and timeouts, shows how Tomcat’s internal threads work, provides sample YAML configurations and testing results, and offers practical tuning guidance for Java backend services.
Spring Cloud 2023.0 (Leiden) milestone, built on Spring Boot 3.2, introduces updated dependencies, repository configurations, and early support for MVC Server in Spring Cloud Gateway, enhanced Kafka Streams handling in Spring Cloud Stream, Java HttpClient in OpenFeign, and upgraded Kubernetes integration, with source code and deployment links provided.
This article explains the differences and proper usage of Java validation annotations such as @NotNull, @NotBlank, @NotEmpty, and compares @Valid with @Validated in Spring Boot applications, providing code examples and import details for effective data validation.
This article presents retrofit-spring-boot-starter, a lightweight Spring Boot starter that simplifies HTTP calls by integrating Retrofit with customizable OkHttpClient, annotation‑driven interceptors, logging, retry, circuit‑breaker, error decoding, and flexible converters, along with detailed usage examples and configuration guidelines.
This article explains how to build a three‑layer cache architecture for Spring Boot by integrating Redis as a distributed cache with Caffeine as a local cache, covering configuration, custom CacheManager implementation, message‑driven synchronization, and practical usage examples.
Spring Cloud 2022.0.4 has been released on Maven Central, built on Spring Boot 3.0.9, and introduces major changes such as discontinued CLI and Cloudfoundry support, migration of Sleuth to Micrometer Tracing, numerous OpenFeign and Netflix updates, plus a full list of updated modules and their versions.
This tutorial explains how to restrict client access to specific APIs within a time window using Spring Cloud Gateway and Redis, covering the concept, implementation options, and complete code examples for a Redis‑backed rate limiter.
This article explains how Spring Cloud OpenFeign discovers @FeignClient interfaces, registers them as beans, configures FeignClientFactoryBean, selects the appropriate HTTP client implementation, and integrates load‑balancing through FeignBlockingLoadBalancerClient and related classes.
This guide demonstrates how to implement a one‑write‑multiple‑read data source strategy in Spring Boot 2.2 using AOP, configurable pointcuts, custom routing, load‑balancing algorithms, and a reusable starter that can be packaged as a Maven jar.
This guide walks through setting up a Spring Boot 2.2.11 environment with Activiti 7.1, configuring Maven dependencies, explaining the Activiti database tables, defining a BPMN leave‑request process, implementing service and controller layers, and demonstrating API calls to deploy, start, query, and complete the workflow.
Spring Boot 3.1.1, now on Maven Central, brings 89 bug fixes, documentation enhancements, and a comprehensive upgrade of 40+ dependencies, providing developers with improved stability and compatibility across the Spring ecosystem.
This guide walks you through building a Spring Authorization Server using the SAS starter, configuring clients, testing token endpoints, and integrating a resource server, all with minimal setup and Maven dependencies for Spring Boot 3.x.
This article introduces Sa-Token, a lightweight Java permission authentication framework, explains its core features such as login, token handling, permission and role checks, demonstrates practical code snippets, and provides step‑by‑step integration guides for Spring Boot and WebFlux projects.
This article recounts the author's real‑world debugging of FastJson, covering unexpected date‑format priority issues on Linux, version mismatches, circular‑reference detection quirks, and practical tips such as disabling specific SerializerFeatures, while also reflecting on the library’s maintenance and migration to FastJson2.
This article provides a comprehensive overview of Spring Batch, covering its purpose, typical business scenarios, core components such as JobRepository, JobLauncher, Job, Step, and core interfaces like ItemReader, ItemProcessor, ItemWriter, followed by detailed code examples for configuration, multi‑step, parallel, decision, nested jobs, data reading, writing, processing, and scheduling using Spring Boot.
This guide demonstrates how to build a Spring Cloud Gateway for microservices, covering system setup, CORS handling, rate‑limiting with the token‑bucket algorithm, password hashing with BCrypt, and secure JWT‑based authentication, complete with Maven dependencies, configuration files, and filter implementations.
This article walks through the background, features, installation, core concepts, and practical code examples of the URule rule engine, showing how to configure variable, constant, parameter, and action libraries, create decision tables and rule sets, and integrate the engine with a Spring Boot application.
This guide walks you through using the Dubbo Initializer web UI to quickly generate a ready‑to‑run Dubbo Spring Boot microservice project, covering version selection, project metadata, module structure, dependency choices, code generation, download, and a brief walkthrough of the generated source files.
This article explains what circular dependencies are in Spring Boot, why they cause startup failures from version 2.6 onward, and presents several practical solutions—including constructor injection, setter injection, @Lazy, @Autowired(required=false), @DependsOn, and interface segregation—accompanied by code examples.
The article presents magic-api, a Java-based rapid API development framework that lets developers create HTTP interfaces through a visual UI without writing traditional controller, service, DAO, or XML code, and provides features, quick‑start instructions, and resource links.
This article explains how Spring Retry's @Retryable and @Recover annotations provide a clean, annotation‑driven way to handle common retry scenarios such as message failures, remote service errors, and lock acquisition issues, while outlining configuration steps, parameter meanings, and important usage cautions.
This tutorial walks through using Spring Boot with Elasticsearch's Java High Level REST Client, covering project setup, dependency configuration, client creation, index mapping, data insertion, various search techniques, and aggregation analysis, all with complete code examples.
This guide explains how Spring Boot 2.7.10 serves static files, how to customize resource locations and URL patterns, configure WebJars, enable cache‑busting, and reveals the underlying MVC components that handle static resource requests.
This article explains why Spring Boot is popular, how @ComponentScan discovers @Component, @Controller, @Service, and @Repository beans across packages, demonstrates usage with code examples, and details the internal processing flow involving ConfigurationClassPostProcessor and related parsers.
This article explains why Apollo configuration stops working after switching from @Value to @FeignClient in a Spring Boot project, analyzes the loading order of Spring's configuration mechanisms, and shows how to adjust the bootstrap settings to resolve the issue.
This guide explains how to add the spring-boot-startup-report library to a Spring Boot project, generate interactive HTML startup reports with bean details and flame graphs, view them during runtime or integration tests, and configure the dependency for production or test scopes.
This article explains how to handle 2 GB video uploads by splitting files into chunks, using breakpoint resume and instant transfer techniques, and leveraging Java's RandomAccessFile together with Spring Boot and Redis to manage upload state, merge chunks, and store the final file.
This article details the Spring Boot startup sequence, including the run() method, creation of listeners, environment loading, application context initialization, and the role of @EnableAutoConfiguration and related annotations in automatically configuring beans and starter components.
This article explains the distinction between Spring Boot’s ApplicationStartedEvent and the traditional ContextStartedEvent, clarifies that Spring Boot defines its own set of events inheriting from SpringApplicationEvent, and lists the core events introduced in Spring Boot 2.0.
This article explains Spring's unified transaction model, the @Transactional annotation, and the various propagation and isolation settings, then details ten typical scenarios—such as missing Spring management, final or private methods, internal calls, wrong propagation, multithreading, and unsupported databases—that cause transactions to fail, providing code examples and solutions to avoid each issue.
This article explains the challenges of sharing HTTP sessions across a clustered backend, evaluates common workarounds, and demonstrates a complete solution using Spring Session backed by Redis together with Nginx load balancing to achieve reliable distributed session consistency.
This guide walks through setting up a Spring Boot 2.7.7 WebFlux project, configuring R2DBC dependencies, defining entity, repository and service layers, writing unit tests, and implementing a full reactive security configuration using WebFlux filters and custom access rules.
This article demonstrates how to build a Spring Cloud Gateway microservice that serves as a centralized authentication and authorization gateway, covering Maven dependencies, YAML configuration, whitelist handling, exception processing, RestTemplate setup, and a custom global filter with code examples.
This article explains how to optimize memory usage and startup time of Spring Boot microservices on a limited-resource server by configuring JVM parameters, installing GraalVM, and building native images with Spring Native and Docker Buildpacks, providing step‑by‑step instructions and code examples.
The article outlines the recent Spring 6.0 release, the cascade of updates across major Spring projects, and previews the upcoming Spring Boot 3.0.0, highlighting the first RC, the new aot.factories feature, and enhanced observability for Java developers.
Learn how to enable Spring Cloud CircuitBreaker in Spring Cloud Gateway using Resilience4j, configure filters, define fallback URIs, customize timeout settings, handle exceptions, and control circuit breaking based on HTTP status codes, with both YAML and Java code examples.
Jeepay is an open‑source payment platform built with Spring Boot and Ant Design Vue that supports multiple payment channels such as WeChat Pay, Alipay, and Cloud QuickPass, offering aggregated QR code payments, robust security, distributed deployment, and comprehensive documentation for developers.
Spring Boot 3.0 RC1 introduces 135 enhancements, native executable support via Maven/Gradle plugins, migration to Jakarta EE 9, Java 17 baseline, and new features such as flexible Spring Data JDBC auto‑configuration, Prometheus example auto‑configuration, and Log4j2 improvements, with full details in the release notes.
