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 how Spring Boot leverages JSR‑380 for declarative request validation, walks through the internal processing chain from RequestResponseBodyMethodProcessor to Hibernate Validator, and demonstrates building custom annotations for enum checks and conditional field validation while supporting multilingual error messages.
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.
A real‑world incident where an unchecked null request parameter caused a full‑table query, massive memory usage and OOM is examined, then Spring Boot’s validation framework—including manual checks, annotation‑driven constraints, nested and group validation, and global exception handling—is demonstrated step‑by‑step with code samples.
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.
This article explains Spring Boot's TargetSource mechanism, covering the default SingletonTargetSource and demonstrating how to implement custom, hot‑swappable, pooled, prototype, and thread‑local TargetSources with full code examples and execution results, helping developers manage bean instances dynamically in AOP proxies.
This article demonstrates how to transform a traditional Spring Boot book‑management service into an AI‑driven MCP service by importing Spring AI dependencies, configuring proxy and MCP server settings, annotating service methods with @Tool, registering them, and exposing a chat endpoint that lets large language models query and manipulate book data through natural language.
This tutorial walks through setting up the easy-data-scope library in a Spring Boot project, configuring the database and dependencies, defining DataScopeInfo, using the @DataScope annotation, and demonstrating various permission scenarios such as filtering by ID, age, merging conditions, and custom templates.
This article explains the differences between Body and Params parameters in Spring Boot, covering various Content‑Type configurations such as query, x‑www‑form‑urlencoded, form‑data, binary, and JSON, and provides code examples and a clear comparison table to help developers choose the right approach for stable and efficient API design.
This article explains the concept of SQL injectors in MyBatis‑Plus, lists the built‑in injectable methods, shows how to configure them globally, demonstrates creating a custom mapper and injector with full code examples, and provides step‑by‑step testing procedures for extending MyBatis‑Plus functionality.
This article demonstrates how to use Spring Boot 3's @JsonFormat annotation for precise date, time, and enum serialization, covering configuration via properties, annotation attributes, locale settings, shape options, lenient parsing, and case‑insensitive deserialization with practical code examples.
Learn how to implement efficient real-time log streaming in Spring Boot using ResponseBodyEmitter, covering its purpose, core methods, usage scenarios, step-by-step controller code, connection lifecycle management, comparison with SSE and Streaming, and important considerations for client support, timeouts, and thread safety.
This article introduces Java 21's virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic usage and Spring Boot integration with code examples, and compares their performance against traditional threads through practical experiments and additional optimization tips.
This article introduces seven Spring Boot 3 initialization mechanisms—including @PostConstruct, InitializingBean, @Bean initMethod, ApplicationRunner, ContextRefreshedEvent, SmartInitializingSingleton, and SmartLifecycle—detailing their usage, code examples, execution order, and suitable scenarios for effective application startup.
This article explains how to implement a custom MyBatis-Plus pagination interceptor that parallelizes COUNT and data queries using CompletableFuture and a configurable thread pool in Spring Boot, suitable for large single-table and complex multi-table pagination scenarios, and provides detailed configuration and code examples.
This article introduces Java 21 virtual threads, explains their lightweight and high‑concurrency advantages, demonstrates basic and delayed creation, shows how to enable them in Spring Boot with minimal configuration, compares performance against traditional threads, and provides additional Java performance optimization tips.
This guide demonstrates how to integrate the easy-data-scope library into a Spring Boot project to implement dynamic, annotation‑driven SQL data permissions with MyBatis, covering project setup, dependency configuration, core interfaces, annotation options, and practical query examples.
This article provides a detailed guide to the most commonly used Spring and Spring Boot annotations—including MVC mapping annotations, bean registration annotations, dependency injection and scope annotations, as well as conditional configuration annotations—explaining their purposes, key attributes, and example usages for Java backend development.
This article explains the problems of traditional Spring MVC setup, introduces Spring Boot starters as a solution, details naming conventions and project structure for custom starters, and walks through the implementation of auto‑configuration classes, properties binding, and the spring.factories registration process.
This guide demonstrates how to integrate Apache Tika into a Spring Boot application to automatically extract file content, detect sensitive data such as ID numbers, credit cards, and phone numbers using regular expressions, and implement data leak protection through a REST API with code examples.
This tutorial walks through practical jsoup usage within Spring Boot 3, covering dependency setup, parsing HTML from strings, fragments, URLs or files, extracting titles, links, images, applying CSS selectors, modifying elements, and sanitizing content to prevent XSS attacks.
This article demonstrates how to create a configurable data‑masking solution for Spring Boot APIs by defining a custom @DataMasking annotation, implementing masking strategies, building a custom Jackson serializer, integrating it via an AnnotationIntrospector, and testing the functionality with a sample controller.
This article explains how to integrate the Camunda 7 workflow engine into a Spring Boot project, covering core concepts, required Maven dependencies, configuration files, database setup, process modeling, task types, gateways, and essential APIs for managing processes, tasks, and variables.
This article explains how Spring Boot eliminates XML configuration and embeds servlet containers like Tomcat by analyzing Maven dependencies, core startup methods, WebServer creation, and the lifecycle methods that ultimately start and stop the embedded Tomcat instance.
This article explains how three Hibernate annotations—@Formula, @SQLRestriction (or @Where), and @Filter—solve common JPA pain points such as scattered query logic, duplicated calculations, and hard‑coded filters, providing code‑reduction, better performance, and easier maintenance in Spring Boot 3 projects.
This article explains how to create custom MyBatis TypeHandler classes to automatically convert Java objects—such as JSON strings and enum codes—to appropriate JDBC types, simplifying data persistence in Spring Boot applications and improving code maintainability.
This guide walks through configuring Maven profiles to produce environment‑specific Spring Boot packages, using the maven‑assembly‑plugin to create a zip bundle, and operating a reusable shell script that can unzip, start, stop, and restart the jar on Linux.
This article introduces Spring Boot 3's filter mechanism, outlines core functions and application scenarios, and provides detailed code examples for eight built‑in filters such as CharacterEncodingFilter, CorsFilter, and HiddenHttpMethodFilter, helping developers build secure and efficient web applications.
This tutorial walks through integrating Dubbo with Spring Boot using Nacos as the service registry, showing how to create a shared API module, configure provider and consumer Maven projects, annotate services with @Service and @Reference, and verify successful RPC calls via a simple REST endpoint.
This tutorial walks through installing Docker and Jenkins on CentOS, configuring system settings, creating a Jenkins job to pull, build, and package a Spring Boot project, testing the pipeline, and finally running the application via Docker, providing complete commands and configuration details for a reliable CI/CD workflow.
This article explains how to integrate Lua scripts into a Spring Boot application to leverage Redis's atomic execution, reduce network overhead, and improve performance, covering Lua fundamentals, reasons to choose Lua, practical use‑cases, step‑by‑step implementation, error handling, security considerations, and best practices.
This article introduces MyBatis‑Plus, an enhancement for MyBatis, outlining its lightweight features, step‑by‑step setup including database creation, Maven dependency, configuration, entity and mapper definitions, CRUD operations, pagination, optimistic locking, logical deletion, condition wrappers, and code generation utilities for rapid backend development.
This article walks through using Nacos as a centralized configuration center for Spring Cloud microservices, showing how to create configuration data, set up a Maven client, enable dynamic refresh with @RefreshScope, and manage multi‑environment and multi‑file configurations.
This article demonstrates how to programmatically register and unregister Spring Boot controller methods, covering simple examples, adding request constraints, custom matching conditions, and endpoint removal, with complete code snippets and a test result illustration.
This article explains the Model Context Protocol (MCP), why it simplifies AI tool integration, and provides a step‑by‑step guide to create a Spring AI 1.0.0‑M7 Maven project, configure the MCP server with HTTP SSE, implement weather and Maoyan movie services, run the server, and test it with the MCP Inspector and Cherry Studio client.
This article introduces APIJSON, a zero‑code JSON‑based ORM for APIs, outlines its key features, and provides a step‑by‑step Spring Boot 3 demo—including cloning the repository, configuring the database, and performing full CRUD operations via Postman with code examples.
This article provides a step‑by‑step tutorial on installing, configuring, and using the open‑source XXL‑Job distributed scheduling framework with Spring Boot, covering server and executor deployment, task creation via annotations, API and sharding, execution, logging, and the underlying Netty‑based communication design.
This article explains why Spring Boot 3.4's new automatic HTTP header binding can corrupt DTO fields like version used for optimistic locking, and provides a global ControllerAdvice solution plus alternative strategies to prevent such conflicts in microservice environments.
This article explains how Spring Boot controllers can return up to 17 different response types—including @ResponseBody, HttpEntity, ResponseEntity, HttpHeaders, ErrorResponse, ProblemDetail, String views, ModelAndView, @ModelAttribute, DeferredResult, Callable, CompletableFuture, ResponseBodyEmitter, SseEmitter, StreamingResponseBody, Flux and Mono—providing code examples, usage notes, and sample output images for each.
This article explains how to design and implement a plugin mechanism in Java and Spring Boot, covering the benefits of modular decoupling, common implementation patterns such as ServiceLoader and custom configuration files, and practical code examples for building extensible backend services.
This article provides a step‑by‑step guide for integrating Alipay sandbox payment into a Spring Boot backend, covering sandbox configuration, network tunneling, Maven SDK dependency, application properties, payment request creation, callback processing, and common troubleshooting.
This article demonstrates how to enable conversation memory and history in Spring Boot 3 applications using Spring AI's Advisor API, covering environment setup, Maven dependencies, configuration, code examples for advisors, unique chat IDs, history retrieval, and optional database persistence.
This article explains a low‑intrusion data‑permission design for backend micro‑services, detailing resource and value‑rule definitions, RBAC modeling, MyBatis SQL interception implementation, Redis‑based permission retrieval, and Spring Boot auto‑configuration for easy enablement in production.
This guide walks through converting a traditional Spring Boot book‑management API into a Model Context Protocol (MCP) service that can be invoked via natural‑language prompts, covering dependency setup, proxy configuration, @Tool annotations, MCP server registration, chat client wiring, data initialization, and end‑to‑end testing.
This tutorial walks through integrating Spring Cloud Sleuth and Zipkin to achieve distributed service tracing in a microservice architecture, covering the underlying concepts, step‑by‑step implementation, log analysis, and optional asynchronous log collection via RabbitMQ.
This comprehensive guide walks you through Spring Boot 3 AOP fundamentals, showing how to declare aspects with @Aspect, define pointcuts using @Pointcut, apply various advice types, manage ordering, bind method parameters, and leverage inter‑type declarations with clear code examples and diagrams.
This article explains how to implement asynchronous request handling in Spring Boot using Callable, WebAsyncTask, and DeferredResult, detailing their processing flow, configuration of thread pools, and scenarios where async requests improve throughput while outlining potential trade‑offs.
This guide walks through initializing a Spring Boot project, handling IDE setup challenges, managing version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides practical code examples for global exception handling, logging, CORS configuration, Swagger integration, and useful development tools.
This article demonstrates how to solve Spring Boot API timeout issues by creating a custom @Timeout annotation combined with an AOP aspect, covering annotation definition, aspect implementation, executor handling, fallback logic, configuration, and practical test results.
