This article explains how to use the iTextPdf library in Java to design a PDF template, fill fixed fields, dynamically generate product tables, and merge the two parts into a single invoice PDF, including Maven dependencies and sample code.
This article examines the limitations of using JPA for complex queries in SpringBoot projects and demonstrates how MyBatis‑Flex can simplify conditional queries, partial field selection, Kotlin integration, and code generation through clear code examples and practical guidance.
The article describes a year‑long development experience where a senior architect designs, plans, and implements a sharding solution for loan and repayment tables using ShardingSphere, Spring Boot 3, MySQL, and custom synchronization code to migrate billions of rows while ensuring data consistency and operational continuity.
This article details a step‑by‑step performance improvement journey for a category‑tree query in a SpringBoot‑Thymeleaf system, covering Redis caching, scheduled jobs, local Caffeine cache, Gzip compression, and data slimming with byte‑array storage to resolve latency and large‑key issues.
This article walks through five successive performance optimizations—adding Redis caching, scheduling async updates, introducing a Caffeine local cache, enabling Nginx GZip compression, and compressing Redis data—to dramatically reduce the size and latency of a category‑tree API in a SpringBoot application.
This article critiques overly complex Spring Boot controllers filled with try-catch and validation logic, demonstrates a cleaner implementation using @Valid annotations and reduced code, provides global exception handling examples, and concludes with advice on maintaining concise controller methods while also promoting related community resources.
A developer recounts how a newly written SpringBoot unit test unintentionally deleted all data in the test database, explores the root causes—including H2 configuration, automatic SQL script execution, and permission issues—and shares concrete steps to prevent similar disasters.
This article explains how to configure XXL‑JOB with a sharding‑broadcast strategy in a SpringBoot application, use ID modulo hashing to partition large tables, implement the task with XxlJobHelper, write MyBatis sharding SQL, and verify correct parallel processing through detailed logs.
This article walks through converting a SpringBoot + MybatisPlus application from MySQL to PostgreSQL, covering driver addition, JDBC URL changes, dozens of SQL syntax incompatibilities, custom conversion functions, and handy PostgreSQL scripts for bulk column type and default value updates.
This article provides a concise guide to SpringBoot’s built‑in utility classes—including Assert, ObjectUtils, StringUtils, CollectionUtils, FileCopyUtils, ResourceUtils, StreamUtils, ReflectionUtils, and AOP helpers—explaining their purpose, key methods, and offering ready‑to‑use code examples to boost development efficiency.
The article demonstrates how to avoid blocking SpringBoot services during massive Excel exports by splitting data, using CompletableFuture with a ThreadPoolTaskExecutor to generate multiple Excel files concurrently via EasyExcel, then compressing them into a ZIP for client download, including full code and resource‑cleanup details.
This article explains how to generate a Java license using TrueLicense, configure key pairs, create the license file, and integrate verification and installation steps into a Spring Boot application, including detailed code examples and deployment considerations for secure software licensing.
This article demonstrates how to design, deploy, and run a two‑level leave‑approval workflow using the Activiti BPMN engine, covering diagram creation, Spring Boot configuration, process variables, task handling, exclusive gateways, database tables, API overview, and best‑practice tips for extending the flow.
This guide reviews two actively maintained open-source Chinese payment platforms—Jeepay, an internet-focused system supporting WeChat Pay, Alipay, UnionPay and more with Spring Boot backend and Ant Design Vue front-end, and DaxPay, a Java-SDK-enabled solution for Alipay, WeChat and UnionPay built on Spring Boot and Vue 3, both offering documentation, demos, and high-concurrency deployment options.
This article walks through converting a SpringBoot + MyBatisPlus project from MySQL to PostgreSQL, detailing driver setup, JDBC changes, common SQL pitfalls, type‑conversion issues, and provides helper scripts for bulk schema adjustments.
This article provides a step‑by‑step guide to building a student leave approval process using Flowable BPMN, Spring Boot 2.7.5, MySQL, and related dependencies, covering environment setup, Maven configuration, application properties, Java classes, REST endpoints, diagram generation, and database tables.
This article explains how Spring Boot handles graceful shutdown in Kubernetes, manual Actuator shutdown, SIGTERM handling, Tomcat graceful termination, and Logback log flushing, providing detailed code examples, configuration snippets, and the underlying shutdown hook mechanisms that ensure resources are released cleanly.
This tutorial demonstrates how to use Java's CompletableFuture in SpringBoot 2.7.18 to parallelize multiple external REST API calls, covering code implementation, exception handling, and timeout management to improve response time and scalability.
This article explains how to enable hot deployment in Spring Boot using DevTools, configure automatic recompilation in IDEs, simplify Java bean code with Lombok, and add the Spring Configuration Processor for property metadata, providing Maven snippets and step‑by‑step instructions.
This article provides an in‑depth tutorial on Alibaba Sentinel, covering its core concepts, installation of the dashboard, version selection, integration with Spring Boot microservices, detailed flow‑control and degrade rule configurations, hotspot parameter limiting, system adaptive protection, custom block handlers, blacklist/whitelist settings, rule persistence with Nacos, push‑mode synchronization, cluster flow control, gateway integration and OpenFeign fault‑tolerance, all illustrated with practical code examples.
This article demonstrates how to implement dynamic data source switching in a Spring Boot application by leveraging ThreadLocal and AbstractRoutingDataSource, providing step‑by‑step code examples for context holders, custom routing, annotation‑driven switching, and runtime addition of new data sources.
This article explains the most frequent SpringBoot BeanCreationException scenarios—including missing beans, duplicate beans, constructor issues, circular dependencies, and bean overriding—provides clear code examples, and offers practical solutions to resolve each problem.
This article explains what a dynamic thread pool is, why it is needed, how to modify its core parameters at runtime, how to monitor and expose its metrics, and lists open‑source implementations and visualization/alerting options such as Prometheus, Grafana, Hippo4j and Dynamic TP.
This article explains how SpringBoot's default data binding can unintentionally modify unwanted fields and demonstrates three safe approaches—using a dedicated DTO, configuring WebDataBinder with @InitBinder to allow only specific fields, and applying advanced @InitBinder options such as required fields, constructor‑only binding, and custom validators—to ensure precise and secure request parameter handling.
The article details how a production Spring Boot system consumed excessive memory due to default JVM heap settings, explains the underlying JVM defaults, demonstrates diagnostic commands, and provides practical recommendations for configuring JVM parameters and monitoring memory usage to prevent similar issues.
This article provides a concise yet comprehensive guide to the most common SpringBoot annotations—including @SpringBootApplication, @EnableAutoConfiguration, @ComponentScan, @Service, @Repository, @Component, @RestController, @Bean, @ResponseBody, and @Autowired—explaining their purpose, composition, and practical code examples for building robust Java backend applications.
This guide explains how SpringBoot's @Async annotation works, why to use it, how to configure default and custom thread pools, handle exceptions and return values, and leverage virtual threads for higher throughput in Java backend applications.
The article explains JWT fundamentals, shows how to integrate it with SpringBoot, compares JWT with a Token‑plus‑Redis approach, and argues why using JWT alone can be problematic in a system that already relies on Redis for session management.
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.
