This article describes an experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated per HTTP and RPC request, detailing the setup, GC logging configuration, results showing average memory consumption around 34 KB per request, and recommendations for logging and performance optimization.
This article explores common overselling problems in high‑concurrency flash‑sale scenarios and presents seven practical solutions—including lock timing adjustments, AOP locking, pessimistic and optimistic database locks, and queue‑based approaches—each illustrated with SpringBoot code and performance test results.
The article introduces DynamicTp, a SpringBoot-based dynamic thread‑pool framework that enables real‑time adjustment, monitoring, and alerting of ThreadPoolExecutor parameters via various configuration centers, outlines its architecture, modules, features, and integration with third‑party components, and provides usage guidance for Java backend developers.
This article recounts a production incident where Spring Boot services consumed excessive memory, explains how to diagnose the issue using jps and jmap, discusses default JVM heap settings, offers practical remediation steps, and also contains promotional material for AI community services and related offers.
This article explains how to diagnose and dramatically reduce SpringBoot startup latency by analyzing SpringApplicationRunListener and BeanPostProcessor phases, limiting component scanning paths, using JavaConfig for explicit bean registration, monitoring bean initialization times, and handling auto-configuration pitfalls such as cache manager duplication.
This article explains how to correctly declare Java thread pools using ThreadPoolExecutor, monitor their runtime status, configure parameters for CPU‑bound and I/O‑bound workloads, assign meaningful names, avoid common pitfalls such as unbounded queues and thread‑local leakage, and leverage dynamic pool frameworks.
This article analyzes a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, and JMeter, demonstrates seven implementations—from service‑level locks to AOP, pessimistic/optimistic locks, and queue‑based designs—examines their trade‑offs with concrete code, test results, and practical recommendations.
This article explains how to replace Spring Boot's default embedded Tomcat container with Undertow, detailing Undertow's features, providing Maven dependency changes, and comparing performance and memory usage through test results, concluding that Undertow offers superior efficiency for high‑concurrency Java web applications.
DynamicTp is a Java‑based dynamic thread‑pool framework that extends ThreadPoolExecutor to enable runtime parameter tuning, real‑time monitoring, and multi‑channel alerting, addressing common pain points of thread‑pool configuration in microservice environments.
This article details a practical experiment using SpringBoot 2.5.4 and JMeter to measure the heap memory allocated by individual HTTP and RPC requests, analyzes GC logs, and demonstrates how request size and logging affect memory consumption, providing insights for backend performance optimization.
This tutorial walks through setting up the lightweight Loki log aggregation system together with Grafana using Docker Compose, integrating Loki into a SpringBoot application via the loki‑logback‑appender, and configuring Grafana dashboards to visualize distributed logs on a low‑memory server.
DynamicTp is a SpringBoot‑compatible framework that extends ThreadPoolExecutor to allow live adjustment of pool parameters, real‑time monitoring, multi‑platform alerts, and seamless integration with popular configuration centers, helping Java services achieve higher performance and reliability.
Hotlinking attacks steal popular media by fetching resources from major platforms, but developers can protect assets using anti-leech methods such as Nginx referer checks, SpringBoot filters, token validation, timestamp verification, and graphical captchas, each with strengths and limitations against forged requests.
This article demonstrates how to simulate a high‑concurrency flash‑sale scenario using SpringBoot, MySQL, Mybatis‑Plus and JMeter, analyzes the overselling problem caused by premature lock release, and presents seven solutions—including lock‑first strategies, AOP, pessimistic and optimistic locks, and queue‑based approaches—along with code samples and test results.
DynamicTp extends Java's ThreadPoolExecutor with zero‑intrusion configuration, real‑time parameter adjustment, comprehensive monitoring, and multi‑channel alerting, allowing developers to dynamically tune thread pools across microservices using popular configuration centers and integrate with tools like Micrometer and Grafana.
Beyond the JDK, modern Java backend development relies on a core toolkit—including SpringBoot, Netty, Guava or Hutool utilities, JUnit 5 with Mockito, JMH, OkHTTP, HikariCP or Druid pools, Caffeine cache, Hazelcast, SLF4J + Logback, Jackson, Jolokia, Hibernate‑Validator, and FreeMarker—to build robust, high‑performance enterprise services.
This article explains Java virtual threads, compares them with regular threads, shows how to enable them in SpringBoot, and presents performance tests that reveal up to a 200‑fold reduction in latency for IO‑bound workloads.
This article explains various plugin implementation approaches in Java, including SPI, ServiceLoader, custom configuration, and Spring Boot's spring.factories, providing detailed code examples and step‑by‑step guidance for building extensible backend systems that can be dynamically loaded and configured at runtime.
This article explains how to prevent duplicate data submissions in a Spring Boot application by designing an idempotent mechanism using AOP and Redis, covering the concept, design strategy, custom annotation, aspect implementation, and a simple test controller.
This article provides a comprehensive tutorial on Apollo, covering its basic concepts, architecture, four-dimensional configuration model, client design, high‑availability considerations, and step‑by‑step instructions for creating a Spring Boot project, integrating Apollo dependencies, configuring environments, testing dynamic updates, and deploying the application on Kubernetes.
This article explains the lightweight Server‑Sent Events (SSE) approach for one‑way server push, compares its features, connection model, performance and use cases against WebSocket and traditional polling, and provides a SpringBoot example with code snippets for building an online‑user SSE endpoint.
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.
