This guide demonstrates how to use Spring State Machine to elegantly manage order status changes by defining states, events, configuring transitions, and implementing listeners, providing Maven dependencies and Java code examples for building extensible, event‑driven workflows in backend applications.
This article demonstrates two practical methods for restricting request IPs—configuring allow/deny rules in Nginx and building a Spring Boot whitelist check using a custom HandlerInterceptor, complete with database schema, service logic, and MVC configuration.
This article walks through creating a Spring Boot project, handling IDE setup, managing Spring Cloud and Kafka version compatibility, using Maven for dependency management, and provides essential scaffold code such as global exception handling, logging aspects, CORS configuration, and Swagger integration.
The article details how a Java SDK for a CIM instant‑messaging system was redesigned using Java 8+ features and the Builder pattern, introduced a lightweight proxy resembling RPC frameworks with dynamic‑URL support, and added comprehensive integration tests that verify automatic client reconnection and reliable message delivery across clustered servers.
This article presents ten practical techniques—including built‑in annotations, custom constraints, server‑side checks, internationalized messages, validation groups, cross‑field rules, exception handling, testing, and client‑side considerations—to help developers implement robust validation in Spring Boot applications.
This article walks through Spring Boot’s built‑in utilities—including request logging with CommonsRequestLoggingFilter, request/response wrappers, the OncePerRequestFilter base class, and AOP helpers like AopContext, AopUtils, and ReflectionUtils—showing how to configure and apply them in real code.
This article provides a comprehensive guide to using Alibaba's JetCache in Java Spring Boot projects, covering dependency setup, configuration of local and remote caches, annotation‑based caching, API usage, testing procedures, and troubleshooting common integration errors.
This article provides a comprehensive, step‑by‑step guide to using Spring Boot 3's @ComponentScan annotation, covering basic usage, package filtering, include/exclude filters, lazy initialization, custom name generators, scoped proxies, and custom scope resolvers, complete with runnable code samples and output screenshots.
This article walks through the design and implementation of symmetric request/response encryption for a Spring Boot API, covering requirement analysis, data models, custom ControllerAdvice for decryption and encryption, serialization challenges with FastJson and Jackson, and final configuration to keep encrypted payloads consistent across Android, iOS, and H5 clients.
This article explains how to use Spring Boot's built‑in request logging, request/response wrappers, OncePerRequestFilter, and AOP utility classes such as AopContext, AopUtils, and ReflectionUtils, providing configuration snippets and practical code examples for backend developers.
This article explains what Tomcat is, its core functions, how to set up a simple servlet manually, and why Spring Boot hides Tomcat by default while still allowing you to switch to alternatives like Jetty or Undertow.
This article introduces Alibaba's JetCache Java caching framework, explains how to integrate it with Spring Boot and Redis, provides detailed configuration and code examples for local, remote, and multi‑level caches, and covers testing procedures and common error resolutions.
This article introduces four Java HTTP client libraries—Java HttpClient, Apache HttpComponents, OkHttp, and Spring WebClient—explains their key features, provides async GET and sync POST code examples for each, and offers guidance on selecting the right client for Spring Boot and plain Java projects.
Bean Searcher is an open‑source, Apache‑2.0 licensed ORM search engine that outperforms MyBatis by up to 100×, offering one‑line multi‑table joins, pagination, dynamic sorting, field aggregation, and extensive extensibility, with simple Spring Boot integration and customizable components for rapid backend development.
This comprehensive tutorial explains how to design and implement RESTful APIs with Spring Boot 3.2.5, covering all major HTTP methods (GET, HEAD, POST, PUT, DELETE, PATCH), best‑practice endpoint design, response handling, status‑code usage, pagination, filtering, versioning, caching, and security considerations.
This article explains how to create a consistent JSON API response format—including custom status codes, message fields, and a Result wrapper—by using a @ResponseResult annotation, an interceptor, and ResponseBodyAdvice in Spring Boot, while also offering tips for optimization and error handling.
The article explains why UUIDv4 primary keys hurt performance and storage, then demonstrates how to replace them in a Spring Boot 3.3 application with a custom Snowflake‑based 64‑bit ID generator, providing full Maven setup, configuration, entity, service, REST controller, and Thymeleaf UI example.
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, covering dependency setup, mapper changes, query construction, pagination, and practical code examples.
This article walks through creating a Spring Boot 3 application from scratch, demonstrating how to customize the ApplicationContext, embed a Tomcat server, define a custom SpringApplication class, configure web components, and test REST endpoints, providing complete code snippets and explanations for each step.
This guide walks through installing kkfileviewer in a Docker container, building and running the image, then shows how to add MinIO support to a Spring Boot project with Maven dependencies, configuration classes, utility methods, and REST endpoints for file upload and preview.
This article explores Spring Boot's asynchronous task and request mechanisms, detailing how @EnableAsync, @Async, @EnableScheduling, and @Async annotations configure thread pools, examines the underlying source code, and demonstrates custom configurations for executors and schedulers to control concurrency.
This article provides a comprehensive analysis of how Spring Boot integrates Log4j2 (and Logback), detailing the internal logging architecture, configuration options, initialization flow, logger groups, and how to perform hot updates of logger levels via the LoggersEndpoint or custom APIs.
This tutorial walks through six practical techniques—@Qualifier, @Primary, @Profile, collection injection, @Priority, and custom @Conditional—to control which implementation of a Spring Boot interface is autowired, complete with code examples and usage tips.
This article explains the purpose of Spring Boot's ApplicationRunner and CommandLineRunner interfaces, demonstrates common startup tasks such as data initialization, configuration loading, cache population and license verification, compares their parameter handling, shows how to control execution order with @Order, and reveals the internal call chain that Spring uses to invoke these runners.
This article explains how to configure a Spring Boot scheduled task to execute just once, covering three approaches—specifying a start time with TaskScheduler, using @Scheduled with an initial delay, and creating a custom PeriodicTrigger—complete with runnable code examples.
This article explains how Spring Boot can handle HTTP requests asynchronously using Callable, WebAsyncTask, and DeferredResult, detailing the underlying servlet workflow, thread‑pool configuration, and when asynchronous processing truly improves throughput versus CPU‑bound workloads.
This article introduces the Forest Java HTTP client, explains its architecture and dynamic‑proxy mechanism, and provides step‑by‑step Spring Boot examples—including dependency setup, configuration, declarative interfaces, request annotations, parameter handling, and programmatic usage—so developers can quickly adopt declarative HTTP calls in their backend services.
This article continues the open‑source design series by detailing the remaining design points of the Lantu Pay SDK, including the end‑to‑end request chain, the Post method with retry support, the use of strategy and template method patterns, and a custom @Require annotation for mandatory parameter validation.
This article explores four common batch‑update techniques in MyBatis, compares their performance, shows how to configure Druid and Spring Boot to allow multi‑statement execution, and provides practical code examples and configuration tips for reliable large‑scale data updates.
This article introduces RabbitMQ, explains its core features and messaging model, discusses why to use it for asynchronous, decoupled, and throttled processing, and provides step‑by‑step installation instructions for macOS, Windows, and CentOS along with Java code examples for configuring and using delayed messages via the rabbitmq_delayed_message_exchange plugin.
By implementing a plug‑in architecture that uses a custom URLClassLoader to load and unload JAR‑packaged governance tasks at runtime, the Spring Boot application can dynamically register Spring beans and XXL‑Job handlers, remove them cleanly, update configuration via YAML or Nacos, and package the solution with Maven Shade without restarting services.
Learn how to enable and test Java 21 virtual threads in Spring Boot 3.2.5, compare their throughput against platform threads with JMeter, and explore performance limits through sample code and benchmarks, revealing when virtual threads excel and their constraints for CPU‑bound tasks.
This article explains how Spring Boot integrates Log4j2, details the internal logging initialization process, describes logger and LoggerConfig relationships, and demonstrates how to hot‑update logger levels using LoggersEndpoint or custom endpoints without restarting the application.
The article explains how exposed API endpoints can be intercepted and altered, and presents practical security measures—including HTTPS, encrypted parameters, timestamp‑based signatures, and a Spring Boot filter implementation—to detect and block tampering and replay attacks in a Java backend.
This article explains how to design a two‑level leave‑approval process using the Activiti BPMN engine, covering diagram creation, Spring‑Boot configuration, deployment, task handling, exclusive gateways, database tables, API overview, and practical tips for extending the workflow.
This guide explains how to use Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, and maven-jar-plugin to package a Spring Boot application into an executable JAR with external lib dependencies, and shows how to deploy the resulting artifacts in a Docker container using a custom Dockerfile.
This article explains Xxl-Job’s lightweight distributed scheduling architecture, covering the admin console, executor startup, JobHandler initialization, HTTP server registration, task triggering logic with scheduling threads, fast/slow thread pools, routing and blocking strategies, and result callbacks, illustrated with code snippets and diagrams.
This article introduces Spring Boot's new RestClient, compares it with RestTemplate and WebClient, and provides detailed code examples for creating clients, performing GET/POST/PUT/DELETE requests, handling errors, customizing interceptors, and enabling load‑balanced service discovery.
Learn how to protect personal data in Spring Boot 3.2.5 applications by customizing Logback's PatternLayout and appender to mask fields such as name, phone, password, and email, with step‑by‑step code examples, configuration snippets, and handling of object logging.
This article demonstrates how to build a flexible API rate‑limiting solution in Spring Boot by combining a HandlerInterceptor, Redis counters, and custom annotations with reflection, covering configuration, code examples, mapping rules, time‑window nuances, path‑parameter handling, and real‑IP considerations.
This article explains how to integrate Spring Boot with WebSocket to create a lightweight instant‑messaging system, covering dependency setup, configuration classes, core server code, front‑end integration, essential IM modules, common deployment challenges, and provides complete example code and demos.
This guide walks you through the pain points of environment setup, shows step‑by‑step creation of a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot and Kafka, and provides ready‑to‑use Maven configurations, global exception handling, logging, CORS, Swagger, and a curated list of useful development tools.
This tutorial walks through creating a Maven‑based Spring Boot backend project with multiple modules, configuring pom.xml files, application properties, and logging, then adds a scheduled Douyin hot‑search crawler using OkHttp, demonstrating full end‑to‑end setup for a web service.
This article provides a comprehensive analysis of how Spring Boot 2.7.2 works with Log4j2 2.17.2, covering Log4j2's core components, Spring Boot's logging configuration options, the internal startup sequence, the LoggersEndpoint for runtime level changes, and custom hot‑update techniques, all illustrated with code snippets and diagrams.
This article explains why API versioning is essential for Spring Boot REST services and compares three common approaches—URI versioning, request‑header versioning, and media‑type versioning—while offering guidance on selecting a method and handling API deprecation.
This article walks through practical ways to perform batch updates in MyBatis, compares foreach, case‑when, and INSERT…ON DUPLICATE KEY techniques, explains common Druid WallFilter restrictions, and shows how to enable multi‑statement execution via JDBC and Spring configuration.
This guide explains why structured logging is essential for observability, shows how Spring Boot 3.4 adds out‑of‑the‑box support for Elastic Common Schema and Logstash formats, and provides step‑by‑step configurations and code examples for console output, file logging, custom fields, and custom formatters.
This article walks through the design and implementation of a Spring Boot Starter for the Lantu Pay SDK that supports personal sign‑up, covering project structure, configuration classes, HTTP layer abstraction using strategy and template patterns, and request/response model design with concrete code examples.
This article examines common pitfalls in Spring Boot controller implementations, demonstrates how excessive if‑else checks and business logic in controllers degrade code quality, and provides clean, refactored examples using @Valid validation, concise error handling, and a global exception handler to achieve more maintainable backend services.
This article explains why a plain Dockerfile for a Spring Boot fat JAR is inefficient, introduces Spring Boot's layered JAR format, and provides a multi‑stage Dockerfile that leverages layer caching to speed up builds and reduce runtime overhead.
This article provides a step‑by‑step tutorial on Apollo’s concepts, features, model, namespace handling, client design, high‑availability considerations, project creation, configuration management, Spring Boot client implementation, testing across environments, clusters and namespaces, and deployment on Kubernetes with Docker.
This article reviews several ways to integrate WebSocket with Spring Boot, focusing on the three mainstream approaches—Javax, WebMVC, and WebFlux—by providing server and client configurations, code examples, and practical tips such as handling ping/pong, handshake interceptors, and reactive streams.
This guide explains why pre‑loading initial data is essential for Spring Boot applications and demonstrates four practical methods—CommandLineRunner/ApplicationRunner, bean initialization with @PostConstruct, SQL script execution, and @Sql annotation for tests—complete with code snippets and configuration details.
This article demonstrates multiple methods to add text or image watermarks to PDF documents in a Spring Boot application, covering Java libraries such as Apache PDFBox, iText, Ghostscript command line, Free Spire.PDF, and Aspose.PDF, with code examples and usage instructions.
This article explains how Spring Boot 3.2.5 implements the RFC 7807 Problem Details specification, covering the core abstractions, code examples for creating ProblemDetail and ErrorResponse objects, and practical patterns for global exception handling in Spring MVC applications.
This article explains how Spring Boot’s @Transactional annotation works, introduces programmatic transaction management, and demonstrates how to create custom transaction hook functions with TransactionSynchronizationManager and TransactionSynchronization to execute custom logic at each transaction phase, improving robustness and maintainability.
This tutorial explains how to integrate Jasypt into Spring Boot 3.2.5, configure encryption keys, encrypt sensitive properties, use the ENC() syntax, and retrieve decrypted values at runtime, providing a complete solution for protecting configuration data.
This article provides a comprehensive guide to Jackson’s most frequently used annotations, core modules, and extension points in Spring Boot, illustrating each feature with concrete Java code examples that show how to customize serialization, deserialization, property handling, and polymorphic type processing.
This guide explains how to use LangChain4j Spring Boot starters to configure OpenAI models, create declarative AI services with @AiService, and run practical examples such as a customer‑support agent and a simple HelloWorld program, covering required dependencies, properties, and code snippets.
This article provides a comprehensive introduction to Spring Cloud OpenFeign, comparing it with Feign and HttpExchange, and walks through practical setup, client declaration, custom configuration, interceptors, error handling, timeout and logging settings with full code examples for Spring Boot 3.2.5.
This article explains the essential duties of a Spring MVC Controller, identifies common pitfalls such as duplicated validation and inconsistent responses, and demonstrates how to introduce a unified result wrapper, ResponseBodyAdvice, proper message‑converter ordering, JSR‑303 validation, custom validators, and global exception handling to produce concise, maintainable backend code.
This article explains why validating file types is essential for security and demonstrates six Java-based techniques—including Java 7 API, URLConnection, MimeTypesFileTypeMap, jMimeMagic, Apache Tika, and Spring's MediaTypeFactory—to reliably determine a file's MIME type under various conditions.
Learn step‑by‑step how to create a custom Spring Boot starter, configure its properties, define services and controllers, register it via spring.factories, and then integrate the starter into other projects with Maven dependencies and configuration files.
This article explains why Spring Cloud Gateway can return duplicate Access-Control-Allow-Origin and Vary headers, analyzes the request processing flow, and provides two solutions—using the built‑in DedupeResponseHeader filter with retention strategies or implementing a custom CorsResponseHeaderFilter—to eliminate the CORS error caused by multiple header values.
This article explains how to implement invisible token refresh for authentication servers using Spring Boot gateway filters, JWT handling, Axios interceptors, and a client‑side timer, compares client‑ and server‑side approaches, and provides complete code examples and practical recommendations.
This article provides a comprehensive guide to using Spring Boot’s @RequestMapping annotation, covering path definitions, HTTP methods, headers, produces/consumes, path variables, parameters, fallback handling, and advanced options, with practical curl commands and code snippets for each scenario.
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 apply asynchronous processing to improve throughput.
This article explains why centralized log collection is essential for multi‑environment services, introduces Graylog as a lightweight alternative to ELK, details Filebeat's role and workflow, provides configuration examples, shows how to deploy both Filebeat and Graylog via Docker or packages, and demonstrates integration with Spring Boot and log search techniques.
Spring Boot 3.4 adds built‑in support for structured logging with ready‑made JSON formats such as Elastic Common Schema, lets you configure console or file outputs, enrich logs via MDC or the fluent API, and enables custom formatters—including a JsonWriter‑based example—for fully tailored, machine‑readable log entries.
This article walks you through designing, deploying, and managing a multi‑level approval workflow using the Activiti engine, covering BPMN diagram creation, Spring Boot integration, database schema, API usage, code examples, and best practices for extending processes without additional code.
This article walks through using JetCache with Spring Boot 3.2.5, covering its features, Maven dependency setup, YAML configuration, annotation-based caching, programmatic cache creation, statistics monitoring, and deprecated APIs, all illustrated with code snippets and screenshots.
This article explains how to protect Spring Boot web applications from Cross‑Site Scripting (XSS) attacks by introducing two main defense mechanisms—custom @XSS annotations and servlet filters—complete with implementation details, code examples, configuration steps, and testing results.
This article explains several strategies for dynamically updating Spring Boot application properties—such as using prototype‑scoped beans, @RefreshScope with Spring Cloud, external configuration files, and custom PropertySource updates—so that changes take effect without restarting the service.
This guide walks through creating a Spring Boot 3.3.3 microservice permission framework with OAuth2, covering technology stack, core features, project structure, step‑by‑step service startup, token acquisition, API calls, and provides the complete source repository for hands‑on experimentation.
This guide explains how to protect a Spring Boot release package from source leakage by comparing code obfuscation and encryption, detailing the configuration of the classfinal‑maven‑plugin, launch commands with and without passwords, and binding the encrypted jar to a specific machine.
This tutorial provides a step‑by‑step guide to set up a complete Jenkins‑Docker‑Spring Boot pipeline on CentOS 7, covering Docker installation, Jenkins deployment, required plugins, Maven configuration, job creation, testing, and running the packaged application with Docker.
This guide explains how to enable and use Spring Boot's @Async and @Scheduled annotations, configure various TaskExecutor and TaskScheduler implementations, leverage new Spring 6.1 pause/resume and virtual‑thread features, and apply graceful shutdown for both asynchronous and scheduled jobs.
This article introduces ShardingJDBC, a Java middleware that simplifies sharding, read/write separation, and distributed transactions, and provides a step‑by‑step Spring Boot example with configuration, code snippets, and verification of its core features.
This guide explains how to automatically inject userId and orderId into log statements in a Spring Boot microservice by configuring Log4j2 patterns, using MDC to store context variables, and creating a custom @UserLog annotation with an AOP aspect that populates the MDC before method execution.
This article walks through the challenges of setting up a Java backend environment, demonstrates how to create a Spring Boot project, explains version compatibility between Spring Cloud, Spring Boot, and Kafka, and provides reusable code snippets for exception handling, logging, CORS, Swagger, and response wrapping, along with recommended tools.
This tutorial explains how to implement IP‑and‑URL rate limiting in a Spring Boot application by creating a custom HandlerInterceptor that tracks request counts in Redis, uses a distributed lock to enforce limits, and registers the interceptor to protect services from malicious or excessive traffic.
This article explains how Spring Boot supports asynchronous request processing using Servlet 3.0 features and four approaches—AsyncContext, Callable, WebAsyncTask, and DeferredResult—provides code examples, thread‑pool configuration, and guidance on when to apply async handling to improve throughput.
This article explains the most commonly used Spring Boot annotations—including @SpringBootApplication, @RestController, @RequestMapping, @Autowired, @Value, @Component, @Service, @Repository, and @Configuration—providing clear descriptions and practical code examples for each.
This tutorial explains how to perform partial updates of RESTful resources using the HTTP PATCH method and JSON Patch format in Spring Boot 3.2.5, covering all RFC‑6902 operations with code examples and a complete working controller implementation.
This article explains the Spring Boot startup mechanism, covering the @SpringBootApplication entry annotation, its constituent annotations, the role of SpringApplication.run, and the step‑by‑step initialization flow that powers Java backend applications.
This article provides a step‑by‑step guide to creating a Spring Boot starter for enterprise‑grade object storage services, explaining OSS concepts, Amazon S3 basics, project setup, Maven dependencies, configuration classes, template interfaces, implementation details, auto‑configuration, packaging, and testing.
This guide explains how to integrate the mybatis-plus-generator-ui library into a Spring Boot project, configure database connections, launch the web UI, and use its customizable templates and naming converters to generate Entity, Mapper, Service, and Controller classes for multiple databases with a single click.
Learn how to seamlessly integrate the open‑source p6spy tool into a Spring Boot 3.2.5 application to automatically log SQL statements, measure execution times, customize logging formats, and fine‑tune database performance using both MyBatis and JPA examples.
This article introduces the open‑source XXL-Job distributed task scheduling framework, explains its architecture and communication design, and provides a step‑by‑step hands‑on tutorial covering server deployment, executor configuration, task development (annotation, API, sharding), execution, and log inspection, with code examples and screenshots.
Apache Tomcat is the underlying servlet container and web server that Spring Boot automatically embeds via the spring‑boot‑starter‑web dependency, but junior developers often miss its core roles—managing servlet lifecycles, serving static resources, and compiling JSPs—so learning Tomcat (or swapping it for Jetty by adjusting Maven exclusions) clarifies what Spring Boot abstracts and enables flexible container choices.
This guide explains how to set up a Spring Boot project, add the Tess4J dependency, configure language data, implement an OCR service and REST controller, and test both local file uploads and remote image URLs for text recognition.
Learn how to integrate the open‑source DynamicTp framework into Spring Boot 2.7, configure its core parameters, enable real‑time monitoring, alerts, and Nacos‑based dynamic adjustments, while exploring code examples, dependency setup, and practical usage for robust thread‑pool management.
This article provides an in‑depth overview of the WebSocket protocol, covering its fundamentals, advantages, lifecycle, message formats, Java API usage, Spring Boot integration, performance considerations, and future development directions, complete with practical code examples for both server and client sides.
This article explains how Spring Boot automatically configures a ThreadPoolTaskExecutor for @Async and @Scheduled, shows the default parameters introduced in version 2.1, demonstrates how to inspect and customize them, compares the default executor with SimpleAsyncTaskExecutor, and provides code examples for using @Async, injecting the executor, and defining a custom thread pool to avoid resource‑exhaustion issues.
This article explains how to standardize API responses in Spring Boot by defining a JSON result format, using custom annotations, interceptors, and ResponseBodyAdvice to automatically wrap controller return values, while also discussing status code design, message handling, and code simplification techniques.
This article explains how to implement unified data desensitization in Java Spring Boot applications by creating custom annotations, enums, serializers, and utility methods that automatically mask personal information during JSON serialization, complete with code examples and test results.
This article systematically catalogs every Spring and Spring Boot extension interface—from ApplicationContextInitializer to DisposableBean—illustrates their invocation order with a diagram, explains practical use‑cases, and provides concrete code samples for each hook, enabling developers to tap into the bean lifecycle for custom initialization, monitoring, and cleanup.
This guide explains how to integrate the Logbook library into Spring Boot applications to capture detailed HTTP request and response logs, covering dependency setup, configuration options, output formats, Logback file logging, custom sinks, and RestTemplate interception for comprehensive monitoring and debugging.
This article explains the concept, advantages, design considerations, and step‑by‑step implementation of a multi‑tenant architecture using Spring Boot and Spring Cloud, covering tenant isolation, database strategies, dynamic routing, security configuration, deployment scenarios, and provides complete code examples for building SaaS‑ready applications.
The article explains what a dynamic thread pool is, why static pools are problematic, how to modify core parameters such as corePoolSize, maximumPoolSize, and workQueue at runtime, and provides code examples for monitoring, exposing metrics via Spring Boot Actuator, and integrating with Prometheus‑Grafana, while also listing open‑source implementations like Hippo4j and Dynamic TP.
