Feat 2.2.0 launches a Java web framework that mimics Spring Boot's developer experience while discarding legacy Servlet APIs, introducing compile‑time code generation and a smart‑socket engine that delivers roughly double the throughput of Vert.x with sub‑millisecond latency.
The article examines three outdated provisions in the Servlet specification—full‑annotation scanning that slows startup, an overreaching security model, and a half‑baked async API—explaining how they hinder modern cloud‑native development and how Spring’s ecosystem has filled each gap, while also suggesting lightweight alternatives.
The article explains how to achieve zero‑downtime code updates for SpringBoot applications by detecting port usage, launching a new instance on an alternate port, swapping the servlet container back to the original port, and terminating the old process, with a complete code example and a live demo showing sub‑second interruption.
The article explains how to update a Spring Boot application without stopping the service by letting two processes share the same port, detailing the underlying Tomcat and ServletContainerInitializer mechanisms, the step‑by‑step implementation, and a demo that shows sub‑second downtime during hot swaps.
This article examines five typical pitfalls when using Spring Boot filters—request body consumption, ThreadLocal leakage, duplicate execution, ordering conflicts, and async handling—provides concrete code examples, explains why each issue occurs, and offers reliable solutions to keep your applications stable and secure.
The article explains what SpringBoot Filters are, their core methods, three registration approaches, practical examples such as encoding, logging, and request blocking, the execution order among multiple filters, a full request chain overview, and a detailed comparison with Interceptors, concluding with usage recommendations.
This guide walks through the end-to-end setup of a WeChat public-account keyword auto-reply, covering the message flow, required server configuration in the WeChat console, and Java servlet implementations for the GET verification and POST message-handling endpoints.
This article explains the fundamental differences between Spring MVC interceptors and servlet filters—including definition, scope, configuration, lifecycle, and execution timing—and details their processing order with illustrative code samples and a request flow diagram.
This guide shows how to leverage IntelliJ IDEA's diagram feature to visualize inheritance and interface relationships of Java classes, prune irrelevant nodes, inspect members, filter visibility, add additional classes, and quickly jump to source code, making code navigation far more efficient.
This article explains how Java developers can retrieve a client’s IP address from an HttpServletRequest, handle proxy headers, and use the ip2region library (via Maven) to map the IP to its province and city, including code snippets and configuration details.
This article explains how to replace annotation‑based controllers with Spring Boot 3 functional routing, covering both servlet‑blocking and reactive WebFlux implementations, complete with code examples for handlers, routers, parameter validation, nested routes, filters, and resource redirects.
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 guide shows how to use IntelliJ IDEA's diagram feature to display, clean up, and explore the inheritance and interface implementation hierarchy of Java Servlet classes, including filtering unwanted nodes, inspecting members, adjusting visibility, zooming, adding related classes, and jumping to source code.
This guide shows how to use IntelliJ IDEA's diagram feature to view, customize, and navigate Java Servlet inheritance and interface implementation graphs, including filtering classes, inspecting members, adjusting visibility, zooming, adding related classes, and jumping directly to source code.
Learn how to quickly generate and customize clear inheritance diagrams for Java Servlet classes using IntelliJ IDEA’s diagram feature, including viewing relationships, filtering classes, inspecting members, adjusting visibility, adding classes, and navigating source code—all illustrated with step‑by‑step screenshots.
The article reviews Java technologies that have become outdated—such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML—explaining why they no longer merit learning and recommending modern alternatives like Spring MVC, MyBatis, and a deep understanding of Servlets for today's backend development.
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.
The article reviews decades of Java evolution, evaluates JSP, Struts, Hibernate, Servlet and other legacy tools against real‑world usefulness, interview relevance, and learning value, and advises developers on which technologies to drop and which fundamentals to master.
This guide shows how to use IntelliJ IDEA's diagram feature to visualize, clean up, and explore Java Servlet inheritance hierarchies, including removing irrelevant classes, viewing method details, zooming, adding related classes, and jumping directly to source code.
This article introduces a Java utility class named CompressUtil that provides methods for compressing files and directories into ZIP archives, handling duplicate filenames, creating new files safely, and offering HTTP endpoints for downloading the generated ZIP files in a single request.
This article introduces Spring Boot 3's filter mechanism, outlines core functions and application scenarios, and provides detailed code examples for eight built‑in filters such as CharacterEncodingFilter, CorsFilter, and HiddenHttpMethodFilter, helping developers build secure and efficient web applications.
This article reviews common Java backend technologies, explains why JSP, Struts, Hibernate and several legacy tools are no longer worth learning, and highlights the essential concepts—especially deep mastery of Servlets—that modern Java developers should focus on in 2024.
Web containers, such as Tomcat, keep running by continuously listening on network ports with socket servers and thread pools, handling I/O requests; this article explains the role of the main function, servlet lifecycle, Netty’s NIO framework, and why WebFlux‑based gateways outperform traditional Tomcat setups.
The article reviews several Java backend technologies—JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC, and XML—explaining why they are now considered obsolete or low‑priority and recommending modern alternatives such as Spring MVC, MyBatis, and deep Servlet knowledge for current development.
Based on 20 years of Java experience, this article evaluates Java technologies like JSP, Struts, Hibernate, and Servlet against practical use, depth of understanding, and interview relevance, recommending which to drop, which to master, and highlighting alternatives such as Spring MVC and MyBatis.
The article reviews a Java veteran's 20‑year experience to identify backend technologies such as JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC and XML that are now outdated or less essential, and recommends focusing on Spring MVC, MyBatis and a deep understanding of Servlets for modern development.
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.
This article explains how Spring Boot can handle HTTP requests asynchronously using Callable, WebAsyncTask, and DeferredResult, detailing the underlying servlet workflow, thread‑pool configuration, and when asynchronous processing truly improves throughput versus CPU‑bound workloads.
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 reviews outdated Java technologies—JSP, Struts, Hibernate, and others—explaining why they are no longer essential for modern backend development and offering clear guidance on which skills to prioritize or abandon.
This article explains how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including tips for removing irrelevant nodes, inspecting class members, adjusting visibility, zooming, and adding related classes to the diagram.
This guide explains how to use IntelliJ IDEA’s diagram feature to view, clean up, and explore inheritance and interface relationships of Java classes such as Servlets, including removing unwanted nodes, inspecting members, adjusting visibility, zooming, adding classes, and jumping to source code.
The article examines which Java backend technologies are considered obsolete—such as JSP, Struts, Hibernate, and others—by applying criteria like practical usage, depth of understanding, and interview relevance, and advises learners on what to drop, prioritize, or master for modern development.
This tutorial explains how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding other classes, and jumping to source code.
This guide explains how Spring Boot automatically registers Servlet, Filter, and Listener beans, how to customize their mappings with registration beans, configure the embedded servlet container, and handle JSP limitations, providing code examples and practical tips for backend developers.
The article advises Java developers to abandon learning outdated technologies such as JSP, Struts, and Hibernate, while emphasizing the continued importance of mastering Servlets and recommending a shift to modern frameworks like Spring MVC and MyBatis for effective backend development.
This guide explains how to configure Nginx to forward the original client IP using X-Real-IP or X-Forwarded-For headers and provides Java servlet code to reliably extract that IP on the backend.
This article explains why Spring Cloud Gateway originally required Netty and could not run in traditional Servlet containers, introduces the new MVC Servlet support added in Spring Cloud 2023 (Gateway 4.1), and provides step‑by‑step instructions for configuring dependencies, routing rules, and custom filters using Tomcat or other servlet containers.
This article explains how Tomcat starts by running the startup script, invoking the BootStrap main method, initializing Catalina, loading configuration, and managing component lifecycles through the Lifecycle interface, while also detailing default implementations, endpoint types, and protocol handlers.
This article reviews common Java technologies—JSP, Struts, Hibernate, Servlet, and others—evaluating their relevance for modern backend development based on practical usage, depth of understanding, and interview value, and offers clear recommendations on what to study or drop.
This article reviews several Java backend technologies—JSP, Struts, Hibernate, Servlet, and others—explaining why they are considered outdated or unnecessary for modern development and offering guidance on what newcomers should focus on instead.
This article explains the differences between JAR and WAR packaging for Spring Boot applications, shows why embedded Tomcat behaves differently from external Tomcat, and provides step‑by‑step instructions with Maven commands and pom.xml modifications to build both JAR and WAR artifacts.
This tutorial walks through building a Spring MVC environment from scratch with Spring 5.3.26, covering traditional XML configuration, servlet registration via web.xml, annotations, and SPI, and shows how to configure a REST controller and required message converters.
This article explains the servlet specification, core servlet APIs, and how Tomcat implements them, detailing the roles of ServletConfig, ServletContext, ServletRequest, and ServletResponse, and walks through Tomcat’s internal architecture, including server.xml configuration, component hierarchy, and the interaction of Server, Service, Engine, Host, and Context.
This article reviews several Java technologies that have become obsolete or less relevant—such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML—explaining why newcomers can safely ignore them and focus on modern alternatives like Spring MVC, MyBatis, and deep Servlet knowledge.
This article explains why a Spring Boot project runs differently when packaged as a JAR versus a WAR, outlines the historical evolution of Java web containers, compares the characteristics of JAR and WAR files, and provides step‑by‑step Maven commands and pom.xml configurations for building both package types.
This article explains the differences between servlet filters and Spring MVC interceptors, demonstrates how to wrap requests with HttpServletRequestWrapper, use OncePerRequestFilter, configure filters and interceptors in Spring Boot, handle login interception with AJAX redirects, set up listeners, manage static resources, and provides step‑by‑step testing procedures with code examples.
This article reviews several Java backend technologies—JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC, and XML—explaining why they are becoming obsolete or less essential and offering guidance on which ones learners can safely skip or deprioritize.
This article reviews the Java ecosystem, explains criteria for deeming technologies outdated, and advises developers to drop JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML while focusing on mastering Servlets, Spring MVC, and lightweight ORM tools like MyBatis.
This article explains the differences between Spring MVC interceptors and servlet filters, provides complete Java code examples for both, describes how to configure them in Spring and web.xml, and summarizes their respective scopes, lifecycles, and typical use‑cases in web development.
Drawing on two decades of Java experience, this article evaluates outdated Java technologies—JSP, Struts, Hibernate, and others—based on real‑world development relevance, interview usefulness, and depth of understanding, and offers clear recommendations on what to skip and what to master.
The article reviews decades of Java development, explaining why technologies such as JSP, Struts, Hibernate, Applet, Swing, JDBC, and XML are now largely obsolete for new learners, and recommends focusing on Spring MVC, MyBatis, and a deep understanding of Servlets.
This article explains Spring's core features such as IoC, DI, and AOP, demonstrates a simple Hello World application with Spring Boot, then shows how to implement the same functionality using raw Servlets and a handcrafted mini‑Spring framework, complete with code examples and deployment steps.
Passing an HttpServletRequest into an asynchronous thread in Spring Boot can cause mysterious parameter loss and request‑recycling bugs, because Tomcat reuses request objects; the proper solution is to employ the servlet's startAsync and AsyncContext.complete methods for safe async processing.
This article explains Spring's core features such as IoC, DI and AOP, demonstrates creating a simple Hello World service with Spring Boot, then shows how to implement the same functionality using raw Servlets and finally builds a miniature Spring‑like framework with custom annotations, an IOC container and a dispatcher servlet.
This article explains what cookies are, how they are represented and transmitted in HTTP, their lifecycle, common attributes, and demonstrates practical usage with Java's Cookie API, JSP pages, and servlet code to achieve automatic login and session management.
This article provides a comprehensive technical overview of Apache Tomcat, covering its role as a Java EE servlet container, internal components such as Server, Service, Connector, and Container, lifecycle management, startup sequence, deployment configuration, JSP engine, connector types, NIO processing, Comet, and asynchronous servlet handling.
This article provides a comprehensive overview of Apache Tomcat, covering its role as a Java web server, the internal components such as Server, Service, Connector, and Container, the lifecycle management, startup process, connector types, NIO handling, Comet support, and asynchronous servlet processing.
This tutorial demonstrates how to leverage IntelliJ IDEA's diagram feature to view, filter, and explore inheritance and interface implementation relationships of Java Servlet classes, including customizing the diagram, inspecting class members, and navigating source code directly from the visual representation.
This article demonstrates how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including tips for filtering classes, inspecting members, zooming, and adding additional classes to the diagram.
This article demonstrates how to leverage IntelliJ IDEA's diagram feature to clearly view, customize, and explore the inheritance and interface implementation hierarchy of Java Servlet classes, including removing irrelevant nodes, inspecting members, adding extra classes, and jumping directly to source code.
This article explains how a senior architect implements a lightweight Tomcat clone called MyTomcat, covering its socket service, request dispatching, request/response encapsulation, servlet mapping, and the overall processing flow with code examples and diagrams.
This article explains how Spring's HttpMessageConverter abstracts HTTP message conversion, shows how to read request bodies via HttpInputMessage and ServletServerHttpRequest, demonstrates a practical filter using FormHttpMessageConverter, and illustrates writing JSON responses with MappingJackson2HttpMessageConverter, all with concise code examples.
This article provides a comprehensive overview of Apache Tomcat, covering its role as a Java EE web server, core components such as Server, Service, Connector, and Container, the servlet and JSP lifecycles, configuration details, connector types, NIO processing, Comet, and asynchronous servlet handling.
Spring Framework 6.0 milestone introduces Jakarta EE migration, updates core containers and persistence, upgrades servlet baselines, removes deprecated APIs, changes controller scanning rules, and replaces the HttpMethod enum with a class, while previewing the upcoming Spring Boot 3.0 release.
Spring Framework 6.0 milestone introduces Jakarta EE package migrations, updates core containers, overhauls persistence APIs, modernizes servlet middleware with Tomcat 10, Jetty 11, Undertow 2.2.14, removes legacy components, and changes controller scanning and HttpMethod handling, while offering resources for learning Spring Boot and Cloud.
Tomcat is an open‑source Java web server that implements core Java EE specifications such as Servlets and JSP, and its architecture includes containers, connectors, pipelines, valves, and lifecycle management, with detailed explanations of component roles, startup process, deployment, NIO handling, Comet, and asynchronous servlet support.
This guide shows how to use IntelliJ IDEA's diagram feature to view, customize, and explore inheritance and interface implementation relationships of Java Servlet classes, including filtering, expanding details, and navigating source code.
This article provides a detailed overview of Tomcat’s backend architecture, explaining its core components such as the server, service, connector, lifecycle management, protocol handler, endpoint, processor, adapter, and container hierarchy, and includes code examples illustrating the request‑response flow.
This guide shows how to use IntelliJ IDEA’s diagram feature to visualize, clean up, and explore Java Servlet inheritance and interface relationships, including removing unwanted classes, inspecting members, adding new classes, and jumping directly to source code for deeper understanding.
This article explains, using servlet source code as a starting point, how Spring MVC registers @RequestMapping‑annotated controllers into RequestMappingHandlerMapping during container initialization and how the DispatcherServlet processes incoming HTTP requests by locating the appropriate HandlerMethod through a series of handler mappings and interceptor chains.
This guide explains what Servlets and the Servlet specification are, outlines Tomcat's architecture and core components, and walks through the detailed HTTP request processing flow, providing code examples and diagrams for Java backend developers.
Tomcat is an open‑source Java web server that implements core Java EE specifications such as Servlets and JSPs, and its architecture comprises containers like Server, Service, Connector, and Catalina, each with components (Engine, Host, Context, Wrapper) that manage lifecycle stages, request processing pipelines, valves, connectors (BIO/NIO/APR), JSP compilation, and asynchronous servlet handling.
This article explains how Spring MVC evolved from basic Servlets to a front‑controller architecture, detailing the roles of DispatcherServlet, HandlerMapping, HandlerInterceptor, ModelAndView, and ViewResolver in streamlining request handling, business logic separation, and view rendering for modern Java web applications.
This article provides a comprehensive overview of Tomcat, covering its role as an open‑source Java web server, the internal components such as Server, Service, Connector, and Container, lifecycle management, servlet and JSP processing, connector types, pipeline/valve mechanisms, Comet push, and asynchronous servlet support.
This article provides a comprehensive technical deep‑dive into Apache Tomcat, covering its role as a Java EE web server, core components such as Server, Service, Connector, Container, the detailed lifecycle management, servlet and JSP processing, various connector implementations, NIO handling, Comet push technology, and asynchronous servlet support.
This article provides a comprehensive technical guide to Apache Tomcat, covering its servlet container architecture, core components such as Server, Service, Engine, Host, and Context, lifecycle management, request processing pipeline, connector types, JSP handling, asynchronous servlet support, and related code examples.
This article explains the stateless nature of HTTP, how session and cookie mechanisms enable login state in a single web system, the challenges of multi‑system environments, and provides a step‑by‑step guide with code examples for building a Java‑based Single Sign‑On solution, including token generation, validation, and logout handling.
This guide explains three ways to register Servlets in Spring Boot 2.3.9—including @ServletComponentScan with @WebServlet, ServletRegistrationBean, and dynamic registration via ServletContextInitializer—while detailing the underlying scanning mechanism, BeanFactory post‑processor workflow, and how Tomcat ultimately registers the servlet.
This guide demonstrates how to use IntelliJ IDEA's diagram feature to view, customize, and explore the inheritance and interface implementation hierarchy of Java Servlet classes, including filtering irrelevant nodes, inspecting members, adjusting visibility, zooming, adding related classes, and jumping to source code.
Understanding Java web backend requires grasping how Tomcat parses HTTP requests, dispatches them through servlets, JSPs, listeners and filters, and then leverages Spring’s IoC, AOP, MVC, Boot’s auto‑configuration, and Cloud’s micro‑service tools to build robust, industrial‑grade applications.
This article explains the fundamentals of Servlet 3.0 asynchronous processing, demonstrates how Spring MVC builds on the Servlet API, and provides multiple practical examples—including starting async support, using AsyncContext, custom threads, listeners, timeouts, and real‑world scenarios—to help developers master non‑blocking request handling in Java web applications.
This article explains Spring's core concepts such as IOC, DI, and AOP, demonstrates building a simple Hello World with SpringBoot, then shows how to recreate the same functionality using raw Servlets and a handcrafted mini‑Spring framework with full code examples.
This article walks through the evolution from traditional Servlets to Spring MVC's DispatcherServlet, explaining how each component—Servlet, BaseServlet, DispatcherServlet, HandlerMapping, HandlerInterceptor, HandlerExecutionChain, ModelAndView, ViewResolver, and View—contributes to a cleaner, more modular server‑side architecture.
Tomcat 10.0.x targets Jakarta EE 9, requiring code changes from javax.* to jakarta.* when migrating from Java EE, and introduces key fixes such as async read regression resolution, safe concurrent ServletInputStream.isReady() calls, and an updated Tomcat Native package built with OpenSSL 1.1.1k.
This article explains the thread‑safety differences between StringBuilder and StringBuffer, demonstrates the problems of using mutable shared objects in multithreaded Java code, presents three solutions, and discusses why Servlets are not thread‑safe by default, highlighting visibility and ordering concepts.
An in‑depth guide covering Java reflection fundamentals, three methods to obtain Class objects, and practical code examples, followed by a comprehensive overview of computer networking layers, protocols, TCP/IP versus OSI models, transport protocols, HTTP/HTTPS differences, status codes, GET/POST, cookies, sessions, tokens, and servlet lifecycle.
The article explains how multithreading can improve web request throughput and scalability, illustrates performance gains with example I/O tasks, discusses pitfalls of shared HashMap in servlets, and presents thread‑safe caching solutions using ConcurrentHashMap and FutureTask to reduce latency and avoid concurrency bugs.
This article demonstrates how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including tips for customizing the view, inspecting members, and navigating to source code.
This article explains the HttpServletResponse object's role in Java web development, details common response header methods, highlights differences between addXXX and setXXX, and provides four complete servlet code examples covering cache control, page refresh, file download (including Chinese filenames), and dynamic image generation.
This article explains the fundamentals of HttpSession in Java web applications, covering its server‑side nature, underlying JSESSIONID cookie mechanism, lifecycle, common API methods, configuration, and provides several practical code examples such as login verification, shopping cart handling, duplicate‑submission prevention, and cookie‑disabled session strategies.
This guide explains how to use IntelliJ IDEA's diagram feature to view, clean up, and explore the inheritance and interface implementation relationships of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding related classes, and navigating to source code.
This article explains the role of Servlet Filters in Spring Boot, details their execution chain, shows how to implement custom filters, and provides step‑by‑step configurations using FilterRegistrationBean and @WebFilter, including a practical CORS filter example.
This article walks through creating a lightweight Spring MVC‑like framework by setting up a clean web project, defining custom annotations, implementing a DispatcherServlet that scans packages, instantiates beans, performs dependency injection, maps URLs to controller methods, and finally runs the application without any Spring dependencies.
This guide shows how to use IntelliJ IDEA's diagram feature to clearly display inheritance and interface relationships of Java Servlet classes, remove irrelevant nodes, explore class members, add additional classes, and quickly navigate to source code, making backend code comprehension much easier.
This guide shows how to use IntelliJ IDEA’s diagram feature to visualize Java Servlet inheritance and interface relationships, remove irrelevant classes, display detailed members, zoom the view, add additional classes, and quickly jump to source code, making backend code exploration much easier.
This article walks through the complete Spring MVC request handling flow, from setting request attributes and locating the handler to executing interceptors, invoking the controller, resolving the view, and finally rendering the response, with detailed code examples for each step.
This article explains how to configure UTF-8 encoding in Gradle, capture request/response bodies in a servlet filter for logging, transform database fields into JSON using a custom MyBatis type handler, and define the corresponding resultMap and SQL query for backend services.
This tutorial demonstrates how to leverage IntelliJ IDEA's diagram feature to view, clean up, and enrich the inheritance and interface implementation hierarchy of Java Servlet classes, including removing irrelevant nodes, inspecting class members, adding new classes, and jumping to source code.
This article explains how Tomcat, a popular Java web server and servlet container, handles incoming HTTP requests by providing socket services, distributing URLs to web applications, encapsulating request and response objects, and invoking servlet classes, illustrated with step‑by‑step screenshots of a simple implementation.
