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.
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.
This guide introduces MinIO, an open‑source, S3‑compatible object storage written in Go, outlines its key features and deployment via Docker, and demonstrates step‑by‑step integration with Spring Boot to upload files through the MinIO SDK, including configuration, controller code, and testing.
This article explains how to implement robust retry mechanisms in Java applications by comparing Spring‑Retry's declarative exception‑based approach with Guava‑Retry's flexible result‑oriented strategy, covering dependencies, configuration, policies, back‑off options, annotation usage, and practical code examples.
This article explains how to achieve database read‑write separation in high‑concurrency Java applications by configuring master‑slave data sources, implementing a routing datasource, managing context with ThreadLocal, and using custom annotations with AOP to switch between read and write databases at runtime.
This article introduces an open‑source Spring Boot starter that lets developers integrate, configure, monitor, and visualize thread pools without altering Spring Boot's core implementation, addressing common issues of unmanaged resources and difficult runtime adjustments.
This article demonstrates how to integrate Spring Boot with RabbitMQ using a direct exchange, configuring queues, producers, and two consumers, and explains manual acknowledgment mechanisms (ACK, NACK, Reject) to ensure reliable message processing and handling of consumer failures.
This article presents seven practical Spring Boot performance optimization methods—including asynchronous execution, increasing embedded Tomcat connection limits, component scanning, switching to Undertow, using BufferedWriter, DeferredResult, and AsyncHandlerInterceptor—each illustrated with code samples and explanations for improving Java backend applications.
This article explains a configurable multi‑strategy data‑masking solution for Spring Boot APIs, covering the design of a custom annotation, serializer, AnnotationIntrospector, ObjectMapper integration, and example usage on response objects.
This article provides a comprehensive guide on using the Quartz job‑scheduling library in Java, covering core concepts such as Job, Trigger, and Scheduler, showing Maven setup, sample job and trigger code, Spring Boot configuration, utility classes for creating and managing jobs, handling concurrency, misfire policies, and REST‑based job management.
This guide explains how Spring Security processes authentication and authorization failures, walks through the default exception flow, and demonstrates multiple ways to customize error handling—including custom failure handlers, access‑denied pages, and JSON responses—using Spring Boot 2.4.12.
This article introduces the open‑source MinIO object storage system, outlines its high‑performance and cloud‑native features, provides step‑by‑step Docker installation and UI configuration, and demonstrates how to integrate MinIO with Spring Boot for secure file uploads via SDKs.
This article provides a comprehensive guide on implementing role‑based access control (RBAC) with Spring Security, covering RBAC models, password encryption, in‑memory authentication, JWT integration, custom authentication filters for JSON login, and detailed configuration examples with full source code snippets.
This tutorial demonstrates how to configure Spring Security to selectively intercept requests, permit static resources, enforce role‑based access, and replace the default login page with a custom Thymeleaf view, complete with code examples and screenshots.
This guide explains why Logback is the preferred logging framework for Spring Boot, shows how to add the necessary dependencies, configure console and file appenders, customize log patterns, use rolling policies, apply filters, and optimize logging statements with placeholders, all illustrated with clean XML and Java code examples.
This article explains why a configuration center is essential for microservices, introduces Nacos as a centralized solution, and provides step‑by‑step instructions with code examples for integrating Nacos into Spring Boot, managing Data IDs, namespaces, groups, and dynamic configuration refresh.
This article explains why Logback is the preferred logging framework for Spring Boot, shows how to add the necessary dependencies, configure logback‑spring.xml with appenders, encoders, filters and rolling policies, and provides best practices for efficient log statements in Java code.
