This article explains Spring Boot's HttpMessageConverter and Content Negotiation mechanisms, covering default converters, source code flow, customization via WebMvcConfigurer, and troubleshooting 415/406 errors.
A backend query interface took 12 seconds despite a 300ms SQL query because it returned 100,000 records directly to the frontend, causing massive object creation, JSON serialization, memory spikes, and GC pressure; the fix involved pagination, DTO projections, separate export endpoints, and monitoring response size.
This article explains how @EnableWebMvc imports WebMvcConfigurationSupport, triggering @ConditionalOnMissingBean to skip WebMvcAutoConfiguration entirely, causing loss of static resource mapping, custom message converters, content negotiation, and spring.mvc.* properties, while showing the correct pattern of implementing WebMvcConfigurer without the annotation.
This article explains how Spring MVC's @ControllerAdvice selects exception handlers by inheritance depth, how @Order prioritizes multiple advice classes, which scope attributes limit coverage, and why Filter exceptions, 404 errors, and afterCompletion interceptor exceptions escape global handling.
This article explains how Spring Boot 2.6's switch from AntPathMatcher to PathPatternParser breaks existing path patterns in interceptors and static resources, details the syntax differences, shows how to fix patterns using {*path} capture groups, and provides troubleshooting techniques including actuator/mappings and unit testing with PathPatternParser.
This article traces an HTTP request through Spring Boot's Servlet and reactive stacks, explaining how SpringApplication chooses between Tomcat and Netty, detailing Netty's event-loop decoding, Spring Cloud Gateway's routing and filtering, Tomcat's request processing to DispatcherServlet, and four common gateway-downstream issues including timeout alignment, header forwarding, thread-model mismatch, and unsafe retries.
This article introduces Apache Fory, a high-performance multi-language serialization framework, and demonstrates its integration with Spring Boot 3.5.0, showing up to 3x throughput improvement over Jackson in JSON benchmarks with code examples for binary, JSON, and row-format serialization.
The author demonstrates how Spring Boot 4's built-in API versioning via Spring MVC eliminates duplicated controller hierarchies by using header-based version routing, semantic version matching, and default version fallbacks, allowing per-endpoint versioning without copying unchanged endpoints.
This tutorial demonstrates how to create a custom @ConvertJson annotation in Spring Boot 3.5.0 that automatically fetches JSON from a URL parameter and converts it into a typed Java object, using HandlerMethodArgumentResolver and BeanPostProcessor for both method-parameter and field-level injection with SpEL support.
This article explains why Spring Cloud Gateway cannot coexist with Spring MVC due to fundamental model differences, and details how Spring Boot's DeferredImportSelector and conditional annotations enable intelligent auto-configuration by evaluating classpath, beans, and environment at runtime.
The article details a puzzling Spring MVC file‑upload issue where parameters vanish when the token is sent in a header, tracing the problem through multipart/form‑data parsing, premature request‑body consumption by custom filters, request.getParameter() side effects, and the HiddenHttpMethodFilter, and provides the correct remediation steps.
This article explains why a common API prefix (e.g., /api/v1) is useful in microservice or front‑back separation projects and demonstrates seven practical techniques—custom DispatcherServlet registration, YAML configuration, SpEL‑based @RequestMapping, custom composed annotation, WebMvcConfigurer addPathPrefix, internal forwarding, Spring Cloud Gateway ProxyExchange, and Nginx reverse proxy—using Spring Boot 3.5.0 examples and code snippets.
Spring Boot’s Filter and Interceptor can both intercept requests, but developers often misuse them; this article explains five frequent traps—null autowiring in Filters, execution order mistakes, @Value timing issues in Interceptors, Swagger blocking, and exception handling—offering concrete fixes and a decision guide.
This guide walks through configuring comprehensive logging in Spring Boot 3.5 for eight common scenarios—including JPA SQL, transaction flow, JDBC operations, RestTemplate, RestClient, WebClient, controller requests, and Feign calls—providing concrete code samples, YAML settings, and sample output to help developers troubleshoot and monitor applications effectively.
The article explains that @RequestBody in Spring Boot is not just a JSON deserializer but a unified HTTP request‑body entry point that can process JSON, XML, plain text, binary streams, byte arrays, form data, files and custom media types through Spring MVC's HttpMessageConverter system.
This article explains a standard Spring MVC + OpenFeign design pattern for microservices, where a contract‑first interface defines routing and API specs, Controllers implement business logic, and Feign clients reuse the same interface for remote calls, with full Maven project setup, code samples, and Nacos integration.
The article explains how Spring’s parent‑child container pattern separates core beans like DataSource and TransactionManager from business‑level beans, improving modularity, configuration reuse, decoupling, and flexible bean management, and shows concrete XML and Spring Boot examples for defining and loading these containers.
This article explains how SpringBoot’s DispatcherServlet acts as the central dispatcher of the Web module, detailing its role and the surrounding core components—HandlerMapping, HandlerAdapter, HandlerExceptionResolver, ViewResolver, and HttpMessageConverter—along with practical code examples and common pitfalls.
This comprehensive guide explains the purpose, configuration attributes, and practical usage of Spring MVC request‑mapping annotations, Spring dependency‑injection annotations, scope settings, and conditional annotations, providing code snippets and visual examples for each feature.
This guide explains how the WebMvcConfigurer callback interface lets developers extend Spring MVC behavior without disabling Spring Boot’s auto‑configuration, covering the full request lifecycle, common customizations such as interceptors, CORS, message converters, static resources, async support, and production‑grade pitfalls.
The article walks through the discovery of an arbitrary ZIP‑file download vulnerability in a large OA front‑end, detailing how the attacker traced the vulnerable Spring MVC controller, built a PoC using a controllable cookie, achieved directory‑traversal reads, demonstrated a DOS extension, and finally suggested input‑filter mitigations.
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.
The article explains how Lombok’s @Data annotation generates getter and setter methods with a lowercase first letter for camel‑case fields, causing Jackson to serialize JSON property names in all lowercase, and offers three fixes: write methods manually, use @JsonProperty, or rename fields to avoid lower‑upper patterns.
The article explains the concept of parent‑child containers in Spring, outlines three key benefits—modularization, scoped bean visibility, and configuration reuse—provides step‑by‑step XML and Java code examples, and shows how the containers integrate with Spring MVC to create a cleaner, more maintainable application architecture.
The article explains how Spring WebFlux replaces the thread‑per‑request blocking model of Spring MVC with an asynchronous, non‑blocking, reactive architecture that uses fewer threads for high‑concurrency I/O workloads, while also outlining its learning curve, ecosystem constraints, and practical decision guidelines for when to adopt it.
This article explains how to transfer the current user ID extracted from a JWT token in a filter to Spring MVC controller methods using a custom HandlerMethodArgumentResolver, highlighting drawbacks of ThreadLocal and request attributes, and demonstrating a type‑safe, extensible solution with code examples.
This article explains how to redesign Spring MVC controllers by introducing a unified response wrapper, handling String conversion issues, applying JSR‑303 validation, creating custom validators, and centralizing exception handling to produce clean, maintainable backend code.
This article explains Spring’s data‑binding fundamentals, outlines the core DataBinder properties and control parameters, and demonstrates seven practical techniques—including simple POJO binding, @RequestParam, @RequestBody, nested objects, collection binding, HTTP‑header binding, and custom converters with @InitBinder—plus validation, error handling, performance advice, and troubleshooting tips for building robust Spring Boot applications.
This article explains the fundamental differences between Spring MVC interceptors and servlet filters, provides complete Java code examples for both, shows how to configure them in Spring and web.xml, and summarizes when to choose each approach for request handling and AOP-like functionality.
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 redesign Spring MVC controllers by introducing a unified response wrapper, leveraging ResponseBodyAdvice for automatic packaging, fixing String conversion issues, applying JSR‑303 validation with custom rules, and implementing global exception handling to keep controller code clean and maintainable.
This guide walks through creating Spring MVC controllers using @Controller, implementing the Controller interface, extending AbstractController, mapping URLs and HTTP methods, handling request parameters, returning ModelAndView, performing redirects, processing forms, uploading files, autowiring services, and adhering to the single‑responsibility principle.
This article analyzes the CPU spikes that occur within minutes after a Java service restart, explains how excessive Runnable threads, frequent context switches, and JIT compiler activity cause the overload, and presents step‑by‑step diagnostics and mitigation strategies such as traffic greying, cache pre‑warming, request‑parameter cleanup, and JVM warm‑up.
This article provides a comprehensive overview of Spring Web MVC and Spring Boot annotations—including @RequestMapping, its attribute set, shortcut mapping annotations, controller advice, dependency injection, bean scopes, conditional configuration, and related component stereotypes—illustrated with code snippets and diagrams for Java backend developers.
This comprehensive guide explains the most common Spring Boot annotations—including request mapping, bean definitions, dependency injection, scopes, and auto‑configuration—providing clear examples and usage tips for Java backend developers.
This article explains how to design Spring MVC controllers with a unified response structure, implement request validation using JSR‑303 and custom annotations, handle exceptions uniformly, and resolve issues with ResponseBodyAdvice and HttpMessageConverters to improve code clarity and maintainability.
This article explains the Spring MVC architecture, detailing the roles of DispatcherServlet, HandlerMapping, HandlerAdapter, Controller, ViewResolver, and View within the MVC pattern, while also providing a brief promotional note for IDE activation codes.
This article explains how to refactor a Spring MVC Controller layer by separating responsibilities, implementing a unified response structure, handling String response conversion, customizing validation with JSR‑303, and creating centralized exception handling to produce consistent API results.
This article explains the essential responsibilities of a Spring MVC controller, identifies common pitfalls such as duplicated validation and inconsistent responses, and demonstrates how to unify response structures, handle String conversion issues, apply JSR‑303 validation, create custom validators, and implement centralized exception handling using ResponseBodyAdvice and @RestControllerAdvice.
This tutorial shows how to build and run a Spring MVC application using an embedded Tomcat server with just a single Java class, covering Maven dependencies, Tomcat configuration, Servlet registration, Spring‑driven startup, and core Spring MVC component setup.
This article explains the concepts of Data Transfer Object (DTO), Business Object (BO), Persistent Object (PO), and Value Object (VO) in backend development, compares their roles, provides Java code examples, and discusses how to configure Spring MVC to filter null fields, while also including promotional content for IDE licenses.
This article presents a continuously updated collection of over 120 Spring Boot 3 practical examples, covering database initialization scripts, switching Redis clients, disabling and customizing security, configuring HTTP clients, and fine‑tuning Spring MVC behavior with code snippets and configuration details.
This article outlines a four‑step approach to refactor Spring MVC controllers by unifying response structures, centralizing response wrapping via ResponseBodyAdvice, implementing robust parameter validation with JSR‑303, and handling custom exceptions globally, resulting in cleaner, more maintainable backend code.
This article explains how to refactor the Spring MVC Controller layer by unifying response structures, using ResponseBodyAdvice for automatic wrapping, handling parameter validation with JSR‑303, and implementing custom exceptions with centralized exception handling to simplify and standardize API responses.
This article explains how to refactor the Spring MVC Controller layer by standardizing response structures, implementing unified response wrapping via ResponseBodyAdvice, handling String conversion issues, applying JSR‑303 parameter validation, creating custom validation rules, and defining custom exceptions with centralized exception handling to simplify controller code.
This article explains how to refactor Spring MVC controller layers by defining a unified response format, using ResponseBodyAdvice for automatic wrapping, handling String conversion issues, applying parameter validation with JSR‑303, creating custom validators, and implementing centralized exception handling to produce consistent API responses.
The article demonstrates how to refactor a large PHP API suite into a Java Spring MVC application by creating a generic AggregateController that, through model‑name mapping, reflection‑based repository registration and a thread‑safe MappingKit, provides CRUD endpoints for any table, collapsing hundreds of endpoints into just two controllers for client and admin.
This guide showcases nine distinct Spring Boot 3 API development techniques—from classic @RestController annotations to functional RouterFunction beans and custom Actuator endpoints—providing complete code samples, configuration details, and a promise of ongoing updates with a downloadable PDF of over 90 practical cases.
This article explores why Spring MVC automatically binds HTTP header values to controller method parameters, demonstrates the issue with a sample Spring Boot 3.4.0 project, analyzes the underlying HandlerMethodArgumentResolver and ServletModelAttributeMethodProcessor code, and provides two practical solutions to prevent unwanted header binding.
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.
Explore how Spring Boot 3 leverages the @ExceptionHandler annotation to centralize error handling, customize responses based on the Accept header, configure view beans for HTML errors, and utilize new Spring 6.2 attributes, with complete code examples and testing guidance.
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 provides a comprehensive tutorial on using the Super CSV library in Spring Boot 3, covering Maven dependencies, core APIs for reading and writing CSV files, cell processors, handling irregular data, and a complete Spring MVC controller example for CSV download, all illustrated with code snippets and screenshots.
This article explains why data desensitization is essential for modern enterprises, compares masking, obfuscation and encryption techniques, and provides step‑by‑step implementations for database, log, and output layers using MyBatis interceptors, Fastjson filters, and Spring MVC configuration.
This article compares Java web filters and Spring MVC interceptors, detailing their implementation differences, origins, execution order, supported project types, and typical use‑cases, helping developers choose the right tool for request handling, security, logging, and other cross‑cutting concerns.
The article explains how to encapsulate asynchronous notification signature verification in Spring MVC by creating a custom annotation and argument resolver, discusses why aspects and @RequestBody are unsuitable, and presents an alternative unified notification handling design using a service interface and dynamic implementation loading.
This article presents a case study of optimizing a multi‑tenant Java Spring MVC backend by applying domain‑driven design principles, the dependency inversion principle, and a factory pattern to decouple tenant‑specific logic, reduce service size, and improve maintainability and testability.
This article analyzes why Spring MVC fails to retrieve request header fields in multithreaded scenarios, explains the underlying ThreadLocal storage mechanism, critiques a common but flawed solution, and presents reliable approaches using CountDownLatch, manual RequestContextHolder propagation, and request caching to ensure header availability across threads.
The article advises Java backend developers to drop learning outdated technologies such as JSP, Struts, Hibernate, and certain legacy tools, emphasizing the importance of mastering core concepts like Servlets while focusing on modern frameworks like Spring MVC and lightweight ORMs like MyBatis.
This article demonstrates how to secure API interfaces by implementing symmetric encryption and decryption for both GET and POST requests in a Spring MVC application, using ControllerAdvice to intercept and process request and response bodies, handling key management, signature verification, and serialization issues across H5, Android, and iOS clients.
This article explains the purpose and usage of Spring MVC’s HandlerMethodArgumentResolver and HandlerMethodReturnValueHandler extension points, demonstrates how to implement custom argument resolvers and return‑value handlers, discusses common pitfalls such as handler ordering, and shows how to replace the default processors to achieve unified request and response processing.
This article provides a comprehensive overview of SpringBoot’s most commonly used annotations, covering MVC, bean, JPA, configuration, exception handling, and testing annotations, complete with clear explanations and practical code examples to help developers avoid pitfalls and write cleaner code.
This article explains the purpose, core methods, and practical implementation of Spring MVC’s RequestBodyAdvice and ResponseBodyAdvice extension points, including code examples for request decryption, signature verification, response encryption, unified result wrapping, and the underlying request‑processing flow within the framework.
The article explains how @ControllerAdvice, a specialization of @Component, enables global exception handling, data binding, and model attribute preprocessing in Spring MVC, demonstrates practical code examples for @ExceptionHandler, @InitBinder, and @ModelAttribute, and dives into the DispatcherServlet internals that make these features work.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean stereotypes, dependency‑injection and scope annotations, as well as Spring Boot conditional and lifecycle annotations, complete with code examples and usage tips for Java backend development.
This article explains why the Spring MVC @RequestBody annotation cannot be applied to multiple parameters in a single handler method, detailing the internal request‑body reading process, the resulting HttpMessageNotReadableException, and how to correctly handle multiple data parts using a single DTO.
This article reviews traditional Spring MVC controller definitions, introduces the new @HttpExchange annotation introduced in Spring 6 for declaring HTTP interfaces, demonstrates its usage with code examples, and shows how to generate client proxies for type‑safe HTTP calls.
This article details how ICBU's core communication pages were accelerated by applying HTTP chunked transfer, streaming HTML rendering, Nginx tweaks, ThreadLocal handling, and caching strategies, resulting in FCP dropping from 2.6 s to 1.9 s and LCP from 2.8 s to 2 s.
This article explains why Spring MVC cannot parse multiple @RequestBody annotations on a single handler method, analyzes the internal I/O stream closure that causes the failure, and provides a practical solution using a request‑body caching wrapper and a servlet filter to allow repeated reads of the request payload.
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 article explains Spring Web MVC.fn's functional programming model, covering HandlerFunction, immutable request/response contracts, parameter validation, routing predicates, nested routes, filters, and provides complete code examples for building functional endpoints in Spring Boot 2.7.
This tutorial walks through building custom Spring MVC core components—including a custom @PackEndpoint annotation, HandlerMapping, HandlerAdapter, and parameter resolver—complete with code examples and a test controller to demonstrate the full request handling flow.
This article explains the key changes when upgrading to Spring Boot 3, covering URL matching deprecation, HTTP header size configuration, removal of Apache HttpClient support, Actuator endpoint sanitization, and various property and dependency updates for a smooth migration.
This article provides a detailed overview of Spring MVC request‑mapping annotations, Spring Bean lifecycle and dependency‑injection annotations, as well as Spring Boot configuration annotations, illustrating each with explanations and code examples to help Java backend developers use these tools effectively.
This article walks through a real‑world scenario of adding symmetric encryption to Spring MVC endpoints for Android, iOS and H5 clients, detailing the requirements, code implementation of request and response interceptors, serialization pitfalls with enums and LocalDateTime, and the final solution using Jackson's ObjectMapper to keep encrypted and non‑encrypted responses consistent.
This tutorial walks through enabling Spring MVC, configuring type conversion, validation, interceptors, content negotiation, custom YAML message converters, view controllers, view resolvers, and static resource handling in a Spring Boot 2.7.12 application, complete with code examples and output screenshots.
The article outlines which Java technologies—such as JSP, Struts, Hibernate, Servlet, Applet, Swing, JDBC, and XML—are now largely obsolete or unnecessary to learn for modern backend development, offering criteria for judging relevance and recommending focus on current frameworks like Spring MVC and MyBatis.
This article explains the Spring MVC return‑value handling mechanism, demonstrates how to implement a custom HandlerMethodReturnValueHandler, register it correctly in a WebMvcConfigurer, and troubleshoot why the default processor may override custom handlers.
Custom Return Value HandlerHandlerMethodReturnValueHandlerJava
This tutorial explains how to extend Spring MVC's HandlerMapping by implementing a custom RequestCondition that matches requests based on an x-token header and a custom @AKF annotation, covering code implementation, configuration, testing, and the underlying request‑matching mechanism.
This article explains how to design a clean, maintainable Spring MVC controller layer by unifying response structures, applying centralized exception handling, and leveraging JSR‑303 validation with custom rules, illustrated with comprehensive code examples and best‑practice guidelines.
This article explains how to handle enum and JSON string parameters in Spring MVC by creating custom annotations and argument resolvers, demonstrates the implementation steps with full code examples, and also reviews Spring MVC's built‑in parameter binding mechanisms such as @RequestParam, @PathVariable, @RequestBody, and @ModelAttribute.
This article explains how to simplify Spring MVC interface calls by defining custom annotations, implementing a custom HandlerMapping, configuring it in Spring Boot 2.6.12, and demonstrating usage with example code, while also covering related handler adapters and underlying principles.
This guide walks through creating custom Spring MVC core components—including DispatcherServlet, HandlerMapping, HandlerAdapter, and ViewResolver—using annotations and Java code to gain full control over request handling, parameter resolution, and response rendering in backend development.
This guide explains how Spring MVC's @ControllerAdvice, @RestControllerAdvice, and @ExceptionHandler annotations enable both local and global exception handling, including selective handling by custom annotations, specific controllers, or packages, with practical code examples for Java developers.
This article provides a detailed overview of Spring MVC and Spring Boot annotations such as @RequestMapping, @GetMapping, @PostMapping, @RequestBody, @ControllerAdvice, @Component, @Bean, @Scope, @Autowired, and others, explaining their purposes, attributes, usage patterns, and offering practical code examples for each.
This article provides an in‑depth overview of the most frequently used Spring Boot annotations, categorizing them into Spring MVC, Spring Data JPA, Spring Security, and other essential annotations, and demonstrates their practical usage with concise examples.
This article explains how Spring MVC handles incoming requests by detailing each core component—from DispatcherServlet to ViewResolver—and demonstrates various controller definitions, including @RestController, HttpRequestHandler, custom Controller, and servlet-based approaches, with code examples and configuration tips.
This article explains why URL mappings that worked in Spring Boot 2.x break after upgrading to Spring Boot 3, demonstrates the issue with trailing slashes, and provides three practical solutions—including a filter, Nginx rule, and Spring Cloud Gateway optimization—to restore correct routing.
This article explains the responsibilities of the MVC controller layer, shows a typical Spring Boot controller implementation, and then demonstrates a series of refactorings—including delegating to the service layer, using validation annotations, standardizing response objects, and centralizing exception handling—to produce cleaner, more maintainable backend code.
This article explains the differences and proper usage of Java validation annotations such as @NotNull, @NotBlank, @NotEmpty, and compares @Valid with @Validated in Spring Boot applications, providing code examples and import details for effective data validation.
This article explains how to refactor a Spring MVC Controller layer by introducing a unified response format, leveraging ResponseBodyAdvice for automatic wrapping, applying JSR‑303 validation for request parameters, and centralizing exception handling to produce clean, maintainable backend code.
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 how Spring MVC handles exceptions, detailing the role of DispatcherServlet, the chain of HandlerExceptionResolver implementations, the controller invocation flow, and the internal mechanisms that resolve errors, including fallback to the default /error endpoint.
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 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 the MVC pattern, the role of the DAO layer, details Spring MVC’s request handling flow, introduces key annotations such as @RequestMapping, @RequestParam, @RequestBody, and @PathVariable, and describes how to implement and register interceptors and request filters for comprehensive request processing.
Explore how Spring Boot 2.6.14 automatically configures Spring MVC, including view resolvers, static resources, converters, message converters, JSON serialization, content negotiation, and error handling, and learn how to customize these features with WebMvcConfigurer, WebMvcRegistrations, and related beans for full control.
This article explains why and how to use asynchronous processing in Servlet 3.0 and Spring MVC, compares four implementation approaches (no return value, Callable, WebAsyncTask, DeferredResult), provides detailed code examples, and demonstrates a real‑world use case for decoupling long‑running tasks.
This article explains how Spring MVC processes exceptions using the DispatcherServlet and a configurable HandlerExceptionResolver chain, outlines the built‑in resolver implementations, shows how to customize error pages, and provides code examples for handling errors in both HTML and JSON responses.