This article explains the concepts, execution order, and ideal use‑cases of Spring Boot's Filter, Interceptor, and AOP, compares their characteristics, and provides a selection guide and best‑practice recommendations for building maintainable backend applications.
This guide explains the fundamentals of memory leaks in Java, outlines common causes in Spring Boot, and provides step‑by‑step techniques—including GC log analysis, JConsole, VisualVM, MAT, Actuator, custom endpoints, jstack, BTrace, and best‑practice recommendations—to identify, diagnose, and prevent memory leaks for stable long‑running services.
This article provides a comprehensive overview of Spring Cloud, explaining its two generations (Netflix and Alibaba), versioning scheme, core components such as Eureka, Ribbon, Hystrix, Feign, Gateway, Config, Bus, Nacos, Sentinel and Seata, and compares the capabilities of the two implementations for building cloud‑native microservice systems.
This guide walks you through initializing a Spring Boot project, handling IDE setup frustrations, managing Spring Cloud and Kafka version compatibility, leveraging Maven for dependencies, implementing global exception handling, logging, CORS, and Swagger configurations, and recommends essential tools for efficient backend development.
The article examines recurring Java backend problems such as duplicated configuration files, hard‑coded parameters, mixed logging practices, unchecked code releases, unsynchronized databases, and Maven dependency issues, then offers concrete solutions like externalized configuration, standardized logging, proper code review, and correct Maven pom settings.
This tutorial walks you through installing the EasyCode IntelliJ plugin, creating a MySQL database, configuring IDEA’s database connection, setting up Maven dependencies and application.yml, generating entity, DAO, service, and controller code automatically, and finally running the Spring Boot project.
This tutorial walks Java developers through using Redis in Spring Boot projects, covering the essential spring-boot-starter-data-redis dependency, RedisTemplate basics, the underlying RedisConnectionFactory design, custom connection configurations for single‑node and sentinel modes, and seamless integration of the Redisson client for advanced distributed features.
This article explains how to build outbound Webhooks in Spring Boot 3 using the non‑blocking WebClient, demonstrates event‑driven publishing, shows code for custom events, retry mechanisms, and provides practical examples for integrating microservices with reliable HTTP callbacks.
This article recounts a midnight production outage caused by inadequate Postman tests, explains three hidden pitfalls of Postman, demonstrates how MockMvc provides precise, code‑level assertions and automated scenarios, and offers a step‑by‑step guide to boost API test automation from 30% to 90% coverage.
This guide walks you through the fundamentals of the ELK stack—Elasticsearch, Logstash, and Kibana—explaining its architecture, installation on Ubuntu, configuration of Logstash shipper and indexer roles, integration with Spring Boot and Nginx logs, and how to run the components as background services using Supervisor.
This article explains six key Spring Boot annotations—@RequestParam, @PathVariable, @MatrixVariable, @RequestBody, @RequestHeader, and @CookieValue—detailing how each retrieves different kinds of request data with clear code examples for building robust APIs.
This article explains what debounce means for web APIs, identifies which endpoints need it, describes how to detect duplicate requests, and provides complete Java implementations using shared Redis caches and Redisson distributed locks with code examples and key generation strategies.
This guide walks through building robust Spring Boot backend APIs by detailing request parameter validation with @Validator, implementing global exception handling, standardizing unified response structures, applying custom annotations for response control, managing API versioning via path and header strategies, and enhancing security with token authentication, timestamps, signatures, and HTTPS.
This article explains how to implement a plug‑and‑play development model in Spring Boot using Java SPI, custom configuration, and Spring Factories, providing step‑by‑step code examples, a multi‑module microservice case study, and practical guidance for creating extensible, decoupled applications.
This article introduces dynamic expression parsing for enterprise Java applications, compares seven Spring Boot‑compatible expression engines (SpEL, MVEL, Aviator, JEP, OGNL, JEXL, QLExpress) across performance, security and syntax, and provides complete code samples, execution results and pros‑cons for each engine.
This article walks through a real‑world production case, showing how to systematically detect, analyze, and resolve severe JVM garbage‑collection pauses that caused service timeouts, by examining CPU, memory, GC logs, adjusting collector settings, and aligning JVM threads with Kubernetes resource limits.
This article explains six common techniques—@RequestParam, @PathVariable, @MatrixVariable, @RequestBody, @RequestHeader, and @CookieValue—for extracting request data in Spring Boot APIs, complete with concise code examples and usage guidance.
This article explains how to protect file downloads in Spring Boot by generating short‑lived or token‑based URLs, preventing static URL exposure, handling path‑traversal attacks, supporting in‑memory or streamed files, and optionally tying downloads to authenticated users.
This article explains why traditional large‑file uploads fail, introduces the benefits of chunked uploading, and provides a complete Spring Boot implementation—including backend controllers, high‑performance merging, Vue front‑end code, enterprise‑level optimizations, performance benchmarks, and best‑practice recommendations—for building a robust, resumable file transfer solution.
Learn step‑by‑step how to create a Spring Boot multi‑module Maven project, from designing the parent and child module structure, configuring pom.xml files, writing simple application and controller code, to building and running the modules with Maven commands.
This article presents twelve practical techniques for obtaining Spring beans—including @Autowired, @Resource, @Inject, constructor injection, ApplicationContext, BeanFactory, ObjectProvider, @Lookup, BeanFactoryUtils, BeanFactoryAnnotationUtils, custom utilities, and @Value with SpEL—complete with code examples and usage scenarios to help developers choose the most suitable approach.
This article demonstrates how to replace cumbersome if‑else logic in Spring Boot 3.4.2 by using the Service Locator pattern with ServiceLocatorFactoryBean, providing a clean way to select parsers for different file types through an enum, interface, and Spring‑managed beans.
This article explains how to achieve invisible token renewal in modern web systems using Spring Boot, JWT, and Redis, detailing backend auto‑renewal, frontend interception, dual‑token strategies, and handling edge cases like silent form timeouts to keep user sessions uninterrupted.
This article introduces the fundamentals of augmented large language model agents, explains six workflow patterns—including chain, parallel, routing, orchestrator‑workers, evaluator‑optimizer, and autonomous agents—and provides complete Spring Boot 3 code examples, configuration, and test results for each pattern.
Version 3.0 of Nacos introduces a decoupled architecture with independent console deployment, multiple port configurations, three flexible deployment modes (merged, server, console), a modular bootstrap startup engine, and an embedded integration approach that simplifies microservice governance while enhancing security and performance.
Spring Boot 3.5.3, the first patch of the 3.5 series, introduces critical fixes for a severe issue in 3.5.1, upgrades Tomcat to 10.1.42 with multipart limits, adds ConfigData options support, resolves numerous performance, configuration, actuator, and binding bugs, improves documentation, and updates a wide range of core, database, server, and monitoring dependencies, making the upgrade strongly recommended.
This article walks through the common frustrations of IDE and environment setup for Spring Boot projects, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates how Maven and auto‑configuration simplify dependencies, and provides ready‑to‑use code snippets and useful tooling recommendations for backend developers.
This article introduces retrofit‑spring‑boot‑starter, a lightweight HTTP client for Spring Boot that simplifies request creation and offers powerful features such as custom OkHttpClient injection, annotation‑based interceptors, connection‑pool management, logging, retry, error decoding, circuit‑breaker support, service discovery, and flexible call adapters and converters, all with concise configuration examples.
This tutorial walks through integrating Alibaba's RocketMQ into a Spring Boot application, covering Maven dependencies, producer and consumer configurations, and detailed examples of synchronous, asynchronous, one‑way, delayed, ordered, transactional, request‑response, batch, and pull messaging APIs, along with best‑practice recommendations.
This guide explains step‑by‑step how to load external JAR files into the JVM, configure Spring Boot to recognize them, and choose among four practical solutions—including classpath expansion, Spring Boot loader.path, custom class loaders, and JVM boot classpath tweaks—while highlighting their pros, cons, and required Maven settings.
This article systematically analyzes a Spring Boot project's 280‑second startup, identifies bottlenecks such as bean initialization and sharding data source loading, and applies listener‑based timing, bean‑post‑processor profiling, and asynchronous initialization to reduce launch time to 159 seconds, improving developer efficiency.
This article explores a supply‑chain consistency framework that tackles distributed transaction challenges by using eventual consistency, detailing its theoretical models, architecture, core components, async execution, retry mechanisms, and a practical code example for Spring‑Boot applications.
This article explores Spring Boot’s powerful built‑in utilities—including request logging, content caching, once‑per‑request filters, AOP helpers, starter auto‑configuration, flexible property binding, asynchronous execution, Actuator monitoring, and SpEL expressions—showing how they streamline development, improve maintainability, and boost production‑grade reliability.
Spring Boot’s Fat Jar packages all application code, dependencies, and an embedded server into a single executable JAR, breaking the parent‑delegation model with a custom class loader and protocol handler, enabling simple ‘java -jar’ execution, streamlined deployment, and benefits for microservices and Docker layering.
This tutorial shows how to use Jackson's polymorphic deserialization in Spring Boot 3 to handle variable JSON request bodies by defining a common Order interface, concrete implementations, and a REST controller that routes calculations based on the order type, eliminating redundant endpoints.
This article explains how Spring Boot 3.4.2 handles data binding using constructors and property setters, demonstrates practical examples with code, shows how to resolve binding errors with BindingResult, and guides you through creating and registering custom PropertyEditors for complex type conversion.
A comprehensive step‑by‑step tutorial shows how to integrate MyBatis‑Plus into a Spring Boot project, covering dependencies, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing.
This article demonstrates how to design a simple Calculator interface, provide two implementation strategies (annotation‑managed and reflection‑based), and achieve hot deployment of user‑supplied JARs in a Spring Boot application, including loading, registering, and removing beans dynamically.
Discover 14 practical Java code optimization techniques—from using configuration properties and @RequiredArgsConstructor to modularizing methods, avoiding null returns, leveraging IDE suggestions, and applying design patterns—each illustrated with clear examples and snippets to help backend developers write cleaner, more maintainable code.
Spring’s latest security advisory reveals a critical Reflection File Download (RFD) vulnerability affecting multiple Spring Framework versions, allowing crafted requests to force users to download malicious files, and provides detailed conditions, unaffected scenarios, version impact, and recommended remediation steps.
This article explains how to implement database read‑write separation in a Spring Boot application by configuring master and slave data sources, creating a routing datasource, managing thread‑local context, and using an AOP‑based annotation to switch between read and write operations.
This guide explains how to improve Spring Boot 3 applications by using Actuator for monitoring, enabling caching, optimizing database connections with HikariCP, and applying asynchronous request handling and tasks to achieve faster response times and better resource utilization.
This article explains how to integrate WebSocket into a Spring Boot project to create a lightweight instant‑messaging system, covering dependency setup, configuration classes, core server implementation, required modules, common deployment issues, and practical solutions with complete code examples.
This guide shows how to integrate Spring Boot with the Model Context Protocol (MCP) to let large language models interact with existing services via natural language, covering entity definitions, Maven dependencies, configuration, tool annotations, and testing to create an AI‑enabled book management API.
This article demonstrates how to implement multi‑version REST APIs in Spring Boot 3 by leveraging @RequestMapping attributes such as headers, params, and consumes, providing complete code examples, request screenshots, and a custom HttpMessageConverter for Content‑Type based versioning.
This tutorial walks through designing a QR‑code login flow, defining a token table, outlining client and server roles, implementing two REST endpoints, configuring Spring Boot WebSocket support, and handling real‑time login notifications with Java and JavaScript code examples.
Concept Plugin 2 introduces a lightweight, annotation‑driven plug‑in system for Spring Boot that separates core business logic from device integration code, enabling independent testing, dynamic loading, and easy configuration through a management UI, while supporting various injection patterns, nested dependencies, and Spring features.
This article explains the various interception mechanisms in Spring Boot 3—including Filters, Spring Security filters, MVC Interceptors, AOP, ControllerAdvice, Request/ResponseBodyAdvice, and REST Clients—provides execution flow diagrams, detailed code examples, and practical usage tips for building robust backend applications.
This article introduces Jolt, an open‑source Java library for JSON‑to‑JSON transformation, explains its advantages over traditional hard‑coded conversion, demonstrates core operations and custom extensions with code examples, shows how to integrate it into Spring Boot, and outlines future plans for a visual drag‑and‑drop configuration tool.
This tutorial walks you through building a Spring Boot project that uses the easy-data-scope library to inject dynamic SQL for fine‑grained data permissions, covering database setup, Maven dependencies, core annotations, custom rule implementation, and practical query examples.
This article walks you through creating a reusable BaseController using MyBatisPlusPro, including dependency setup, utility methods for reflection, a generic CRUD controller, pagination configuration, and how to extend it in your own Spring Boot applications.
This comprehensive guide explains the most common Spring Boot annotations—including request mapping, bean definitions, dependency injection, scopes, and auto‑configuration—providing clear examples and usage tips for Java backend developers.
This article presents a comprehensive guide to Spring Data JPA in Spring Boot 3, covering 131 practical cases, core repository interfaces, Specification and Criteria Builder techniques, and dozens of performance‑optimizing tips such as lazy loading, caching, batch processing, transaction management, projections, and stream queries.
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 tutorial walks through creating a Sequential Thinking MCP Server in Java using Spring AI 1.0, covering configuration, core classes, tool registration, HTTP SSE setup, performance trade‑offs, and links to the official guide and GitHub repository.
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.
