Spring Boot 3.0 adds a Native Executables feature that lets Java code be compiled ahead‑of‑time into machine code, contrasting with the traditional JIT approach, and provides a Maven command to generate platform‑specific executables for faster startup and performance.
This article explains how the Linux kill -9 command can cause data inconsistency and service disruption, demonstrates why it should be avoided in production, and provides several graceful shutdown techniques for Spring Boot—including using kill -15, the built‑in shutdown hook, Actuator endpoints, and a custom Tomcat connector configuration—along with code examples and best‑practice recommendations.
The mica-auto Spring Boot starter tool leverages Java Annotation Processors to automatically generate essential configuration files such as spring.factories, AutoConfiguration.imports, aot.factories, and spring‑devtools.properties, supporting Spring Boot 2.7+ and 3.0, and simplifying native image builds with GraalVM.
The article explains how the Linux kill command, especially kill -9, can abruptly terminate processes causing data inconsistency, and demonstrates safer alternatives for stopping Spring Boot applications—including kill -15, the built‑in shutdown script, Actuator endpoints, custom Tomcat connector shutdown, and @PreDestroy backup hooks—providing complete code examples.
This tutorial demonstrates how to use the MyBatis-Plus-Join (MPJ) library to perform left and right join queries in a Spring Boot project without writing XML SQL, covering dependency setup, mapper modification, query construction with MPJLambdaWrapper and MPJQueryWrapper, and pagination support.
This article explains how Spring Boot 3's Http Interface feature enables declarative HTTP service calls by defining Java interfaces, covering dependency setup, interface definitions, token handling, WebClient configuration, controller integration, testing with Postman, and discusses its reliance on WebFlux.
This article provides a comprehensive step‑by‑step guide on integrating Spring Batch with Spring Boot, covering configuration, entity and mapper definitions, job, step, reader, processor, writer implementations, database setup, error handling, and execution via a REST controller, complete with code examples.
This article demonstrates how to create a custom Spring Boot starter that provides automatic request body decryption and response body encryption using Hutool‑crypto, HttpServletRequestWrapper, RequestBodyAdvice, ResponseBodyAdvice, and validation utilities, enabling secure data transmission with timestamp verification.
This article explains multiple ways to perform asynchronous processing in Spring Boot, including @Async annotation, CompletableFuture (supplyAsync, runAsync), WebAsyncTask, DeferredResult, custom AsyncHandlerInterceptor, and server‑side optimizations such as increasing Tomcat connections and switching to Undertow, with complete code examples.
This article explains how to implement a comprehensive unified exception handling mechanism in Spring Boot by using @ControllerAdvice, custom BaseException/BusinessException classes, enum‑based error codes, assertion utilities, and standardized response objects to simplify error management across controller and service layers.
This article presents and compares five practical batch‑insert methods for MyBatis and MyBatis‑Plus, covering preparation steps, code implementations, configuration details, and performance results, helping developers choose the most efficient approach for inserting large volumes of data in Java backend projects.
This tutorial shows how to combine Spring Boot and Netty‑SocketIO to build a simple real‑time push system with broadcast, group and single‑user messaging, providing Maven dependencies, configuration files, Java classes, a REST controller and two HTML client pages for demonstration.
This article provides a step‑by‑step guide for building a CAS server and client with Spring Boot, covering WAR deployment, configuration file adjustments, custom authentication redirect strategies, CORS setup, and troubleshooting ticket validation and cross‑origin issues.
This article introduces Groovy as a JVM scripting language, outlines its typical use cases, and provides a detailed, code‑rich tutorial on how to integrate Groovy scripts into a Spring Boot application, including dependency setup, script execution, bean access, and security considerations.
This article explains why back‑end parameter validation is essential, introduces the JSR‑303 Bean Validation specification and Hibernate Validator, demonstrates common constraint annotations, shows how to integrate validation in Spring Boot, create custom annotations, and resolve typical pitfalls.
This article explains how to replace Shiro with jCasbin in a Spring Boot application, covering Maven dependencies, configuration files, Enforcer initialization, policy definition, and practical usage through a servlet filter and REST endpoints for adding or removing permissions.
This article provides a step‑by‑step guide on integrating Elasticsearch into a Spring Boot project, covering Maven dependency configuration, creation of a RestHighLevelClient, basic index and document CRUD operations, bulk data handling, advanced search queries with highlighting, and key implementation notes.
This article walks developers through upgrading Spring Cloud Tencent to the 2022 release, covering JDK 17 installation, Maven dependency updates, handling package conflicts, migrating javax to jakarta imports, adapting auto‑configuration files, and provides practical tips for a smooth transition to Java 17, Spring 6, and Spring Boot 3.
This article introduces OKHttpUtil, a lightweight wrapper for OkHttp that simplifies HTTP GET, POST, file upload/download, and chainable requests in Java, provides Maven integration, Spring Boot configuration, and demonstrates how to encapsulate external APIs such as eBay with concise code examples.
This article explains what Spring Native is, how to set up the required environment, the two main ways to build a native Spring Boot image using either Buildpacks or the GraalVM native-image Maven plugin, and demonstrates container deployment and performance comparison with traditional JVM execution.
This article explains how Spring Boot launches an application by invoking SpringApplication.run(), initializing the SpringApplication instance, and executing the run method, detailing each internal step, configuration loading, listener handling, and context refresh with illustrative code examples.
This article explains how to securely encrypt sensitive Spring Boot configuration properties such as database passwords using the Jasypt library, covering dependency setup, YAML configuration, encryption/decryption testing, custom encryptors, property detectors, resolvers, filters, and Maven plugin usage, all with practical code examples.
This article provides a comprehensive step‑by‑step migration guide for upgrading Spring Boot applications to version 3.0, covering JDK updates, dependency assessment, configuration changes, Jakarta EE package renaming, key feature alterations, and practical code snippets.
Learn how to compress large JSON payloads in a Spring Boot advertising API using GZIP, implement a servlet filter and request wrapper to decompress on the server, and evaluate bandwidth, CPU trade‑offs, testing methods, and deployment steps to halve request size.
Spring Boot 3.0, the first major release since 2.0, introduces Java 17 baseline, GraalVM native image support, enhanced observability with Micrometer, and Jakarta EE 10 compatibility, while providing a detailed migration guide for upgrading from earlier Spring Boot versions.
The article explains why browsers enforce same‑origin policies, then presents three practical ways to solve cross‑origin issues in a Spring Boot backend—using the @CrossOrigin annotation, routing through Spring Cloud Gateway, and making server‑side requests with HttpClient—accompanied by configuration examples and full code snippets.
This tutorial provides a complete, step‑by‑step guide to automatically deploy a Spring Boot project on CentOS 7 by installing Docker and Jenkins, configuring Maven and required plugins, creating a Jenkins pipeline, building the Docker image, and running the container, while avoiding common pitfalls.
This article explains ElasticSearch’s role in modern applications, compares its clients, shows how to configure RestHighLevelClient in Spring Boot, and details the four Spring Data Elasticsearch Operations interfaces with code examples for building queries using CriteriaQuery, StringQuery, and NativeSearchQuery.
This tutorial demonstrates how to integrate the Decorator design pattern into a Spring Boot application, showing a basic interface, concrete services, a simple decorator, and a multi‑layer decorator with full code examples and runtime output.
This article provides a thorough tutorial on using Spring Validation for request parameter checking, covering simple usage, dependency setup, requestBody and requestParam validation, group and nested validation, collection handling, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation in Spring MVC and Hibernate Validator.
This article explains the concept of distributed transactions, presents typical microservice scenarios that generate them, and demonstrates a complete implementation using RocketMQ transactional messages and SEATA, including database schema, producer and consumer code, transaction listeners, and idempotent consumption handling.
This article explains how to design an open API authentication mechanism by creating app credentials, storing them in a MySQL table, generating short‑lived access tokens with a utility class, exposing a token endpoint, and securing all /openApi/* routes with a Spring interceptor, complete with code examples.
This article explains why browsers enforce same‑origin policies, presents common CORS solutions such as the @CrossOrigin annotation, gateway integration with Spring Cloud Gateway, and using HttpClient, and provides detailed configuration and code examples for implementing these approaches in a Java backend project.
This article provides a comprehensive tutorial on implementing Single Sign-On using the Central Authentication Service (CAS), covering its concepts, features, architecture, environment setup, server and client configuration, and testing procedures with detailed code examples for Java developers.
This article presents a comprehensive Spring Boot tutorial on implementing non‑intrusive login authentication using three techniques—Filter, Interceptor, and AOP with custom annotations—plus extensions such as ThreadLocal storage and a Spring MVC argument resolver, complete with project setup, Maven dependencies, and test screenshots.
This article presents a comprehensive guide on designing a unified JSON response structure, implementing global exception handling with @ControllerAdvice, and configuring Logback for console and file logging in Spring Boot applications, complete with code examples and best‑practice recommendations.
This article describes how to design an open API interface that issues time‑limited access tokens, defines the supporting database schema, implements token generation utilities, creates a token‑issuing endpoint, and secures all open‑API calls with a Spring MVC interceptor.
This tutorial walks you through installing Devtron on Kubernetes, creating additional Kind clusters, adding them as managed clusters, configuring environments, adding custom Helm repositories, and deploying a sample Spring Boot application across multiple clusters using Devtron's UI and chart groups.
This article introduces MinIO as a high‑performance, cloud‑native object storage solution, explains its key features and use cases, provides step‑by‑step Docker installation commands, and demonstrates how to integrate MinIO with Spring Boot through Maven dependencies, configuration, utility classes, service, and controller code.
This article explains the principles and workflow of Single Sign‑On using OAuth2.0, illustrates the process with a real‑life analogy, and provides a complete Spring Boot example—including authorization server, client configuration, and role‑based access control—suitable for microservice architectures.
This tutorial explains how Spring Boot handles logging with Commons Logging, demonstrates using SLF4J as a facade, shows a complete code example, and covers configuring log output, levels, color, file rotation, and custom patterns for effective backend logging.
This article explains the inner workings of Spring Boot's auto‑configuration mechanism, covering the role of @SpringBootApplication, @EnableAutoConfiguration, spring.factories scanning, conditional annotations, and how configuration properties are bound to beans, with code examples and diagrams for clear understanding.
This article explains why MySQL LIKE queries are inefficient for search, introduces Elasticsearch as a high‑performance alternative, and provides a complete Spring Boot integration tutorial—including version compatibility, Maven dependencies, Java configuration, entity mapping, repository interfaces, service and controller code, and testing steps—to implement CRUD‑style full‑text search for a book catalog.
This article provides a detailed tutorial on using Spring Validation in Spring Boot applications, covering simple and advanced usage such as requestBody and requestParam parameter checks, group validation, nested and collection validation, custom constraints, programmatic validation, fail‑fast mode, and the underlying implementation mechanisms.
This article explains how to design and implement a distributed lock using Redis, Spring AOP annotations, and a scheduled executor to automatically extend lock expiration, providing complete Java code examples, configuration details, testing procedures, and best‑practice recommendations for handling long‑running business operations safely.
This article explains how Spring Boot 3.0.0‑RC1 integrates Micrometer Observation API to provide unified metrics, logging, and distributed tracing, showing the observation lifecycle, configuration steps, sample server and client code, Docker‑compose setup, and notes on native image support for comprehensive application observability.
This tutorial explains how to use Baidu's WebUploader component together with a Spring Boot backend to achieve large file uploads via chunking, breakpoint resume, merging, and instant MD5‑based upload, and also demonstrates a multithreaded chunked download solution with Java client code.
This guide walks through setting up a one‑click automated deployment pipeline for a Spring Boot application using Docker and Jenkins on CentOS 7, covering Docker installation, Jenkins container setup, required plugins, job configuration, building, testing, and running the project.
This article documents a step‑by‑step solution for preventing XSS attacks in a Spring Boot application, covering input validation, a custom HttpServletRequestWrapper, filter registration, and Jackson serializers/deserializers to escape malicious HTML both on request parameters and JSON payloads.
Java SPI is a lightweight plug‑in mechanism that decouples service contracts from implementations using a META‑INF/services configuration file and the ServiceLoader class, enabling dynamic loading of providers as demonstrated with simple examples and applied in frameworks such as JDBC, Spring Boot, Apache Commons Logging, and Dubbo.
This article provides a comprehensive guide to building a microservice ecosystem with Spring Cloud Alibaba, covering essential modules such as service registration, load balancing, configuration, messaging, gateway, fault tolerance, distributed transactions, tracing, and task scheduling, and showing how to integrate them with practical code examples.
This guide explains how to use Baidu's WebUploader component together with a Spring Boot backend to implement large file uploads by splitting files into chunks, supporting breakpoint resume, MD5‑based instant upload, and also provides a parallel download client using HTTP range requests.
This article walks through building a low‑code platform that automatically creates Spring Boot REST endpoints from plain SQL definitions, covering datasource configuration, dynamic request mapping, SQL execution, and optional Swagger documentation generation.
This article explains how to secure Spring Boot APIs by encrypting request and response bodies with symmetric AES, handling signatures, and configuring Jackson serialization to preserve enum and date formats, providing complete code examples and debugging insights.
This article explains how to protect a Spring Boot application from XSS attacks by validating input, wrapping HttpServletRequest, creating a servlet filter, and customizing Jackson serialization/deserialization to safely handle both form parameters and @RequestBody JSON payloads.
This tutorial explains how to deploy a MinIO object‑storage service using Docker on Linux/macOS and Windows, configure a Spring Boot backend with MinIO client libraries, and build a Vue + Element‑UI front‑end for various file‑upload methods, providing complete code examples and deployment steps.
This article explains why @RequestBody conflicts with Swagger in Spring Boot, outlines two common but cumbersome work‑arounds, describes a Swagger API timeout caused by Groovy's MetaClass, and provides a concise configuration fix that eliminates both the timeout and the compatibility issue.
This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master and slave data sources, implementing a routing DataSource, managing context with ThreadLocal, defining a custom @DataSourceSwitcher annotation, and applying AOP to switch between read and write operations.
This guide walks you through integrating MyBatis with Spring Boot, covering basic CRUD operations, dynamic SQL constructs like if, choose, where, set, foreach, as well as advanced mapping techniques, pagination plugins, and practical code examples to help you master MyBatis in real-world projects.
Spring Boot 3.0 RC1 arrives with 135 enhancements, native image generation via GraalVM, JakartaEE 9 migration, Java 17 upgrade, and new auto‑configuration features for Spring Data JDBC, Prometheus, and Log4j2, while the 2.7.5 and 2.6.13 releases focus on bug fixes and dependency updates.
This article provides a detailed walkthrough of Spring and Spring Boot's bean lifecycle, explaining each extension point—from ApplicationContextInitializer to CommandLineRunner—illustrating their usage with code examples and describing practical scenarios for customizing bean creation, initialization, and destruction.
Spring Boot 2.7.5 has been released with over 30 bug fixes and dependency upgrades, includes details on configuration comment detection, Kafka auto‑configuration changes, PEM certificate handling, and provides guidance on switching from the unavailable Alibaba Cloud Maven mirror to Tencent Cloud’s mirror.
Spring Boot 3.0 introduces built‑in GraalVM AOT support, adding new core, bean, and context modules, aot.factories configuration files, and runtime hints such as HttpMimeTypes and CodecConfigurer, enabling developers to replace spring‑native with native AOT extensions for custom resources and reflection.
This article walks through adding complete observability to Spring Boot 3 applications using Micrometer's Observation API, covering metrics, tracing, log correlation, configuration, code examples for both server and client, and even native image support for production-ready monitoring.
This article explains how to create a Spring Boot starter that automatically registers XXL-Job executors and job handlers to the scheduling center, eliminating manual configuration through code examples, API analysis, and step‑by‑step implementation details.
Spring Framework 6.0 introduces comprehensive GraalVM AOT support, adding new modules such as GraalVM feature, AOT core, and JavaPoet, along with aot.factories configuration files that enable developers to customize native image generation, replace Spring Native, and manage runtime hints for beans, context, and other components.
This tutorial demonstrates how to apply before, after, and custom filter functions to Spring WebFlux RouterFunction routes, shows a complete handler and router configuration example, and explains the use of UriComponentsBuilder for flexible URI construction in Java backend applications.
The article analyzes a weekend outage of a Spring Boot microservice where all HTTP requests timed out, tracing the root cause to Caffeine's synchronous cache eviction lock being blocked by a long‑running compute operation, and proposes using AsyncCache with a dedicated thread pool to avoid similar contention.
This article explains how Spring Boot 3.0.0‑RC1 integrates Micrometer Observation to provide unified metrics, logging, and distributed tracing, showing the required dependencies, configuration, code examples for both server and client, and how to visualize data with Prometheus, Grafana, Loki, and Tempo.
This article walks through Spring Boot 2.3's session auto‑configuration process, detailing how core SessionConfiguration classes are registered, how the appropriate SessionRepository is selected based on store type, and how the SessionRepositoryFilter wraps requests and responses to manage session data with implementations such as Redis.
This guide shows how to replace static cron‑based scheduling in a Spring Boot application with dynamic, runtime‑adjustable tasks by reading cron expressions from an external file and providing REST endpoints to modify both cron and millisecond intervals.
This guide explains how to upgrade to Alipay’s new transfer interface, configure the required certificates, add the SDK dependency, and implement Spring Boot components and utility classes for secure fund transfers using the alipay.fund.trans.uni.transfer API.
This tutorial explains how to set up Graylog for centralized log aggregation using Docker Compose, configure its inputs, and integrate a Spring Boot application with Graylog via Logback GELF, including search syntax examples for effective log analysis.
This article explains how to protect time‑consuming business operations by using Redis as a distributed lock together with Spring AOP, covering annotation design, aspect implementation, lock acquisition, automatic renewal via a scheduled executor, and practical testing examples.
This article provides a step‑by‑step tutorial on adding MyBatis‑Plus to a Spring Boot project, covering dependency setup, configuration, entity annotations, CRUD operations, pagination, logical deletion, enum handling, automatic field filling, multi‑datasource support, and testing with full code examples.
This article explains why and how to split a Spring Boot project into Maven modules, defines a common framework with clearly separated modules such as api, base, rpc, service, interaction, and start, and provides practical steps and code snippets for managing dependencies in complex backend applications.
This guide explains how to use Spring Boot's RouterFunction API to create, combine, and nest reactive routes with RequestPredicates, demonstrating practical code examples for GET, POST, and complex route compositions in a Spring WebFlux application.
This article walks through diagnosing memory pressure in a multi‑service Spring Cloud Alibaba project, applying JVM tuning, installing GraalVM and Spring Native, configuring Maven and Docker Buildpacks, and finally building and running a native Spring Boot image that starts in milliseconds and consumes only a few dozen megabytes of RAM.
This article provides a step‑by‑step guide to building a Spring Boot permission management system using Spring Security, Spring Data JPA, Thymeleaf and Bootstrap, covering database design, entity classes, Maven setup, security configuration, dynamic menu loading, front‑end rendering and testing with full source code examples.
This tutorial walks through building a simple Dubbo‑Nacos integration using Spring Boot, covering environment setup, Maven project structure, dependency management, service interface definition, provider and consumer modules, configuration files, and a test call, enabling rapid development of high‑performance Java microservices.
This tutorial explains how to address memory constraints when deploying multiple Spring Boot microservices on a single 2‑CPU, 4‑GB server by applying JVM tuning, installing GraalVM, configuring Spring Native 0.11.1 with Maven plugins, building native images, and deploying them via Docker, achieving startup times in milliseconds and memory consumption around 28 MB.
This article explains nine practical methods for reading files placed in the resources folder of a Spring Boot project, covering classloader resource retrieval, URL decoding, getFile(), getResourceAsStream, ClassPathResource, absolute paths, and environment‑variable based approaches, each with code examples.
This article provides a comprehensive guide to upgrading Spring Boot to version 2.7, detailing common issues such as missing dependencies, logging conflicts, circular bean references, Swagger configuration changes, Flyway compatibility, JUnit version mismatches, and JSON Long precision loss, along with concrete code‑based solutions.
This tutorial walks through installing MinIO with Docker on Linux/macOS and Windows, configuring a Spring Boot backend with MinIO Java client, creating a reusable component for file upload, and implementing three Vue/Element‑UI front‑end upload methods, complete with code snippets and screenshots.
The Spring Boot 3.0.0 M1 release upgrades the Java baseline to 17, migrates all Java EE APIs to Jakarta EE, removes several legacy components, updates a long list of Spring and third‑party dependencies, and outlines the upcoming milestone schedule for the framework.
After upgrading to Spring Boot 2.7.1 (Spring Framework 5.3.21), the execution order of @Around, @Before, and @After advice changes, leading to ThreadLocal data loss inside @Around, and the article explains the cause, reproduces the issue, and recommends using only @Around for reliable logic.
This article demonstrates how to use RabbitMQ's delayed‑queue plugin together with Spring Boot to create a lazy exchange, configure a durable queue, send messages with a specified delay, and consume them, providing complete Java code examples and explaining why this approach outperforms traditional Redis, database polling, or JVM DelayQueue solutions.
This article explains how Spring Boot’s auto‑configuration uses @ConditionalOn annotations and related Condition classes to conditionally register beans, outlines the key internal components, and demonstrates the mechanism with a WebSocketServletAutoConfiguration example.
This article explains how Java developers can use Maven’s dependency‑management features to create a centralized version‑control system that unifies third‑party library versions across multiple modules and services, reducing upgrade pain, avoiding version conflicts, and establishing a solid foundation for scalable backend architecture.
This article introduces Spring Native, explains how native images built with GraalVM can reduce Spring Boot startup time to under 100 ms, walks through environment setup, project initialization, Docker image creation, performance testing, and provides troubleshooting tips for common issues.
This tutorial demonstrates how to create Spring Boot scheduled tasks whose execution intervals can be changed at runtime using both CronTrigger and PeriodicTrigger, providing REST endpoints to update the cron expression or timer value dynamically.
This article explains how a company built Robustdb, a lightweight client‑side read/write splitting solution to replace Atlas, detailing its background, routing core, method‑level control, dynamic data source management, performance gains, and providing code examples for implementation.
This article explains how to protect time‑consuming business operations in a Spring Boot application by creating a custom @RedisLock annotation, using Redis as a distributed lock via AOP, implementing automatic lock renewal with a ScheduledExecutorService, and handling lock release and thread interruption.
This article explains how to build a lightweight, single‑machine configuration center for Spring Boot micro‑services, detailing the core classes, file scanning, variable pooling, environment initialization, YAML conversion, controller endpoints, and runtime property updates, while also discussing current limitations and future improvements.
This tutorial provides a complete, code‑rich example of integrating Dubbo with Nacos using Spring Boot, covering environment setup, Maven project structure, module creation, configuration files, Java source code, and testing the RPC service call.
This article details the investigation of an unexpected native memory consumption issue in a Spring Boot service, describing how JVM and system‑level tools were used to pinpoint the leak caused by the Spring Boot loader's Inflater usage and how configuring MCC scan paths or upgrading Spring Boot eliminated the problem.
Spring Boot 2.7.4 introduces official support for JDK 19, includes numerous bug fixes such as H2 console logging issues and Hazelcast configuration problems, and upgrades a wide range of dependencies from Byte Buddy to Spring Framework, enhancing stability and compatibility for Java developers.
This guide walks through creating a self‑signed SSL certificate with JDK’s keytool, configuring Spring Boot to use the PKCS12 keystore, redirecting HTTP to HTTPS, and alternatively obtaining a free FreeSSL certificate, covering necessary code, configuration files, and deployment steps for both Windows and Linux environments.
After migrating a project to the MDP framework based on Spring Boot, the system repeatedly reported high swap usage despite a 4 GB heap configuration, leading to an investigation that uncovered native memory consumption caused by unchecked JAR scanning and allocator behavior, which was resolved by limiting scan paths and updating Spring Boot's inflater implementation.
This article explains how Spring Boot's auto‑configuration works, detailing the role of @SpringBootApplication, @EnableAutoConfiguration, the spring.factories mechanism, conditional annotations, and how configuration properties are bound to beans such as ServerProperties, providing a clear understanding for developers and interview preparation.
