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.
This article introduces Quartz, the Java‑based open‑source scheduler behind many distributed task‑scheduling frameworks, compares its RAMJobStore and JDBCJobStore options, shows step‑by‑step Spring Boot integration with code samples, and explains the internal architecture and lifecycle of the scheduler.
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.
This tutorial walks through designing an OAuth2 authentication architecture, configuring Spring Boot services, setting up MySQL schemas, integrating Nacos discovery, implementing security with JWT tokens, and connecting microservices through a Spring Cloud Gateway, while demonstrating all four OAuth2 grant types with code examples.
This article introduces Quartz, a Java job‑scheduling library, explains its core components (Job, Trigger, Scheduler), provides step‑by‑step Maven demos, shows how to integrate it with Spring Boot, configure persistence, manage concurrency, and handle advanced features like cron expressions and calendar exclusions.
This guide demonstrates how to implement Spring Security authentication and authorization using web expression-based rules, custom beans, path variables, multi‑condition expressions, and advanced @PreAuthorize methods, including parameter‑based checks, custom annotations, and custom logic services within a Spring Boot 2.4 application.
This article explains the difference between synchronous and asynchronous calls, demonstrates a synchronous Task example, shows how to convert it to asynchronous execution with Spring Boot's @Async annotation, and introduces Future-based callbacks to coordinate concurrent tasks and measure total execution time.
This article provides a comprehensive guide to using Quartz in Java Spring Boot, covering core concepts, basic and advanced usage—including job creation, triggers, Cron expressions, bean injection, multiple triggers, and persistence with JDBC—complete with code samples and configuration steps.
This article compares the Java Redis clients Jedis, Redisson, and Lettuce, explains their core differences, and provides detailed Spring Boot configuration and code examples for using each client, including RedisTemplate, RedissonClient, and annotation‑based caching.
This article demonstrates how to implement unified global exception handling in a Spring Boot application by defining custom exceptions, creating a @RestControllerAdvice with specific @ExceptionHandler methods, and wiring sample controller endpoints to showcase both system and custom error responses.
This tutorial walks you through setting up a complete CI/CD pipeline on CentOS 7 using Docker, Jenkins, and Spring Boot, covering Docker installation, Jenkins container deployment, plugin and Maven configuration, job creation, Dockerfile setup, and automated project build and run.
This article explains why browsers enforce the Same‑Origin Policy, defines cross‑origin requests, lists the restrictions of non‑same‑origin access, and provides five practical ways—global filter, WebMvcConfigurer, @CrossOrigin annotation, manual header setting, and a custom filter—to enable CORS in Java Spring Boot applications, complete with code examples.
This article provides a comprehensive overview of Spring and Spring Boot's extension points, detailing each lifecycle hook, its purpose, typical use cases, and sample implementations, enabling developers to customize bean initialization, configuration, and shutdown processes with concrete code examples.
This article explains the concept of database read‑write splitting, discusses its limitations, and provides a step‑by‑step guide with Spring Boot code to configure master‑slave data sources, implement dynamic routing, context handling, custom annotations, and AOP for seamless switching.
This tutorial demonstrates how to set up a Spring Security FormLogin authentication flow, including creating a demo project, customizing the login page, configuring security rules, defining users and roles, and testing the login process with custom success and failure handlers.
This guide walks you through configuring the new Alipay transfer API in a Java Spring Boot project, covering certificate placement, property files, Maven dependencies, bean definitions, client configuration, utility methods, and the data models required for secure payments.
This article provides a detailed tutorial on Quartz, a powerful Java scheduling framework, covering its core concepts, basic usage with SimpleTrigger and CronTrigger, advanced features such as multiple triggers, bean injection, and persistence, and includes complete Spring Boot code examples.
This tutorial explains how to install Spring Boot CLI, demonstrates the project layout, creates a Hello World application using Groovy, shows how to use @Grab for dependencies, run tests, package the app into an executable JAR, and generate new projects with the init command.
This guide walks through configuring Spring Security with a custom AuthenticationProvider that authenticates users against a database, covering environment setup, core filter mechanics, custom UserDetails, UserDetailsService, PasswordEncoder implementations, and bean configuration with full code examples.
This comprehensive tutorial walks through the evolution of Sharding-JDBC into ShardingSphere, explains core concepts like sharding, data nodes, and algorithms, demonstrates MySQL master‑slave setup with Docker, and provides step‑by‑step code examples for implementing read‑write separation, horizontal and vertical sharding, and distributed primary keys.
This article explains why a Spring Boot application that runs fine in an IDE may throw NoSuchMethodError or NoSuchFieldError when packaged as an executable jar, and provides systematic steps—including JVM class‑loading flags, Maven enforcer rules, and class‑path inspection—to locate and resolve the root cause.
This article walks through building a QR‑code based login system using Spring Boot, detailing database design, role analysis, required APIs, step‑by‑step implementation, and full Java and JavaScript code for generating QR codes, handling WebSocket communication, and confirming user authentication.
This article explains the core @SpringBootApplication annotation, its composition of @EnableAutoConfiguration, @ComponentScan, and @SpringBootConfiguration, shows its source code, demonstrates custom composite annotations, and details how Spring Boot performs component scanning and automatic bean configuration.
This article explains why traditional application releases cause downtime, introduces maturity levels for nonstop deployment, compares release patterns, details essential technical components such as load balancers and service registries, and provides step‑by‑step graceful‑shutdown procedures using Spring Boot Actuator and Eureka.
