This article dissects the Spring Boot startup sequence step by step, showing how a minimal @SpringBootApplication triggers listeners, type deduction, auto‑configuration loading, environment preparation, IOC container creation, bean refresh, and embedded Tomcat launch, with interview‑ready explanations.
This guide walks through exposing metrics, integrating Prometheus and Grafana, using async‑profiler flame graphs, tuning Tomcat/Undertow, optimizing JVM flags, applying SkyWalking tracing, and applying layer‑wise code, cache, and thread‑pool improvements so a SpringBoot service can reliably serve millions of concurrent requests.
This guide explains why Tomcat may become a bottleneck under sudden high concurrency, introduces Undertow as a lightweight non‑blocking alternative, and provides detailed Maven, YAML/Properties, thread‑pool, timeout, request‑size, compression, HTTP/2, and access‑log configurations along with monitoring tips for Spring Boot 3 applications.
This article explains how Spring Boot processes concurrent HTTP requests using its embedded Tomcat thread pool, details the default limits (200 max threads, 10 min threads, queue size 10,000), shows how to tune these settings via configuration files, demonstrates async controllers, and suggests performance testing tools to measure real‑world capacity.
After optimizing a Spring Boot channel service, a mysterious extra ~100 ms appeared per request; detailed tracing with Arthas revealed that embedded Tomcat repeatedly loads Swagger UI META‑INF resources, causing a 70 ms overhead, which can be eliminated by upgrading Tomcat or removing the Swagger dependencies.
This guide walks through Maven’s core workflow for Java backend development, covering plugin configuration, automatic project setup in IntelliJ IDEA, detailed pom.xml settings—including properties, dependencies, plugins—and code examples for Servlets and JSPs, plus dependency scope handling to avoid runtime conflicts.
This guide walks you through practical performance tuning of Tomcat 11 on JDK 21, covering JVM memory settings, GC selection, connector and thread‑pool optimization, virtual‑thread integration, benchmark scripts, security hardening, high‑availability deployment, and comprehensive monitoring and troubleshooting techniques.
A Spring Boot channel service showed an unexpected 100 ms latency; by systematically checking network, using curl, and employing Arthas to trace Spring MVC and Tomcat internals, the author discovered a Tomcat‑embed bug that repeatedly loads Swagger‑UI JAR resources, which is resolved by upgrading Tomcat.
The article explains how JetBrains' Spring Debugger plugin provides remote debugging for Spring applications without using Java agents, detailing the underlying thread‑model tricks, supported containers, practical features like bean inspection and SQL execution, and step‑by‑step JDWP configuration.
This article explains how to update a Spring Boot application without stopping the service by allowing two processes to share the same port, detailing the underlying Tomcat embedding, DispatcherServlet handling, and providing step‑by‑step code and a live demo to achieve seamless zero‑downtime deployments.
This article explains how to update a Spring Boot application without stopping the old process by letting a new instance start on the same port, detailing the Tomcat internals, the required ServletContainerInitializer callbacks, and providing a complete, step‑by‑step implementation with code samples and a live test.
This comprehensive guide walks you through diagnosing Full GC pauses on a Java 2020 production outage, explains JVM memory structures, compares JDK 21 garbage collectors, and provides step‑by‑step installation, configuration, and tuning instructions for Tomcat, monitoring tools, and real‑world case studies to achieve stable, high‑throughput services.
A detailed benchmark shows that enabling Java virtual threads in Spring Boot 4.0 makes Tomcat handle up to fifteen times more requests than Jetty, while startup times remain similar, and the article explains the test setup, configuration steps, native image builds, and the reasons behind Jetty's limitation.
This article explains how to update a SpringBoot application without stopping the service by letting the old and new processes share the same port, detailing the underlying Tomcat and ServletContainerInitializer mechanisms, providing a step‑by‑step implementation and a demo for seamless zero‑downtime deployments.
This article provides a comprehensive technical walkthrough of Tomcat, covering its connector and container architecture, lifecycle management, key design patterns such as Composite and Template Method, custom class‑loading mechanisms, hot‑reload process, and includes essential code snippets and diagrams for developers.
This guide walks you through Tomcat's concepts, its role as a Java servlet container, step‑by‑step installation and configuration, detailed directory structure, deployment of a sample zrlog application, and how to set up multiple Tomcat instances on a single server, complete with code examples and log configuration.
Learn how to secure Apache Tomcat by applying a 13‑item baseline that covers account permissions, root‑less operation, strong passwords, disabling manager apps, preventing directory listing, restricting HTTP methods, enabling HTTPS, changing default ports, configuring access logs, custom error pages, hiding server banners, and limiting connections.
This guide walks you through why Tomcat's default JVM settings are insufficient, common pitfalls when manually editing catalina.sh, and the recommended, maintainable approach using setenv.sh to configure heap, Metaspace, and GC options for reliable, high‑performance server operation.
This article explains how to replace SpringBoot's default embedded Tomcat with the high‑performance Undertow server, details the necessary Maven changes, compares Tomcat and Undertow in terms of throughput and memory usage, and concludes why Undertow is the better choice for high‑concurrency Java web applications.
Large enterprises are increasingly replacing Spring Boot’s default embedded Tomcat with Undertow because Undertow delivers superior memory efficiency, higher concurrency, lower latency, and more flexible configuration, as demonstrated by detailed performance benchmarks, architectural analysis, and real‑world migration case studies presented in this article.
This comprehensive guide shows how a seasoned operations engineer can dramatically improve Tomcat stability and throughput by understanding JVM memory structures, configuring optimal JVM and connector parameters, selecting the right garbage collector, and implementing robust monitoring and diagnostics to prevent crashes and latency.
A detailed post‑mortem explains how a sudden traffic surge, insufficient pod count, and a custom thread‑pool bottleneck caused Tomcat thread‑pool saturation, health‑check failures, and a zone‑wide outage, and offers concrete lessons on capacity planning, monitoring, and safe coding practices.
This article walks through ten practical Spring Boot configuration optimizations—including Tomcat connection pool, HikariCP, Jackson timezone handling, Logback rotation, Caffeine caching, Actuator endpoint exposure, file upload limits, async thread pools, static resource caching, and transaction timeouts—providing ready‑to‑use YAML snippets and clear explanations for each setting.
This article explains how to achieve zero‑downtime updates for SpringBoot applications by allowing two processes to share the same port, detailing the underlying Tomcat and ServletContainerInitializer mechanisms, providing a step‑by‑step implementation with code examples, and demonstrating seamless hot‑swap without service interruption.
An in‑depth investigation of a Java service’s memory alarm reveals that a surge of temporary NioChannel objects, caused by high QPS and insufficient socket reuse, prematurely promotes objects to the old generation, leading to uncollected memory growth, and the article details the diagnosis, GC tuning, and mitigation steps.
This comprehensive guide explores Tomcat’s mature architecture, detailing its connector and container components, the underlying design patterns such as composite, observer, and template method, and the custom class‑loading mechanisms that enable modularity, hot‑reloading, and isolation for Java web applications.
This guide provides four ready-to-use one‑click scripts for Linux that automate the installation of a Rust development environment, Tomcat 9 server, Docker engine, and Nginx web server, including supported distributions, usage steps, and post‑install considerations.
This tutorial walks you through preparing separate site directories, editing Tomcat's server.xml to define Host entries, restarting the service, and testing each domain, while also covering firewall, DNS, and production‑grade security considerations for deploying multiple websites on a single CentOS server.
This article presents seven practical Spring Boot performance tuning techniques—including asynchronous execution, Tomcat connection tuning, component scanning, switching to Undertow, BufferedWriter usage, DeferredResult handling, and AsyncHandlerInterceptor interception—each illustrated with concise Java code examples to help developers boost application speed and scalability.
This guide walks you through installing Tomcat via yum or binary packages, configuring its core directories and ports, setting up virtual hosts, and integrating Tomcat with Nginx for static‑dynamic separation, providing complete commands and explanations for a production‑ready Java web server on Linux.
Spring Boot 3.5.3, the first patch of the 3.5 series, introduces critical fixes for a severe issue in 3.5.1, upgrades Tomcat to 10.1.42 with multipart limits, adds ConfigData options support, resolves numerous performance, configuration, actuator, and binding bugs, improves documentation, and updates a wide range of core, database, server, and monitoring dependencies, making the upgrade strongly recommended.
This guide explains how to adapt a distributed micro‑service architecture to run all SpringBoot services inside one external Tomcat instance by changing packaging to WAR, configuring server.xml, setting memory options, adjusting virtual addresses, handling logs, and registering services with Nacos for low‑memory environments.
This article explains the default and recommended log patterns for Tomcat and Apache HTTPD, provides detailed descriptions of each log parameter, shows sample log entries, and compares how different browsers appear in the server logs.
Learn how to configure Tomcat virtual hosts on a CentOS server to host multiple websites with different domain names, covering directory preparation, server.xml modifications, restarting Tomcat, testing access, firewall and DNS considerations, and essential tips for a reliable deployment.
This guide walks you through installing Tomcat on Linux, configuring its core components, understanding its directory layout, deploying a sample Java web application, and setting up multiple independent Tomcat instances on a single server for efficient resource utilization.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, details the configuration steps and Maven dependencies, compares performance and memory usage between the two servers, and concludes with a recommendation for high‑concurrency applications, while also promoting related AI resources and services.
The article explains the practical limitations of using only Tomcat—such as DNS IP caps, scaling costs, deployment downtime, and lack of health checks—and demonstrates how adding Nginx as a reverse proxy and load balancer resolves these issues with concrete configuration examples.
This article explains how Spring Boot’s default embedded Tomcat container can be replaced with the high‑performance Undertow server, provides step‑by‑step Maven configuration, compares their performance and memory usage, and concludes with a recommendation for high‑concurrency applications while also containing promotional material for AI services.
Learn how to configure Tomcat virtual hosts on a CentOS server to host multiple websites with distinct domain names, covering directory preparation, server.xml modifications, firewall and DNS settings, testing, and restart procedures, complete with code snippets and practical tips.
This article explains how to use Nginx to implement gray release—gradually rolling out a new application version to a subset of users—by configuring header‑based, cookie‑based, and IP‑address‑based routing strategies, detailing the required Nginx directives, deployment steps, and verification process.
This article explains how Spring Boot eliminates XML configuration and embeds servlet containers like Tomcat by analyzing Maven dependencies, core startup methods, WebServer creation, and the lifecycle methods that ultimately start and stop the embedded Tomcat instance.
This article explains how to replace Spring Boot's default embedded Tomcat server with Undertow, detailing Undertow's features, Maven dependency changes, performance and memory benchmarks, and provides step‑by‑step configuration code to improve high‑concurrency Java web applications.
This article explains how SpringBoot uses Tomcat by default, shows how to replace it with Undertow by adding the appropriate dependency, and presents benchmark results demonstrating Undertow's superior throughput and lower memory consumption for high‑concurrency Java web applications.
This article explains how to replace Spring Boot's default embedded Tomcat with the Undertow container, details the configuration steps, and presents benchmark results showing Undertow's superior throughput and lower memory usage under high‑concurrency workloads, making it a better choice for performance‑critical applications.
The article explains how to update a SpringBoot application without stopping the old process by detecting port usage, temporarily launching a new instance on an alternate port, then seamlessly switching the original port to the new instance, achieving near‑zero downtime.
This article explains how SpringBoot’s default embedded Tomcat can be replaced with the high‑performance Undertow server, shows the necessary Maven dependencies, lists Undertow’s key features, presents benchmark results comparing QPS and memory usage, and concludes with recommendations for high‑concurrency applications while also noting related AI‑product promotions.
This article explains how SpringBoot's default Tomcat container can be swapped for the high‑performance Undertow server, details Undertow's characteristics, provides Maven configuration steps with code snippets, and presents benchmark results showing superior throughput and lower memory usage for high‑concurrency applications.
This article explains the default Tomcat settings in Spring Boot 2.7.10, details core parameters such as connection queue length, max connections, thread pool sizes, keep-alive and timeout options, and demonstrates how to inspect and test these configurations with code examples and command-line tools.
The article details a step‑by‑step investigation of an unexpected ~100 ms latency in a Spring Boot‑based channel system, covering network checks, curl measurements, Arthas trace and watch commands, identification of TomcatJarInputStream’s repeated jar‑resource loading caused by Swagger dependencies, and the final fix by upgrading the embedded Tomcat version.
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.
This guide explains why Tomcat's default development settings need tuning for production, covering JVM memory model basics, configuration file edits, thread pool and connector adjustments, as well as security hardening steps to improve performance and stability.
This guide explains how to optimize Tomcat by adjusting maxThreads, acceptCount, maxConnections, and connectionTimeout, while also tuning Linux kernel parameters, TCP settings, and JVM options to achieve balanced CPU and I/O performance for high‑concurrency web services.
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 guide walks you through Tomcat’s overview, multiple installation methods, essential configuration files, port settings, virtual‑host setup, and how to combine Tomcat with Nginx for static‑dynamic separation, providing a complete Linux‑based deployment workflow.
This article provides a comprehensive analysis of Spring Boot 2.7.10's embedded Tomcat 9.0.73 default settings, core parameters, internal thread architecture, configuration examples, performance testing with various concurrent connections, and includes detailed code snippets and diagrams, while also containing promotional material for AI services.
The article details a step‑by‑step performance investigation of a Java Spring backend that initially handled only 50 requests per second under load, covering slow SQL, excessive logging, thread‑pool misconfiguration, prototype‑scoped Redis beans, JVM memory settings, and the resulting optimizations that raised throughput to over 200 TPS.
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 guide explains Tomcat and Apache HTTPD log configurations, recommended patterns, detailed parameter meanings, and shows how log entries vary across browsers like Edge, IE, Firefox, and Chrome.
This tutorial shows how to configure Spring Boot 3 to start multiple Tomcat servers, isolate services into separate modules with shared parent configuration, and test the endpoints, providing full code snippets and screenshots for each step.
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 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.
This guide explains Tomcat and Apache httpd log configurations, showing default and recommended patterns, detailed parameter meanings, sample log entries, and how different browsers appear in the logs, providing a comprehensive reference for developers and operators managing server logging.
This article explains the purpose of Java's parent‑delegation class‑loading mechanism, describes its three built‑in loaders, shows how custom loaders can override it, and explores common situations—such as JNDI, JDBC, Tomcat, and OSGi—where developers intentionally break the delegation for flexibility and modularity.
This article investigates a production issue on Java 21 where virtual threads cause Tomcat to stop processing requests, closeWait sockets to accumulate, and locks to deadlock, detailing the diagnostics, thread‑dump analysis, lock inspection, and the eventual conclusions about virtual‑thread behavior.
This article explains what Tomcat is, its core functions, how to set up a simple servlet manually, and why Spring Boot hides Tomcat by default while still allowing you to switch to alternatives like Jetty or Undertow.
After upgrading from Tomcat 7 to Tomcat 8, the application’s mixed log4j‑1.4 and logback‑1.2.3 dependencies caused the SLF4J binder to be loaded nondeterministically, so Tomcat 8 sometimes selected the Log4j binder without a configuration file, resulting in completely missing log output; removing the conflicting jars or enforcing a deterministic class‑loading order restored logging.
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 guide explains step‑by‑step how to modify source files and configuration settings in Nginx, Apache, and Tomcat to replace version strings with custom placeholders, then recompile or repack the binaries, effectively hiding server version details from clients.
Apache Tomcat is the underlying servlet container and web server that Spring Boot automatically embeds via the spring‑boot‑starter‑web dependency, but junior developers often miss its core roles—managing servlet lifecycles, serving static resources, and compiling JSPs—so learning Tomcat (or swapping it for Jetty by adjusting Maven exclusions) clarifies what Spring Boot abstracts and enables flexible container choices.
This article builds a simple Spring Boot Greetings API, configures Maven profiles for Tomcat, Jetty, and Undertow, creates Docker images for each, runs load‑testing benchmarks across multiple concurrency levels, and analyzes startup time, CPU, memory, and response performance to determine the optimal embedded server.
The article explains Java's parent delegation model for class loaders, its benefits for stability and security, how to break it by customizing loadClass or using thread‑context class loaders, and illustrates common scenarios such as JNDI, JDBC and Tomcat's own class‑loader hierarchy.
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.
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 guide explains how to switch the embedded web server in Spring Boot 3.2.5, disable it, customize ports (including random and range ports), enable HTTP compression, configure SSL and HTTP/2, add servlets, filters, listeners, set up logging, and fine‑tune Tomcat and Undertow settings, all with practical code examples.
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 explains how to enable two SpringBoot processes to share the same port for seamless code updates, covering the underlying servlet container mechanics, the required initialization flow, and providing a complete Java implementation with a demo that achieves near‑zero downtime during deployment.
An October 2023 outage of the bfe‑customer‑application‑query‑svc revealed how traffic spikes, downstream latency, and a mis‑configured custom thread pool saturated Tomcat's worker threads, causing health‑check failures, pod restarts, and a complete zone failure.
This article explains how Spring Boot's request capacity is determined by Tomcat's configuration parameters, demonstrates the impact of min‑spare, max threads, max‑connections, and accept‑count through a small example, and discusses concurrency pitfalls caused by singleton beans.
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.
The article explains why deploying only Tomcat without Nginx is impractical due to DNS IP limits, scaling costs, lack of health checks, and static file handling, and demonstrates how Nginx provides load balancing, failover, virtual hosting, and reverse‑proxy capabilities with concrete configuration examples.
This guide explains how to tune Tomcat 8.5 by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file‑descriptor limits, and JVM options to achieve optimal concurrency and response times.
This article explains the default Tomcat settings bundled with Spring Boot 2.7.10, details core parameters such as accept‑count, max‑connections, thread pool sizes, and timeouts, describes the internal Acceptor and Poller threads, provides configuration examples and testing results, and includes reference links.
This article explains the purpose of Java's parent delegation class‑loader mechanism, describes its three built‑in loaders, and details common scenarios—such as JNDI, JDBC, Tomcat, and OSGi—where developers intentionally break the delegation to achieve flexibility and isolation.
On October 27, 2023, a sudden surge in request volume and downstream latency caused the bfe‑customer‑application‑query‑svc to exhaust its Tomcat thread pool, triggering health‑check failures and pod restarts; a deep dive revealed that an ill‑designed custom executor and unchecked thread‑waiting calls created a bottleneck that amplified the outage.
The article explains why deploying only Tomcat without Nginx leads to scaling, cost, and reliability problems, and demonstrates how Nginx’s health‑check, failover, and virtual‑host features complement Tomcat to build a robust, production‑grade web architecture.
This guide walks through setting up a complete CI/CD environment on three CentOS 7.6 machines—GitLab, Jenkins, and Tomcat—covering installation, configuration, plugin management, Maven integration, SonarQube scanning, and automated deployment of a Java web application.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, outlines the configuration steps, compares their performance and memory usage through benchmark results, and concludes that Undertow offers superior throughput for high‑concurrency Java web applications.
This guide walks through importing a CentOS 7 virtual machine in VMware, configuring network settings (dynamic or static IP), resolving common issues, then installing and configuring JDK 1.8, MySQL 5.7, and Tomcat 8.5, and finally creating systemd services for automatic startup of Java applications.
This guide demonstrates how to leverage Maven resource filtering for automatic property expansion in Spring Boot 3.2.5, configure externalized settings via spring.main and system properties, customize configuration file locations, activate profiles, set parent containers, modify DispatcherServlet paths, enable Tomcat access logs, MBean registry, and generate build and Git metadata.
This article explains how SpringBoot defaults to an embedded Tomcat container, shows how to replace it with Undertow by adding the appropriate dependency, and compares the two servers' performance and memory consumption through benchmark results, concluding that Undertow is preferable for high‑concurrency Java backend applications.
This guide explains why Tomcat’s default settings are unsuitable for production, then walks through JVM memory tuning, thread‑pool adjustments, connector optimizations, and security hardening to dramatically improve stability and throughput on various server configurations.
This article explains how to optimize Tomcat by adjusting server.xml parameters such as maxThreads, acceptCount, maxConnections, and connectionTimeout, while also covering related Linux kernel settings, file descriptor limits, and JVM options to achieve balanced performance for both CPU‑bound and I/O‑bound workloads.
This article explains how to replace the default embedded Tomcat container in Spring Boot with Undertow, compares their performance and memory usage through load tests, and demonstrates why Undertow is a better choice for high‑concurrency Java web applications.
This article explains the default Tomcat settings bundled with Spring Boot 2.7.10, details core parameters such as connection queues, thread pools, keep‑alive limits, and timeouts, and demonstrates how to monitor and test these settings with code examples and network tools.
This article dissects Tomcat’s mature architecture, explaining its macro and micro design, startup flow, connector and container components, lifecycle management, class‑loader hierarchy, hot‑reload mechanism, and how developers can apply the demonstrated patterns such as composite, observer, template method, and strategy in real projects.
This article walks through an interview question about the maximum concurrent requests a default SpringBoot application can process, builds a minimal demo, examines Tomcat and Undertow thread‑pool configurations, and shows how container defaults and parameters like core size, max size, and queue length determine the real limit.
Passing a HttpServletRequest to a regular thread in Spring Boot causes Tomcat to recycle the request after the servlet returns, making parameters unavailable and yielding null values, so you must use the servlet async API (startAsync and complete) to keep the request alive.
This article explains multiple backend optimization methods for Spring Boot, including asynchronous execution with @Async and CompletableFuture, increasing embedded Tomcat connection limits, using @ComponentScan, switching to Undertow, applying BufferedWriter, employing DeferredResult, and intercepting async calls with AsyncHandlerInterceptor, accompanied by concrete code examples.
This tutorial walks through importing a CentOS7 virtual machine into VMware, configuring static or dynamic IP settings, installing JDK 1.8, setting up MySQL 5.7 with remote access, and deploying Tomcat 8.5 and a Spring Boot service for automatic startup, including common pitfalls and fixes.
This article explains the default Tomcat settings in Spring Boot 2.7.10, detailing connection queues, thread pool parameters, timeout configurations, and internal threading architecture, and provides practical examples and testing results for various concurrent connection scenarios.
