This article demonstrates three practical methods to transform the HTTP request body in a SpringBoot 3.2.5 application before it reaches the controller—using a custom Filter, a RequestBodyAdvice‑based AOP approach, and a HandlerInterceptor—complete with code examples, explanations, and testing results.
This article provides a comprehensive overview of SpringBoot’s most commonly used annotations, covering MVC, bean, JPA, configuration, exception handling, and testing annotations, complete with clear explanations and practical code examples to help developers avoid pitfalls and write cleaner code.
This tutorial explains how to set up IntelliJ IDEA and Docker for one‑click remote deployment of a SpringBoot application, comparing traditional jar deployment with the Docker‑based workflow, and walks through SSH configuration, Docker daemon basics, Dockerfile creation, and IDE deployment settings.
This guide explains how to activate SpringBoot DevTools for hot deployment, integrate Lombok to reduce boilerplate code, and configure the Spring Configuration Processor for property metadata, including necessary Maven dependencies, IDE settings, and build plugin adjustments.
This article explains how to achieve seamless code updates for SpringBoot applications by allowing two processes to share the same port, detailing the underlying servlet container mechanics, the role of DispatcherServlet, and providing a complete Java implementation with step‑by‑step instructions and code samples.
This article details the design, planning, and step‑by‑step implementation of a database table‑partitioning solution for loan and repayment request tables, covering schema decisions, sharding strategy, historical data migration, dynamic synchronization, code examples with ShardingSphere, SpringBoot, and operational considerations for seamless migration.
This article demonstrates three methods for invoking external services in a Spring Boot application—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code examples, configuration steps, and tips for handling headers and tokens.
This article introduces JetCache, an open‑source distributed caching framework built on Spring and Redis, outlines its key features and typical scenarios, and provides step‑by‑step guidance for integrating JetCache into a SpringBoot application with configuration examples and sample code.
This article explains why maintaining up‑to‑date database schema documentation is essential, introduces the Screw tool and its supported databases and output formats, and provides a step‑by‑step SpringBoot 3.2.5 example—including Maven dependency, configuration classes, a generation component, and a test—to automatically produce HTML, Word, or Markdown docs.
When updating a SpringBoot application the old process must be stopped because the new one cannot bind to the same port, but by leveraging Tomcat's embedded container, ServletWebServerFactory, and dynamic port handling you can keep both processes alive and achieve zero‑downtime deployments.
This article explains the purpose and usage of Spring MVC’s @PathVariable annotation, covering basic binding, custom names, class‑level variables, multiple parameters, map injection, regex and optional variables, path‑suffix handling, and how to retrieve variables outside controllers, all with clear code examples.
This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its core concepts, architecture, four‑dimensional configuration model, client design, deployment, and step‑by‑step instructions for creating projects, adding configurations, testing dynamic updates, and running the service in Kubernetes with Docker.
This article presents a detailed case study of Ctrip's large‑scale desktop IT management solution, describing the challenges of handling tens of thousands of office PCs, the full‑link architecture built with Rust, Tauri, SpringBoot and Django, automated health monitoring, fault detection, remediation workflows, security measures, performance optimizations, and the measurable operational improvements achieved.
Fast‑Retry is a high‑performance, asynchronous retry framework for SpringBoot that handles millions of concurrent tasks, offering configurable retry attempts, delay, exception handling, and custom result policies, and outperforms traditional synchronous solutions like Spring‑Retry and Guava‑Retry in throughput and resource usage.
This article details the step‑by‑step process of switching a SpringBoot‑MyBatisPlus application from MySQL to PostgreSQL, covering driver integration, JDBC configuration changes, numerous SQL and type‑conversion pitfalls, and provides ready‑to‑run PostgreSQL scripts for bulk column adjustments and default values.
The article demonstrates how to transform overly complex Spring Boot controllers—filled with repetitive validation and business logic—into clean, maintainable code by using @Valid annotations, concise validation rules, and a centralized exception handler, effectively halving the code size and improving readability.
This article explains why SpringBoot's default @EnableScheduling runs tasks sequentially with noticeable delays, analyzes the underlying single‑threaded scheduler, and provides multiple solutions—including thread‑pool configuration, asynchronous execution, custom executors, and distributed locks—to achieve reliable and scalable scheduled jobs.
This guide explains how to use regular‑expression path variables, property placeholders, class‑level parameters, and suffix‑based content negotiation in SpringBoot 3.2.5, providing code examples, configuration tips, and practical request illustrations for flexible URL routing.
This article explains Spring AOP’s core concepts, shows how proxies are normally created with @EnableAspectJAutoProxy, and details several edge cases—such as implementing Advice, Pointcut, Advisor, or using special bean names—where Spring will not generate a proxy, providing code examples and the resulting output for each scenario.
This article explains how to implement invisible token refresh for authentication systems, covering server‑side gateway filtering in Spring Boot, client‑side Axios interceptors, timer‑based proactive checks, and practical code examples to address token expiration, parsing, and renewal challenges.
This article explains how to achieve seamless code updates for SpringBoot applications by allowing two instances to share the same port, detailing the underlying Tomcat embedding mechanism, DispatcherServlet handling, and providing a complete Java implementation with step‑by‑step instructions and test results.
This article introduces MyBatis‑Mate, an official MyBatis‑Plus extension that provides enterprise‑level capabilities such as sharding, data auditing, field encryption, dictionary binding, data masking, automatic DDL maintenance, dynamic data‑source switching, distributed transaction logging, and fine‑grained data permissions for Spring Boot applications.
The article presents a comprehensive case study of Ctrip's full‑chain desktop operations system, detailing its architecture, cross‑platform Rust/Tauri agents, SpringBoot server, security measures, operational challenges, performance optimizations, and the measurable improvements in fault detection and repair across a massive corporate PC fleet.
This article analyzes the problems of scattered property configuration in SpringBoot projects, designs a database table to store configuration items, implements a configuration loader that injects database values into the Spring environment, and demonstrates testing and best‑practice considerations for a robust backend configuration solution.
This article provides an in-depth overview of common backend interview topics, covering MySQL index structures and storage engines, Redis single‑threaded design and persistence mechanisms, Java transaction ACID properties, SpringBoot auto‑configuration principles, JVM memory regions, class loading, and garbage‑collection algorithms, all illustrated with code examples.
This article explains how to create a unified SpringBoot utility class that builds hierarchical structures such as multi‑level menus, comments, departments, and categories, discusses database design choices like the optional tree_path field, provides a detailed ITreeNode interface, implementation of TreeNodeUtil with code examples, and demonstrates testing and filtering scenarios.
The article critiques overly complex Spring Boot controllers filled with repetitive validation and business logic, demonstrates cleaner implementations using @Valid, Assert, and global exception handling, and provides practical code examples and guidelines for building maintainable backend controllers.
This guide walks through creating a lightweight SpringBoot cache component using custom @Cacheable and @CacheEvict annotations, configuring Redis, implementing an AOP aspect to handle caching logic, and demonstrating usage with sample services and controller endpoints, while also discussing key generation and potential enhancements.
The guide demonstrates how to build a front‑end/back‑end separated captcha login using Spring Boot, Kaptcha and Redis, showing Redis‑based captcha storage with a unique key, Base64 image delivery, and verification logic that replaces traditional session‑based approaches.
This comprehensive guide walks you through Shiro's core concepts, authentication and authorization mechanisms, various realm implementations, session management, distributed session handling with Redis, caching strategies, and step‑by‑step integration of CAS single sign‑on using SpringBoot and pac4j, complete with code samples.
This article explains how to replace Spring Boot's default embedded Tomcat with the high‑performance Undertow server, detailing Undertow's features, providing Maven dependency changes, showing configuration steps, and presenting benchmark results that compare QPS and memory usage, concluding that Undertow is preferable for high‑concurrency Java backend applications.
Learn how to set up a lightweight, container‑based CI/CD pipeline using Drone and Gogs, install both tools via Docker, configure servers and runners, write .drone.yml scripts, and automate building and deploying a SpringBoot e‑commerce project, all with minimal memory usage.
This article explains how to protect sensitive database credentials in SpringBoot applications by encrypting passwords in configuration files, leveraging Jasypt and a custom BeanFactoryPostProcessor to transparently decrypt values at runtime.
This article demonstrates how SpringBoot validates controller request parameters using @Validated, @Valid, and constraint annotations, compares behavior between SpringBoot 2.7.18 and 3.2.5, and shows how to handle validation exceptions with @ControllerAdvice.
The article presents a full‑stack solution for seamless token auto‑refresh, combining a Spring Cloud Gateway GlobalFilter that signals expiration with a custom 511 status, Axios response interceptors and a TypeScript timer on the client, plus server‑side token metadata, allowing developers to choose server‑centric or client‑centric refresh strategies.
This tutorial explains MinIO's features, common application scenarios, step‑by‑step CentOS 7 Docker installation, Spring Boot configuration, utility classes for bucket management, file upload/download, presigned URLs, and provides REST endpoints for handling large file uploads in Java backend applications.
This article explores three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑AOP header checks—to restrict certain APIs to internal network calls, and provides step‑by‑step SpringBoot code examples for implementing the preferred gateway‑AOP solution.
This guide walks through installing Grafana and Prometheus with Docker, configuring node_exporter to collect system metrics, adding SpringBoot Actuator and Micrometer for application metrics, setting up Prometheus scrape jobs, and importing ready‑made Grafana dashboards to achieve real‑time monitoring and alerting.
This article explains the purpose and proper usage of SpringBoot 3.3’s request‑handling annotations—@ModelAttribute, @SessionAttribute, @RequestAttribute—and the RedirectAttributes class, providing detailed code examples, configuration tips, and scenarios where each tool is essential for form submission, session management, and flash‑attribute redirects.
This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions and register synchronization callbacks so that Kafka messages are sent asynchronously only after a transaction successfully commits, illustrated with a Spring Boot starter example.
This article details the design and implementation of a Java SpringBoot seckill system, covering its architecture, technology stack, double‑MD5 password encryption, distributed session management with Redis, unified exception handling, page and object caching, static page generation, memory‑flag plus Redis pre‑decrement and RabbitMQ asynchronous order processing, oversell prevention, and API rate limiting, accompanied by key code snippets.
This article provides a detailed tutorial on installing MinIO on CentOS 7 using Docker, configuring it, integrating with Spring Boot for multipart upload, generating presigned URLs, and includes complete Java code examples for utilities and controllers, covering use cases, deployment steps, and troubleshooting tips.
This article introduces the Java Caffeine caching library, explains its manual, loading, and async cache APIs, details eviction and refresh strategies, shows how to collect statistics, and demonstrates full integration with Spring Boot using Maven dependencies, cache annotations, constant definitions, configuration classes, and usage examples.
This article explains how to use Spring's TransactionSynchronizationManager to detect active transactions and register callbacks that asynchronously send Kafka messages after a transaction successfully commits, ensuring data consistency in payment‑system archiving scenarios.
This article explains the Spring Boot startup process, enumerates the key extension points and their execution order, demonstrates the sequence with practical code examples, and answers common questions about bean initialization, lifecycle callbacks, and the proper timing for opening RPC, MQ, and HTTP traffic.
This article details the end‑to‑end design, configuration, and code implementation of a 50‑table sharding solution for cash repayment and loan application data, covering database schema planning, historical data migration, backend query adaptation, dynamic switches, scheduled consistency checks, and practical pitfalls encountered with Spring Boot 3 and ShardingSphere.
This article introduces JMH, explains why it outperforms simple loops or other tools, and provides step‑by‑step Maven setup, benchmark creation, execution, and advanced annotations such as @Warmup, @Fork, @Setup, Blackhole usage, and SpringBoot integration for accurate Java micro‑benchmarking.
This article explains what Java virtual threads are, compares them with traditional threads, shows how to enable them in SpringBoot with configuration and code examples, and presents performance tests that demonstrate dramatic speed improvements for IO‑bound workloads.
This article provides a comprehensive explanation of Spring Boot's startup process, detailing each lifecycle extension point, the order of execution, common pitfalls with RPC/MQ/HTTP traffic, and includes runnable code examples to help developers master Spring initialization.
This tutorial explains how to implement a standardized response format and a global exception handling mechanism in Spring Boot 3, providing reusable code examples, status enums, controller advice, and best‑practice guidelines to improve code consistency, readability, and maintainability across backend projects.
This article explains the concept of interface debouncing, identifies which API endpoints need it, and provides detailed Java implementations using custom @RequestLock annotations, Redis caching, and Redisson distributed locks to prevent duplicate submissions in backend services.
This article details how to switch a SpringBoot + MybatisPlus + MySQL project to PostgreSQL by adding the driver, updating JDBC settings, handling numerous SQL and type‑conversion pitfalls, and provides ready‑to‑run PostgreSQL scripts for bulk column modifications and default‑value settings.
This tutorial demonstrates how to retrieve custom application parameters, inject and print the banner, use ConversionService for type conversion, access servlet‑related beans, work with MessageSource for i18n, publish events, and gracefully shut down a SpringBoot 2.7 application.
This article explains how to add a custom banner to a SpringBoot application by placing a banner.txt file in the resources folder, and lists several online tools for generating ASCII art banners, including examples and screenshots of the results.
This guide explains how to run custom code after SpringApplication starts by implementing ApplicationRunner or CommandLineRunner, compares their method signatures and argument handling, shows execution timing, provides practical examples, and demonstrates how to control execution order with @Order or Ordered.
This article provides an in‑depth explanation of the Spring Boot startup process, enumerates the key extension points, demonstrates their execution order with sample code and logs, and offers practical recommendations for correctly initializing RPC, MQ, and HTTP traffic.
This guide shows how to output all SpringBoot controller endpoints via logging configuration, measure complete request processing time by listening to ServletRequestHandledEvent, dynamically register and deregister static resources at runtime, and execute custom logic after the application context refreshes using ContextRefreshedEvent.
This guide walks through setting up Docker on Windows, creating a Dockerfile for a SpringBoot service, using IntelliJ IDEA to build the image, testing the container locally, and finally deploying the image to a Linux server with proper volume and port mappings.
The article details a real‑world case study of building and operating a high‑traffic business middle‑platform for a leading consumer‑goods company, covering business and technical architecture, API gateway selection, SpringBoot microservices, custom MyBatis, logging, SSL, Docker, MyCat sharding, K8s deployment, CI/CD pipeline, and monitoring solutions.
This article walks through the problem of traditional session‑based captcha login, compares it with a modern front‑back‑separated architecture, and provides a step‑by‑step implementation using Spring Boot, Kaptcha, and Redis, including full code snippets, configuration classes, and flow diagrams.
This article explains why a Spring AOP aspect that overrides a parent method logs twice, walks through the debugging process that reveals duplicate advisor creation, and presents two solutions—including a pointcut tweak and upgrading to Spring 6.1.8—to eliminate the redundant logs.
This article demonstrates three approaches for invoking external services in Spring Boot applications—using raw HttpClient, the RestTemplate utility, and Feign clients—providing code samples, configuration steps, and tips for handling headers and tokens.
The Chinese Patent CN112905176B granted to Industrial and Commercial Bank of China describes a SpringBoot‑based backend implementation method that extracts operation data, maps business IDs to configuration, builds conditional expressions, and processes data, aiming to reduce development changes, lower costs, and improve system stability.
This article explains Java virtual threads, compares them with traditional OS threads, shows how to enable them in SpringBoot 3, and presents performance benchmarks demonstrating up to 200‑fold speed improvements for I/O‑bound workloads.
This article details how to switch a SpringBoot‑MyBatisPlus‑MySQL application to PostgreSQL, covering driver addition, JDBC configuration changes, numerous SQL and type‑conversion pitfalls, helper scripts for bulk column updates, and essential migration notes.
This article explains how to implement a configuration‑driven mechanism that dynamically switches between Spring's native @Scheduled tasks and XXL‑JOB execution, automatically registers jobs, disables Spring's scheduler when needed, and forwards logs to the XXL‑JOB console, providing a complete starter solution for backend developers.
This article provides a step‑by‑step tutorial on Apollo's configuration center, covering its core concepts, four‑dimensional model, client design, Spring Boot integration, testing of dynamic updates, and deployment via Docker and Kubernetes for cloud‑native applications.
This guide explains how to enable MQTT support in RabbitMQ, use MQTTBox and MQTT.js for instant messaging, and integrate MQTT into a SpringBoot application, providing step‑by‑step commands, code snippets, and configuration details for both front‑end and back‑end developers.
The article explains why API debounce is essential, identifies the types of endpoints that need it, and walks through two SpringBoot solutions—Redis‑based shared cache and Redisson distributed lock—complete with custom annotations, key generation, code samples, test results, and practical limitations.
This article documents the author's practical migration from JDK 8 to JDK 11, covering motivations such as performance, compatibility, and industry trends, detailed upgrade steps, GC tuning, resolved issues, and showcases significant performance gains and new Java 11 language features with code examples.
This article explains how to protect sensitive fields in SpringBoot 2.7 by using a custom annotation with AOP or a ResponseBodyAdvice implementation, comparing their advantages, showing complete code examples, and highlighting performance considerations for symmetric AES encryption.
This article explains SpringBoot 3.3.0's new support for adding description metadata to record components, covering configuration metadata basics, how to generate the metadata file, and step‑by‑step examples using both classic Java classes and Java records.
This article explains how to combine MVEL expressions with the Chain of Responsibility design pattern to build a decoupled, extensible message‑processing framework, using an order‑splitting MQ example to illustrate the architecture, code implementation, and benefits for backend Java services.
This article explains why large database transactions degrade backend API performance and presents practical techniques—such as avoiding RPC inside transactions, using programmatic transactions, batching data, splitting into smaller transactions, and applying asynchronous processing—to dramatically improve efficiency.
This guide introduces DataEase, an open‑source BI platform built with SpringBoot, Apache Doris, and Kettle, walks through its architecture, provides step‑by‑step Docker‑based installation, and demonstrates how to create datasets, visualizations, and dashboards from Excel and MySQL sources.
This article explains how to dramatically reduce SpringBoot endpoint latency by refactoring synchronous REST calls into parallel asynchronous tasks using CompletableFuture, handling thread safety, result aggregation, exception isolation, and custom thread pools for optimal throughput.
This article explains why using a wrong Content‑Type header and not closing the InputStream when returning a Resource in SpringBoot 3.2 causes file‑handle leaks, and demonstrates three solutions—including try‑with‑resources, direct HttpServletResponse streaming, and custom Resource implementations—to safely download files even under high concurrency.
This article introduces retrofit-spring-boot-starter, a lightweight, type‑safe HTTP client starter that seamlessly integrates Retrofit into Spring Boot projects, outlines its key features, provides quick usage examples with Maven/Gradle dependencies, interface definitions, injection, configuration options, and advanced capabilities such as custom OkHttpClient injection, annotation‑based interceptors, connection‑pool management, logging, and retry mechanisms.
This article explains why combining Spring's @Async and @Transactional annotations can cause transaction rollback failures, analyzes the proxy mechanisms behind each annotation, reproduces the issue with sample code, and demonstrates how bean ordering affects the outcome.
The article introduces retrofit-spring-boot-starter, a lightweight HTTP client library for Spring Boot that simplifies HTTP calls, offers extensive features such as custom OkHttpClient injection, annotation‑based interceptors, retry, logging, circuit‑breaker, and provides detailed usage examples, configuration options, and advanced customization techniques.
This guide explains why SpringBoot JARs become bulky when many dependencies are included, shows how to inspect the packaged libraries, and provides step‑by‑step Maven configurations and runtime commands to build a leaner JAR that loads external libs only when needed, dramatically speeding up deployment.
The article explains that SpringBoot’s request capacity is governed by Tomcat’s thread pool and connection settings, derives the formula max‑connections + accept‑count, demonstrates it with a small‑scale experiment, and discusses related concurrency pitfalls in singleton beans.
This article walks through the fundamentals of RSA encryption, illustrates two security scenarios, and provides a step‑by‑step Spring Boot implementation—including Maven setup, annotations, key configuration, controller encryption, decryption testing, and practical tips—to protect API data from interception and tampering.
This article demonstrates three practical approaches for invoking external services in a Spring Boot application—using a raw HttpClient, the RestTemplate utility, and the Feign declarative client—complete with code examples, configuration steps, and tips for handling headers and tokens.
This guide walks you through setting up Jenkins to pull code from GitLab, build a SpringBoot 3 Java project with Maven, back up and copy JAR files to a remote server, and perform rolling updates of Docker Swarm services, all with step‑by‑step instructions and code snippets.
This tutorial explains the basics of SpringBoot's @RequestMapping annotation, its shortcut variants, handling of HEAD and OPTIONS requests, how to create custom request annotations, and demonstrates dynamic handler registration with complete code examples.
This article walks through how to use the Singleton pattern together with SpringBoot's ScheduledExecutorService to build a reusable asynchronous task manager, recreate Ruoyi's login‑log recording logic, and verify the non‑blocking behavior with a concrete test case.
This article shows how to use SpringBoot together with the POI‑TL template engine to create Word reports that embed text, images, tables and charts, providing a step‑by‑step guide, code snippets and a reusable utility class for rapid document generation.
This article introduces Redis Streams, explains its core concepts and commands, compares it with Kafka, demonstrates practical SpringBoot integration with code examples, and discusses its suitability as a lightweight message queue, highlighting advantages, limitations, and best‑practice considerations.
This article demonstrates how to boost the performance of inserting over two million records by configuring a ThreadPoolTaskExecutor in a Spring Boot application, providing detailed implementation code, test results comparing multithreaded and single‑threaded approaches, and practical recommendations for optimal thread pool sizing.
This article introduces the key SpringBoot extension interfaces—including BeanPostProcessor, BeanFactoryPostProcessor, BeanDefinitionRegistryPostProcessor, SmartInstantiationAwareBeanPostProcessor, SmartInitializingSingleton, ApplicationContextInitializer, EnvironmentPostProcessor, and the *Runner interfaces—explaining their purposes, usage patterns, and providing concrete code examples to help developers customize and extend SpringBoot applications effectively.
This article explains the core principles of Spring Boot startup configuration, demonstrates how to intervene using ApplicationContextInitializer, SpringApplicationRunListener, ApplicationRunner, and CommandLineRunner, and provides practical optimization techniques to significantly reduce application launch time.
This article demonstrates how to protect sensitive user information in a Java backend by encrypting data before storage, decrypting and desensitizing it on retrieval, and applying these rules automatically through custom annotations, reflection, and Spring AOP aspects.
This article explains how to lower the learning curve of DDD and CQRS by using structured, standardized, and templated approaches, introduces a Maven archetype for rapid project scaffolding, and demonstrates an IntelliJ IDEA plugin that auto‑generates boilerplate code for aggregate roots, commands, queries, and related components.
Learn how to implement multi-version REST APIs in SpringBoot 2.7.16 using a single custom annotation, custom RequestCondition, and HandlerMapping, enabling seamless version control, client compatibility, and flexible business scenarios with clear code examples and testing screenshots.
This article introduces Cool Request, a free open‑source IntelliJ IDEA plugin that automatically extracts SpringBoot controllers, simplifies HTTP request debugging, supports multiple request bodies, pre‑ and post‑scripts, reflection calls, cURL import, Apifox export, global API search, and even provides a static resource server.
The tutorial project showcases how to implement database sharding with ShardingSphere-JDBC (versions 4 and 5) in a SpringBoot O2O order service, providing modules for sharding, a gRPC ID generator, detailed configuration of four data sources, sharding algorithms, and Swagger-based testing of order creation and queries.
This article explains Spring's Resource abstraction, its key methods, built‑in implementations, and how to use ResourceLoader, ResourcePatternResolver, and ResourceLoaderAware for flexible resource access in Spring Boot 2.7 applications.
This guide walks through setting up Flink CDC with MySQL on SpringBoot 2.7, covering binlog configuration, Maven dependencies, Java implementation for real‑time change capture, startup options, a custom Redis sink, and a web UI for monitoring the streaming pipeline.
This article compares JWT and session authentication, explains their differences, advantages, and drawbacks, and provides a complete Java implementation with Redis integration, token generation, validation, renewal, and related interceptor configuration for a robust backend authentication system.
