This article introduces Liteflow, a lightweight yet powerful Java rule engine, explains its architecture, shows how to integrate it with Spring Boot, details its component types and EL rule syntax, and demonstrates a real‑world e‑commerce workflow using XML rule files.
This tutorial shows how to create a reusable BaseController in a Spring Boot application using MyBatis‑Plus, providing generic CRUD, list, pagination, and count endpoints for any entity while demonstrating utility methods, pagination configuration, and concrete controller extensions.
This guide explains how to use @PathVariable to capture URL segments, configure static resource mapping for local files, and centralize path values in Spring Boot applications, providing code examples for request mapping, resource handler registration, and property injection.
This article explains four practical ways to control the availability of Spring Boot controller endpoints at runtime—using @ConditionalOnProperty, a custom AOP annotation, a HandlerInterceptor, and a custom RequestMappingHandlerMapping—detailing code examples, configuration, advantages, and trade‑offs.
This tutorial walks through creating a generic BaseController that provides CRUD, list, pagination, and count operations for any entity by adding MyBatis‑Plus, writing a utility class for query building, configuring a pagination interceptor, and extending the base class in concrete controllers, all illustrated with complete Java code snippets.
This article introduces the lightweight retrofit‑spring‑boot‑starter for Spring Boot, explains its key features such as custom OkHttpClient, annotation‑based interceptors, logging, retry, circuit‑breaker support, and shows step‑by‑step configuration, dependency setup, and code examples for building robust HTTP client services.
The article critiques overly large and tangled Spring MVC controllers, demonstrates ugly examples filled with try‑catch blocks, field validations, and business logic, then presents streamlined, elegant alternatives using @Valid, @Autowired, proper exception handling, and best‑practice guidelines to dramatically reduce code size and improve readability.
This guide explains why Spring Boot 3 is incompatible with Swagger 2, shows how to downgrade or replace dependencies, updates servlet imports, adjusts Maven and application settings, and provides a complete Swagger configuration to get the API docs running again.
This article walks through setting up a Java Spring Boot project, managing compatible Spring Cloud, Spring Boot and Kafka versions, handling common dependency pitfalls with Maven, and provides ready‑to‑use scaffolding code for exception handling, logging, CORS, Swagger, and response wrapping, plus a list of useful development tools.
This article explains how Spring Boot 3's BeanWrapper simplifies Java object property manipulation with detailed examples covering basic usage, map binding, nested objects, collections, custom type conversion, HTTP request binding, property access, and metadata extraction.
This guide walks through ten crucial Spring Boot extension points—including global exception handling, custom interceptors, container access, configuration imports, startup runners, bean definition tweaks, initialization hooks, bean post‑processing, graceful shutdown, and custom scopes—providing clear explanations and ready‑to‑use code samples for building resilient backend services.
This article explains practical methods for protecting data exchanged with third‑party systems by using access tokens, timestamps, cryptographic signatures, and anti‑duplicate‑submission techniques, and provides complete Spring Boot code examples for token generation, validation, Redis storage, and request interception.
This article presents five practical approaches to protect Spring Boot 3 API endpoints—including Filter, Interceptor, AOP combined with Filter, Spring Security, and OAuth2 integration—providing code examples, configuration steps, and screenshots to demonstrate authentication, authorization, and token handling for secure access control.
This tutorial walks through integrating Dubbo with Seata in a Spring Boot microservice architecture, showing how to create service interfaces, configure Maven dependencies, set up Nacos discovery, implement distributed transaction logic, test normal and rollback scenarios, and externalize Seata server addresses for scalable deployments.
This article compares messy and elegant Spring Boot controller implementations, demonstrates how to use @Valid for input validation, introduces a concise global exception handler, and provides practical refactoring steps and open‑source resources to dramatically reduce controller code size and improve maintainability.
This tutorial explains how to build a custom Spring Boot starter by detailing the auto‑configuration mechanism, loading custom properties, creating the starter and its pom files, and demonstrating its use in a sample application to simplify configuration and bean creation.
This article analyzes the pain points of manually maintaining common fields in order‑related entities and presents a production‑tested solution that combines MyBatis‑Plus automatic filling, custom AOP annotations, multi‑data‑source handling, distributed ID generation, and auditing to dramatically reduce boilerplate code and bugs.
This article explains how to achieve graceful shutdown for Java applications by using Linux kill signals, JVM SignalHandler registration, Runtime.addShutdownHook, and Spring Boot's actuator shutdown endpoint, providing code examples and configuration details for safe resource cleanup.
This article explains how Spring Boot supports asynchronous request handling after Servlet 3.0, compares four async mechanisms—AsyncContext, Callable, WebAsyncTask, and DeferredResult—provides code examples for each, discusses thread‑pool configuration, and outlines when asynchronous processing improves throughput.
This article demonstrates how to integrate Spring Security into a Spring Boot application, configure JWT‑based authentication, implement custom AES encryption, define user and role entities, set up service and controller layers, and configure security, filter, and CORS settings to achieve secure login and permission management.
Spring Boot 4.0 (SNAPSHOT) introduces built‑in Spring Framework 7.0 support, elegant API versioning via @RequestMapping, flexible bean registration, virtual thread integration for massive concurrency, JSpecify null‑safety annotations, enhanced SPEL, Jackson 3.x migration, servlet upgrades, and native GraalVM image support, all illustrated with code samples.
The article discusses why token transmission is discouraged in microservice authentication, proposes passing explicit parameters, compares Feign, Dubbo, and Spring Boot Web internal call approaches, and explains how to integrate these patterns with a unified gateway, regular authentication modules, and Kubernetes Ingress for scalable backend architectures.
Learn how to implement Spring AI’s Model Context Protocol (MCP) in Spring Boot 3.4.2, enabling dynamic runtime tool updates, configuring MCP server and client, building sample tools with code snippets, and demonstrating add/remove operations and testing via Cline and REST endpoints.
This article presents a comprehensive Spring Boot 3 tutorial that explains how the framework manages database connections, introduces eight built‑in DataSource control methods, and provides detailed code examples for configuring HikariCP, using DataSourceUtils, SmartDataSource, TransactionAwareDataSourceProxy, and transaction managers.
Explore a comprehensive collection of 128 Spring Boot 3 practical examples demonstrating Docker Compose integration, from environment setup and dependency configuration to service lifecycle management, custom compose files, container persistence, and advanced features, enabling developers to effortlessly run MySQL, Redis, and other services without manual configuration.
This article explores Jackson's ObjectMapper in Spring Boot 3, covering basic serialization/deserialization, converting between objects, JSON strings, JsonNode, and collections, custom serializers/deserializers, handling unknown fields, and performance tuning with the Afterburner module and JMH benchmarks.
This article introduces Spring Boot 4.0.0 preview, built on Spring Framework 7, and walks through five major enhancements—including elegant API versioning, flexible bean registration, null‑safety with JSpecify, simplified HTTP proxy creation, plus several other upgrades and deprecations—complete with code samples and screenshots.
This article explains the removal of the spring.factories file in Spring Boot 3, the performance and modularity reasons behind it, introduces the new imports‑based mechanism, provides step‑by‑step migration guidance, and shows how the change improves GraalVM native image support.
This article explains the fundamental distinctions between Spring Boot filters and interceptors—including execution timing, scope, registration methods, request handling, modification capabilities, exception mechanisms, and typical use cases—while providing practical code examples for each.
This tutorial introduces Spring Task, explains how to enable scheduling in Spring Boot, demonstrates creating cron expressions, shows common use cases such as data sync, log cleanup, and email reminders, and provides best‑practice tips for thread‑pool tuning, distributed execution, and avoiding common pitfalls.
This guide shows how to configure Jackson in Spring Boot to consistently format LocalDateTime, Date, and String parameters as "yyyy-MM-dd HH:mm:ss", covering global settings via application properties, field-level @JsonFormat, custom serializers/deserializers, and unified handling in REST controllers.
This tutorial shows how to extend MyBatisPlus with a reusable BaseController, create utility methods for naming conversion and query building, configure pagination support, and quickly generate CRUD REST endpoints in Spring Boot projects using MyBatisPlusPro.
This article explains how Spring Framework 7, bundled in Spring Boot 4.0 snapshot, introduces native API version control via a new `version` attribute on `@RequestMapping`, demonstrates basic and advanced configuration examples, showcases common versioning strategies, and provides testing commands to help developers manage API evolution efficiently.
This article introduces the JSON-RPC 2.0 protocol, demonstrates how to integrate the jsonrpc4j library into a Spring Boot 3.4.2 project, and provides step‑by‑step code examples for defining services, exposing them via beans or annotations, configuring various client proxies, handling errors, and implementing streaming socket communication.
This article provides a comprehensive guide to integrating WebSocket in Spring Boot, covering Javax, WebMVC, WebFlux implementations with detailed server and client configurations, as well as brief introductions to Java‑WebSocket, SocketIO, and Netty libraries, including full code examples.
This article introduces the LiteFlow lightweight rule engine, explains its architecture, component types, EL rule files, data context handling, configuration options, and demonstrates a real‑world e‑commerce workflow with code examples, while also noting related promotional offers at the end.
This article introduces the Mybatis-Plus Generator UI, a highly customizable web‑based code generator that wraps Mybatis‑Plus, explains its features, shows how to integrate it via Maven, run a sample main class, configure generation strategies, customize templates and naming rules, and even extend the frontend with Yarn builds.
This article explains how to implement asynchronous request handling in Spring Boot using four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—detailing their mechanisms, code examples, thread pool configuration, and when to choose async processing to improve throughput.
This article demonstrates how to integrate Project Loom virtual threads into a Spring Boot application, provides the necessary Maven configuration and Java code, runs load tests with JMeter to compare response times against traditional threads, and shows the significant throughput improvements achieved on the same hardware.
This guide explains the difference between one‑way and two‑way SSL/TLS authentication, shows how to generate self‑signed and CA certificates with keytool, configures Spring Boot for mutual authentication, and demonstrates testing the setup using Postman, including detailed steps, code snippets, and troubleshooting tips.
This article explains how to combine Elasticsearch and MySQL in a Spring Boot backend by selecting the technology stack, creating a shared Elasticsearch package, defining ES and MySQL entity classes, implementing repository and mapper interfaces, writing service logic, and demonstrating query testing.
This tutorial walks you through obtaining or generating SSL certificates, configuring Spring Boot to use JKS or PKCS12 keystores, redirecting HTTP to HTTPS, and distributing the certificate to clients, with complete command‑line examples and code snippets for a production‑ready setup.
This article introduces Mustache as a logic‑less template engine, explains its purpose and syntax, and provides step‑by‑step Spring Boot 3 examples—including data models, controllers, templates, collections, and form handling—to help developers quickly build dynamic web pages without embedding complex logic.
This article explains why a Spring Boot application fails to locate a template file when packaged as a JAR, details the step‑by‑step debugging process, and provides code solutions using ClassPathResource or PathMatchingResourcePatternResolver to correctly read resources inside the JAR.
This article demonstrates how to securely upload files to Minio, stream them for preview via KKFile without exposing the Minio endpoint, and protect download URLs with token validation, providing complete Java code examples for upload, download, and preview URL generation.
This article explains how to prevent image hotlinking in a Spring Boot application by creating a simple interceptor with hard‑coded settings and then extending it to a flexible, configuration‑driven solution using application.yml and a properties‑mapping class.
Discover how Nacos 3.0 introduces a high‑availability distributed lock feature that eliminates the need for external services like Redis or ZooKeeper, learn step‑by‑step integration with Spring Boot, explore its core components, and unlock advanced extensibility via Java SPI.
This article walks through eleven notable Spring Boot 3.5 enhancements—including stricter .enabled flags, renamed TaskExecutor beans, Redis URL handling, annotation‑based servlet/filter registration, multi‑property environment loading, structured logging tweaks, WebClient connector settings, task decorators, custom executors, bootstrapExecutor auto‑configuration, and secured heapdump actuator endpoint—providing concise explanations and runnable code snippets.
This article demonstrates how to implement a real‑time device‑monitoring system using WebSocket, covering the problem scenario, front‑end Vue.js visualization, Spring Boot back‑end configuration, WebSocket server setup, and step‑by‑step testing to achieve instant status updates.
After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported high swap usage; the author investigated JVM settings, used tools like jcmd, pmap, gperftools, strace, and GDB, identified native memory leaks caused by Spring Boot’s Reflections scanning and Inflater usage, and resolved the issue by configuring scan paths and fixing Inflater handling.
This tutorial walks you through API protocol types, Swagger/OpenAPI documentation setup, advanced configuration, environment‑specific activation, UI enhancement with Knife4j, and practical versioning strategies to efficiently manage and evolve your backend APIs.
This article demonstrates how Nginx’s default behavior ignores request headers containing underscores, causing missing parameters in a Spring Boot application, and shows how to configure the 'underscores_in_headers on;' directive to correctly forward such headers, with code examples and testing via Postman.
This article explains why using 777 permissions on production servers is dangerous when deploying a Spring Boot Docker service, and provides step‑by‑step guidance on applying minimal permissions, creating dedicated users, and automating secure deployments with Docker, CI/CD, and Kubernetes.
The article explains how to achieve graceful shutdown of Spring Boot services by handling Linux kill signals, registering JVM shutdown hooks, and exposing an Actuator REST endpoint that safely releases resources, stops beans, and terminates the JVM without data loss.
This article walks you through using Spring AI's MCP client starter in a Spring Boot 3 project to connect to Baidu Map's MCP server, covering dependencies, YAML and JSON configurations, communication modes, custom server setup, and sample code for invoking the service.
This guide shows how to use Tencent's open‑source APIJSON library with a Spring Boot demo to automatically generate full‑stack CRUD REST endpoints from database tables, covering project setup, configuration, table creation, and example requests for querying, adding, updating, deleting, and paginating product brand data.
This article explains the CQRS architectural pattern, its benefits and pitfalls, and provides a step‑by‑step guide to implementing CQRS with Spring Boot, Axon, and Kafka, including command and query handling, event sourcing, and practical considerations for microservice architectures.
This article introduces Spring Cloud Gateway as a high‑performance replacement for Zuul, explains its core components (Route, Predicate, Filter) and request flow, provides step‑by‑step setup of a gateway project, demonstrates route configuration, custom GlobalFilter and GatewayFilter implementations, and validates the behavior with example requests.
This article presents six commonly used file upload and download techniques for Spring Boot, covering basic Multipart handling, stream-based download, integration with Alibaba Cloud OSS and MinIO, as well as high‑concurrency chunked uploads with Nginx, each accompanied by complete code examples and usage scenarios.
This tutorial shows how to build and run a Spring MVC application using an embedded Tomcat server with just a single Java class, covering Maven dependencies, Tomcat configuration, Servlet registration, Spring‑driven startup, and core Spring MVC component setup.
Explore how to leverage JSR‑330 standard annotations such as @Inject, @Named, and @ManagedBean in Spring Boot 3.4.2, with practical code examples, dependency setup, bean naming, optional injection, and a comparison of their limitations versus native Spring annotations.
This article explains how to use Spring Boot Actuator to monitor and control Spring Cache, covering essential cache annotations, a complete CRUD example with caching, cache management endpoints, custom CacheManager configuration, and optional Redis integration for production‑grade caching.
This guide walks through practical RBAC design using Sa-Token, providing MySQL table schemas for users, roles, permissions, sample data, and Spring Boot API code for authentication, authorization checks, and retrieving the logged‑in user's details.
This article compares three classic real‑time web technologies—Server‑Sent Events, WebSocket, and Long Polling—explaining their principles, Spring Boot implementations, advantages, disadvantages, and suitable scenarios to help developers select the optimal solution for live data updates.
This article presents a comprehensive collection of 124 Spring Boot 3 practical cases, detailing eight distinct methods for defining web interfaces—including @Controller, @RestController, HttpRequestHandler, ServletRegistrationBean, HandlerFunction, @HttpExchange, and static resource registration—complete with code snippets, configuration steps, and usage explanations.
This guide shows how to create a reusable BaseController using MyBatis‑Plus, reflection utilities, and Spring Boot annotations to provide automatic CRUD, list, pagination and count endpoints for any entity with minimal code.
This article demonstrates how to automate CRUD functionality in a Spring Boot application by adding MyBatisPlus, creating utility methods for query building and reflection, implementing a generic BaseController, configuring pagination support, and extending the controller for specific entities, providing a reusable RESTful API template.
After caching, indexing, and async optimizations still leave a Spring Boot REST API sluggish, this guide shows how fine‑tuning JVM options—such as enabling G1GC, adjusting pause targets, compressing class metadata, shrinking thread stacks, and pre‑touching memory—can triple response speed without changing application code.
This article explains the concept of Cross‑Origin Resource Sharing (CORS), demonstrates how to identify cross‑origin requests, and provides a complete Spring Boot backend configuration together with Vue3/Axios frontend code to solve CORS issues in a full‑stack web application.
This article introduces PowerJob, a next‑generation distributed scheduling and computing framework, outlines its key advantages, compares it with other schedulers, and provides a step‑by‑step guide for local deployment, web console usage, and creating a scheduled task.
Explore 15 practical Java Stream API examples—from filtering and mapping to parallel processing and JPA integration—demonstrating how to write concise, efficient code, improve performance, and avoid memory issues, with full code snippets and explanations for each use case.
This tutorial explains WebSocket’s full‑duplex protocol, compares it with HTTP polling, outlines typical real‑time use cases, details the handshake and frame structure, and provides complete client‑side JavaScript and Spring Boot server examples to help developers quickly implement bi‑directional communication.
This article walks you through six essential validation strategies for Spring Boot applications, from using JSR‑303 annotations and global exception handling to custom validators, validation groups, cross‑field checks, and integrating a Drools rule engine, all illustrated with complete code examples and best‑practice tips.
This article introduces Spring AI, explains its core features for integrating various AI models, and walks through creating a Spring Boot chat application that connects to the DeepSeek model using both synchronous and streaming endpoints.
This article walks through integrating SpringBoot, Dubbo, and Seata to implement reliable distributed transactions, covering project setup, Maven dependencies, service definitions, Nacos registration, configuration files, testing normal commits and rollbacks, and troubleshooting version incompatibilities.
This article explains why feature flags are essential in Spring Boot projects and walks through six concrete ways to implement dynamic toggles—including @Profile, @Conditional, @RefreshScope, database‑backed scheduling, Apache Commons Configuration, and Togglz—complete with code snippets and usage tips.
This tutorial walks through adding Dataway to a Spring Boot project, covering Maven dependencies, configuration properties, required database tables, data‑source setup, Hasor module integration, enabling Hasor, launching the application, and creating and testing APIs using both SQL and DataQL without writing any service code.
This article introduces Java 21 virtual threads, demonstrates their basic creation and delayed start, shows how to enable and configure them in Spring Boot, compares performance against traditional threads with benchmark results, and provides additional Java performance optimization techniques.
IDEA no longer offers Java 8 when creating Spring Boot projects because it relies on Spring Initializr, which now only supports Spring Boot 3.x and Java 17+, but you can still generate Java 8‑compatible projects by switching to alternative starter services like Alibaba Cloud’s start.aliyun.com.
This article presents seven advanced Spring Boot topics—including Resilience4j circuit breaking, custom Actuator health checks, Saga-based distributed transactions, cache optimization, asynchronous processing, Gateway vs. Zuul, and OAuth2/JWT security—each illustrated with concise explanations, implementation steps, and code samples.
Spring Boot's @ConversionService annotation simplifies request parameter conversion by automatically transforming string inputs into target types such as dates or numbers, eliminating repetitive manual parsing code, supporting custom converters, and enhancing code maintainability and development efficiency, as demonstrated with practical examples.
This article explains how to use Spring Boot's asynchronous request handling with Callable, WebAsyncTask, and DeferredResult, compares their processing flows, shows how to configure a custom thread pool, and discusses when asynchronous endpoints improve throughput in backend services.
This tutorial walks through the need for robust API parameter validation in Spring Boot, introduces the Bean Validation specification and its implementations, explains key constraint annotations, demonstrates a quick start with Maven dependencies, shows how to build DTOs and controllers, and details a unified global exception handling strategy for clean error responses.
This article explores the hierarchy of Spring Boot interception mechanisms—Filter, HandlerInterceptor, AOP, RestTemplate, Feign, and WebFilter—detailing their typical use cases, implementation code, pitfalls, and best‑practice ordering, while providing practical tips and performance monitoring advice for robust backend development.
This tutorial demonstrates how to create a complete meeting‑management CRUD application using Spring Boot 3, Spring AI Tools, and a custom ChatClient, covering environment setup, entity definitions, repository, service layer, tool integration, and REST endpoints with code examples and screenshots.
This tutorial explains how to set up and use the easy-data-scope library in a Spring Boot project to implement dynamic SQL data‑permission rules with MyBatis, covering database preparation, Maven dependencies, core annotations, configuration files, and example queries for various permission scenarios.
Redis 8.0 marks a major shift with its return to a true open‑source license (AGPLv3), the consolidation of Redis Open Source, a suite of advanced modules like Vector Search and TimeSeries, and a Spring Boot compatibility guide, turning Redis from a simple cache into a versatile data platform.
Explore a comprehensive Spring Boot 3 tutorial featuring 122 real‑world controller examples—from basic @RestController setup and dynamic URL configuration to advanced SpEL usage, interface default methods, exception handling, data binding, and custom endpoints—complete with code snippets and test results.
The production failure where a customer‑service event creation stopped each morning was traced to RedisTemplate’s increment returning null because @Transactional combined with enabled Redis transaction support caused the command to be queued in a MULTI/EXEC block, which is fixed by using separate non‑transactional and transactional StringRedisTemplate beans.
This article introduces easy-data-scope, a lightweight Java library that enables dynamic SQL‑based data permission control for MyBatis, MyBatis‑Plus, and MyBatis‑Flex, showing how to set up the project, configure dependencies, define annotations, and apply various permission scenarios with code examples.
This article explores common pitfalls in Java date handling, explains thread‑unsafe SimpleDateFormat issues, demonstrates safe alternatives with ThreadLocal, Java 8 Time API, and zone‑aware calculations, and provides performance‑optimized patterns for high‑throughput applications.
Spring Boot 3.5 introduces a suite of enhancements—including task decorator support, the Vibur connection pool, SSL health metrics, flexible configuration loading, automatic Trace‑ID headers, richer Actuator capabilities, functional programming hooks, and many more—each explained with code examples and practical usage tips for modern Java backend development.
This article explains Seata's distributed transaction architecture, details the AT transaction mode, walks through single‑node and cluster deployments, and provides complete code examples for stock and order services that demonstrate both successful commits and automatic rollbacks in a microservice environment.
This article introduces Spring AI's multimodal capabilities, explains the Message API for handling text, image, audio, and video inputs, and provides step‑by‑step Spring Boot examples for image analysis, ID card extraction, and structured JSON output of car‑color counts.
Spring Boot 3.5 introduces a suite of powerful enhancements—including task decorator support, a new Vibur connection pool, SSL monitoring, flexible environment variable loading, Actuator-triggered Quartz jobs, automatic Trace ID headers, structured log customization, functional routing insights, expanded SSL client support, OpenTelemetry upgrades, Spring Batch tweaks, OAuth 2.0 JWT profiling, and functional bean registration—providing developers with richer capabilities for modern Java backend applications.
This article explains how to integrate Lua scripts into Spring Boot applications to leverage Redis for atomic operations, performance optimization, and complex data processing, providing detailed Lua fundamentals, practical use‑cases, implementation steps, error handling, security considerations, and best‑practice recommendations.
This article explains how @Transactional and @Async normally cooperate in Spring Boot, demonstrates cases where the transaction does not roll back when @EnableAsync order is changed, analyzes the underlying AOP proxy creation and bean post‑processor execution order, and introduces new Spring 6.2 transaction‑rollback configuration options.
This article presents a continuously updated collection of over 120 Spring Boot 3 practical examples, covering database initialization scripts, switching Redis clients, disabling and customizing security, configuring HTTP clients, and fine‑tuning Spring MVC behavior with code snippets and configuration details.
This article explains how to design and implement a multi‑level approval workflow for an office automation system using the Activiti BPMN engine, covering process diagram creation, Spring Boot configuration, Java code for deployment and task handling, database tables, API overview, and comparisons with similar frameworks.
This article explains why circuit breakers are essential for third‑party API calls, introduces the lightweight Resilience4j library, and provides step‑by‑step Spring Boot 3 examples—including Maven setup, RestTemplate and WebClient integrations, annotation usage, and both default and custom configurations—complete with code snippets and result screenshots.
