This article explains how to prevent brute‑force password attempts by locking an IP after three failed logins using a Spring Boot backend, Redis for distributed counters, and a Lua script to ensure atomic increment and expiration, while also providing a simple HTML login page for the front end.
This article explains how Spring Boot uses Tomcat by default, introduces Undertow as a high‑performance alternative, provides step‑by‑step Maven configuration to switch containers, compares Tomcat and Undertow on throughput and memory usage, and recommends Undertow for high‑concurrency Java web applications.
This article presents a systematic experiment that uses JMeter to generate HTTP requests against a SpringBoot 2.5.4 service, records detailed GC logs, and calculates that each HTTP call consumes roughly 34 KB of heap memory, while logging and payload size can significantly increase the allocation.
This article recounts a production incident where Spring Boot services consumed excessive memory, details step‑by‑step diagnostics using jps and jmap, explains default JVM heap settings, offers remediation recommendations, and also includes promotional material for AI services.
This article introduces the evolution of Java-based workflow engines, compares Activiti, Flowable, and Camunda, explains core BPMN concepts, and provides a step‑by‑step tutorial for integrating Flowable into a Spring Boot project, including dependencies, BPMN diagram creation, service task implementation, and testing.
This article compares Server‑Sent Events, WebSocket, and traditional polling, explains why SSE is often a simpler and more efficient choice for one‑way real‑time communication, and provides a complete Spring Boot example with code snippets for publishing online‑user statistics.
The author describes how changing a SpringBoot controller annotation from @GetMapping to @PostMapping caused a silent 404 error, how a teammate quickly fixed it by disabling CSRF, and how a visual tool helped reveal the underlying filter-chain behavior.
This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, illustrated with a payment‑system example and complete Java code snippets, while also noting thread‑local considerations and promotional offers.
This article details how a SpringBoot advertising platform service with startup times of 400‑500 seconds was analyzed and optimized through Actuator monitoring, log inspection, Tomcat TLD scan disabling, asynchronous HBase warm‑up, custom BeanPostProcessors, async JSF consumer initialization, Tomcat version tuning, and hardware upgrades, achieving roughly a 60% reduction in launch time.
This article explains the concept of layered architecture in Java backend projects, outlines five design dimensions, presents a nine‑layer SpringBoot module structure, and provides concrete code examples for each layer—including util, infrastructure, domain, service, integration, facade, client, controller, and boot—demonstrating how to achieve clean separation of concerns and maintainable code.
This article explains how to replace Spring Boot's default embedded Tomcat with the high‑performance Undertow server, provides step‑by‑step Maven dependency changes, outlines Undertow's advantages, and presents benchmark results showing superior throughput and lower memory usage for high‑concurrency applications.
This article demonstrates how to experimentally determine the heap memory allocated by individual HTTP and RPC requests in a SpringBoot application using JMeter load testing, GC logging, and code analysis, providing insights into memory consumption, GC frequency, and optimization strategies for backend performance.
This article explains why a SpringBoot service field initialized with a value becomes null when accessed through a CGLIB proxy, analyzes the role of final methods and Objenesis in the proxy creation process, and provides three practical solutions to prevent the null value.
This article provides a detailed tutorial on using Flowable as a BPMN workflow engine within a Spring Boot application, covering the history of workflow engines, core concepts, Maven dependencies, BPMN diagram creation, process deployment, task configuration, service task implementation, and troubleshooting tips.
This article explains how to implement plugin mechanisms in Java using SPI and ServiceLoader, demonstrates custom configuration approaches, and shows how Spring Boot’s spring.factories can be leveraged for extensible services, providing practical code examples and step‑by‑step guidance for building modular backend applications.
This article demonstrates how to encapsulate Alibaba's EasyExcel library within a Spring Boot backend, providing step‑by‑step environment setup, entity annotations, service interfaces, implementation details, usage examples, and solutions to common issues such as date conversion and template‑based export limitations.
This article details a comprehensive set of optimizations that reduced a SpringBoot application's startup time from 400‑500 seconds to about 130‑150 seconds, covering Actuator monitoring, Tomcat TLD scan disabling, HBase asynchronous warm‑up, custom BeanPostProcessor timing, JSF consumer proxy refactoring, Tomcat version impacts, and hardware upgrades.
This article documents the systematic analysis and multi‑step optimization of a SpringBoot application's slow startup, covering profiling with Actuator, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, and asynchronous JSF consumer initialization to cut launch time by over 60 percent.
This comprehensive guide explains how to implement plugin mechanisms in Java and Spring Boot, covering ServiceLoader (SPI), custom configuration with reflection, dynamic JAR loading, and Spring's spring.factories, complete with code examples and practical micro‑service use cases.
This article explains why SpringBoot's default @EnableScheduling creates a single‑threaded scheduler that can cause execution delays, and demonstrates multiple solutions—including configuring the thread pool, using async execution, and applying a distributed lock with Redisson—to achieve reliable and concurrent scheduled tasks.
This tutorial explains how to set up a SpringBoot application with MinIO storage and the kkFileView tool to achieve universal online file preview for various file types, using Docker containers and simple configuration steps.
This article details a real‑world case where Spring Boot microservices on a 64 GB server consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, and provides practical recommendations for tuning JVM parameters to prevent similar problems.
This article examines common problems in Spring Boot controller implementations—excessive try‑catch blocks, inline validation, and business logic leakage—and demonstrates how to refactor them using @Valid, assertion utilities, and a global exception handler to achieve concise, maintainable backend code.
This article documents the diagnosis of slow SpringBoot startup in a large‑scale advertising platform and presents a series of optimizations—including actuator monitoring, Tomcat TLD scan disabling, HBase async warm‑up, custom BeanPostProcessor timing, asynchronous JSF consumer refer, Tomcat version tuning, and hardware migration—that together reduce launch time by about 60%.
This article explains Java's Service Provider Interface (SPI), compares it with traditional APIs, and provides a step‑by‑step guide with Maven project setup, code examples, custom class loader, and Spring Boot integration to build a modular plugin system.
This article enumerates fifteen common SpringBoot startup extension points, explains their positions in the bean lifecycle, illustrates each with concrete code snippets and usage scenarios, and provides a visual call‑order diagram to help developers harness these hooks for custom initialization and middleware development.
This article summarizes how to correctly declare, monitor, configure, and name Java thread pools, explains common mistakes such as unbounded queues and ThreadLocal contamination, and introduces dynamic tuning techniques and open‑source solutions for robust backend concurrency management.
This article demonstrates how to encapsulate EasyExcel within a Spring Boot + MyBatis‑Plus project, providing step‑by‑step usage, complete source code, and solutions to common issues such as date formatting, POI version compatibility, and template‑based export limitations.
This article demonstrates how to wrap the EasyExcel library in a Spring Boot + MyBatis‑Plus project, providing a unified component that simplifies Excel import and export through concise annotations, reusable service methods, and customizable converters while addressing common pitfalls such as date handling and template support.
This guide explains how to analyze the structure of a SpringBoot jar, separate your own classes from third‑party dependencies, reconfigure Maven packaging to produce a much smaller zip‑layout jar, and deploy it efficiently by uploading only the necessary libraries.
This article records and reviews a production incident where multiple Spring Boot services consumed excessive memory, explains how default JVM settings caused each instance to allocate up to 12 GB of heap, and provides step‑by‑step diagnostics, configuration guidelines, and optimization recommendations for backend developers.
This article explains how to replace Spring Boot's default embedded Tomcat with Undertow, detailing the necessary Maven dependencies, configuration steps, and performance and memory usage comparisons that demonstrate Undertow's advantages for high‑concurrency Java backend applications.
This article explores three practical approaches—microservice isolation, Redis‑based whitelist, and gateway‑AOP integration—to restrict internal‑only APIs, compares their trade‑offs, and provides step‑by‑step SpringBoot code examples for implementing the AOP solution.
The article details a SpringBoot experiment that uses JMeter to send 20,000 HTTP requests, captures detailed GC logs, and demonstrates that each request consumes roughly 34 KB of heap memory, with larger payloads and logging increasing the usage, highlighting the importance of memory‑aware coding and log management.
This article demonstrates how to boost the insertion speed of over two million records in a PostgreSQL database by configuring a Spring Boot ThreadPoolTaskExecutor for multithreaded batch processing, detailing the setup, code implementation, performance testing, and analysis of results.
This article describes how a senior architect designed, configured, and implemented a 50‑table sharding solution for loan and repayment request data using ShardingSphere, Spring Boot 3, MySQL, and custom synchronization scripts, while also addressing historical data migration, backend query changes, and operational safeguards.
This article explains how to implement request debouncing and distributed locking in a Java backend using Redis and Redisson, covering the definition of debounce, identifying suitable APIs, generating unique keys, and providing complete code examples for both cache‑based and Redisson‑based lock mechanisms.
This article demonstrates how to integrate Kafka with Spring Boot, add necessary dependencies and configuration, implement both single‑message and batch consumers, and tune batch settings to dramatically improve processing speed for millions of records in a microservice environment.
This article explains how to replace Spring Boot's default embedded Tomcat container with Undertow, provides the necessary Maven configuration, compares their performance and memory usage, and highlights why Undertow is a superior choice for high‑concurrency Java web applications.
LiteFlow is a lightweight Java flow‑orchestration framework that lets developers break complex business processes into independent Spring‑Boot node components, configure them via XML, and execute them with FlowExecutor, supporting conditional switches and loops while focusing on simple workflow modeling rather than role‑task management.
This article provides a comprehensive tutorial on configuring front‑end resource bundling, adjusting server settings, building and uploading SpringBoot back‑end modules, creating deployment scripts, managing environment‑specific properties, and implementing a Baidu Tieba hot‑search crawler, enabling a complete end‑to‑end cloud deployment.
The article examines Java connection pool technologies, comparing Commons Pool 2 with HikariCP and showing through JMH benchmarks that HikariCP delivers up to five‑times higher throughput, while detailing lifecycle management, configuration, eviction strategies, sizing best practices, and real‑world uses such as database, HTTP, and RPC connections.
This guide introduces thirty highly useful IntelliJ IDEA plugins—including code assistants, UI themes, project utilities, and debugging tools—explaining how to install them, what features they provide, and why they can significantly boost productivity for Java and Spring developers.
This guide walks developers through rapidly onboarding a SpringBoot 3 and Vue‑based e‑commerce system, covering project overview, setup, core features, technology stack, business logic, deployment, and extending the code for new requirements.
This article introduces UniHttp, a declarative Java framework that replaces manual HttpClient or OkHttp code with clean interface annotations, explains its quick‑start setup, details all @Par annotations for request construction, shows how to handle raw responses and file downloads, and demonstrates custom lifecycle processing for enterprise‑level third‑party API integration.
This article describes how a senior architect designed and implemented a sharding solution for loan and repayment tables, covering database design, table naming, sharding algorithms, historical data migration, three‑write synchronization, dynamic switches, and the necessary Spring Boot, MyBatis‑Plus, and ShardingSphere configurations with code examples.
The article recounts a recent Hikvision interview, outlining campus salary ranges and providing a technical Q&A that explains Spring Boot’s startup sequence, Spring MVC request handling, MySQL index structures, creation rules, and performance diagnostics, as well as Redis’s in‑memory, single‑threaded architecture and optional I/O threading.
The article examines common pitfalls in Spring Boot controller implementations—excessive try‑catch blocks, inline validation, and business logic—then demonstrates how to refactor them into clean, maintainable code using @Valid annotations, reduced duplication, and a centralized global exception handler.
This article presents comprehensive Java exception‑handling guidelines, covering why exceptions should not be ignored, how to use global handlers, capture specific exceptions, properly close I/O streams, employ try‑with‑resources, avoid returning in finally blocks, log detailed errors, and design custom exceptions for clean, maintainable backend code.
In Spring Boot, a class annotated with @Service can act as a web controller if it is discovered by component scanning and carries @RequestMapping (or method‑level mapping) annotations, allowing HTTP requests to be handled just like a traditional @Controller‑annotated bean.
This article provides an in‑depth tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its concepts, features, four‑dimensional model, client architecture, deployment steps, SpringBoot integration, Kubernetes deployment, and practical testing scenarios for real‑time configuration updates.
This article explains how to design, configure, and code a multi‑level leave‑approval workflow using the Activiti BPM engine, covering process diagram creation, deployment, task handling, exclusive gateways, and database schema while providing complete Java examples and best‑practice recommendations.
This article details a step‑by‑step investigation of an OutOfMemoryError in a Spring Boot social app, revealing that frequent initialization of a script engine caused massive StringSequence instances via SPI loading, and shows how consolidating the engine eliminated the OOM issue.
The article presents a Redis‑based distributed ID generator for Spring Boot 3.0 that uses an atomic INCR on a Redis string to produce compact, monotonic, globally unique numeric identifiers, synchronizes the maximum value with MySQL on startup, and offers high performance, availability, and low storage overhead.
This article explains the concept of short‑URL redirection, its benefits, and provides a complete SpringBoot implementation—including database schema, entity, DAO, service, controller, and testing code—to convert long links into short, trackable links and handle redirects.
This article demonstrates how to replace bulky if‑else discount handling in a SpringBoot shopping service with a clean combination of strategy and factory patterns, providing extensible, maintainable code for various user types and product discounts.
This article recounts five successive performance optimizations applied to a SpringBoot‑Thymeleaf category‑tree API—adding Redis caching, scheduled async refresh jobs, local Caffeine memory cache, gzip compression via Nginx, and Redis data slimming—transforming query latency and scaling QPS from around 100 to over 500.
This guide walks through common pitfalls and 13 practical best‑practice techniques for handling exceptions in Java, covering everything from avoiding ignored errors and using global handlers to proper logging, try‑with‑resources, custom exceptions, and avoiding exception‑driven control flow.
This article explains how to use the iTextPdf library in a Java SpringBoot project to create, fill, and merge PDF invoice templates—covering dependency setup, template design, dynamic table generation, and final PDF concatenation for both fixed and variable invoice data.
Cool Request is an IDEA plugin that enhances HTTP debugging by offering reflection calls, traceable method execution, MyBatis function monitoring, customizable timing highlights, and scriptable environment handling, enabling Java developers to efficiently analyze performance and automate request workflows without leaving the IDE.
This article provides a step‑by‑step tutorial on Apollo, Ctrip’s open‑source distributed configuration center, covering its core concepts, features, architecture, four‑dimensional model, project creation, Maven dependencies, Spring Boot configuration, test controllers, various runtime scenarios, cluster and namespace usage, and deployment on Kubernetes with Docker.
This article demonstrates how to quantify the heap memory allocated by individual HTTP and RPC calls in a SpringBoot application by creating a test service, configuring JMeter for load, capturing detailed GC logs, and analyzing the results to guide JVM and logging optimizations.
The article announces a Chinese patent for a SpringBoot‑based web backend implementation method, outlines its technical abstract and benefits, briefly introduces SpringBoot, and also contains promotional material for ChatGPT services and a developer community.
This article explores whether the @Service annotation can replace @Controller in Spring Boot, demonstrates a working example, explains the underlying bean registration process, and clarifies how Spring’s component scanning and request mapping enable such unconventional usage.
This article details the end‑to‑end architecture of a high‑traffic business middle platform, covering business and technical design, Kong API Gateway, SpringBoot microservices, Dockerfile creation, MyCat‑MySQL sharding, cold/hot data strategies, DevOps pipelines, Kubernetes deployment, and operational monitoring.
This article walks through creating a WebSSH solution using SpringBoot, WebSocket, the Java jsch library, and the xterm.js front‑end, covering technology choices, core backend logic, demo screenshots, command examples, and future extension ideas.
This article explains how to leverage Spring's TransactionSynchronizationManager to detect active transactions, register synchronization callbacks, and asynchronously send Kafka messages only after a transaction successfully commits, providing a practical example and detailed code snippets for building a reusable Spring Boot starter library.
This article introduces UniHttp, a declarative Java HTTP client framework that lets developers define third‑party HTTP APIs as annotated interfaces, provides quick‑start instructions, detailed annotation usage, lifecycle hooks, custom client configuration, and an enterprise integration example with full code snippets.
This article explains what Java virtual threads are, compares them with ordinary platform threads, shows how to enable them in SpringBoot, and presents performance benchmarks that reveal virtual threads can be up to two hundred times faster for I/O‑bound workloads.
This article explains how APIJSON can replace dozens of traditional SpringBoot controller methods with a single configurable endpoint, demonstrating concise request formats, permission annotations, and example code for creating, reading, updating, deleting, and aggregating data in a Java backend.
This article provides an in‑depth tutorial on Apollo, Ctrip's open‑source distributed configuration center, covering its concepts, features, architecture, four management dimensions, client design, Maven integration, SpringBoot implementation, testing procedures, and deployment on Kubernetes with Docker.
This article presents a SpringBoot-based experiment measuring the heap memory allocated per HTTP request, detailing the setup with JMeter, JVM GC logging, observed memory usage of roughly 34 KB per request, analysis of GC frequency, and concludes with recommendations on logging and memory optimization, while also promoting related AI services and community resources.
This article walks through creating a Spring Boot project, handling version compatibility between Spring Cloud, Spring Boot, and Kafka, demonstrates common Maven configurations, provides global exception handling and logging aspects, and lists useful backend tools such as embedded Redis, MyBatis‑Plus, and Redisson.
This article examines whether the @Service annotation can replace @Controller in Spring Boot by presenting a functional example, explaining the component‑scanning and request‑mapping mechanisms that allow a @Service‑annotated class to handle HTTP requests just like a controller.
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 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.
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.
