Support http request and response injection in @ExceptionHandler methods for reactive stack

Author: aureamunoz

docs/src/main/asciidoc/spring-web.adoc

@@ -469,6 +469,46 @@ The following parameter types are supported, in arbitrary order:
 
 Other parameter types mentioned in the Spring `https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/bind/annotation/ExceptionHandler.html[ExceptionHandler javadoc]` are not supported.
 
+==== Using `HttpServerRequest` and `HttpServerResponse` in Spring Web-style exception handlers
+
+When using the Quarkus Spring Web compatibility layer on top of the reactive stack (`quarkus-rest-jackson`),
+you cannot inject servlet-based request and response types such as `jakarta.servlet.http.HttpServletRequest` or `jakarta.servlet.http.HttpServletResponse`.
+These types are only available when using the Classic RESTEasy stack (quarkus-resteasy / quarkus-resteasy-jackson), which relies on the Servlet API provided by `quarkus-undertow` dependency.
+
+To provide a Spring-friendly experience while staying reactive, Quarkus allows you to inject the following types into your `@ExceptionHandler` methods:
+
+- io.vertx.core.http.HttpServerRequest
+
+- io.vertx.core.http.HttpServerResponse
+
+These types give you direct access to the underlying Vert.x HTTP layer.
+This allows you to manipulate the response (e.g. set headers, cookies, or status codes) or enrich the returned information using details from the request.
+
+For example:
+
+[source, java]
+----
+@ExceptionHandler(IllegalArgumentException.class)
+public ResponseEntity<Object> handleException(Exception ex,
+                                                       HttpServerRequest request,
+                                                       HttpServerResponse response) {
+    // Add a custom header to the response
+    response.putHeader("X-Error-Reason", "IllegalArgument");
+
+    // Build a response body enriched with request details
+    String body = String.format("Request %s %s failed",
+            request.method().name(),
+            request.uri());
+
+    return new ResponseEntity<>(body, HttpStatus.BAD_REQUEST);
+}
+
+----
+
+**Warning:** This is potentially dangerous.
+Users should only do this if they understand the reactive model, and are aware that writing directly to the response can bypass normal handling of status codes, headers, and serialization.
+
+
 == Important Technical Note
 
 Please note that the Spring support in Quarkus does not start a Spring Application Context nor are any Spring infrastructure classes run.

extensions/spring-web/core/deployment/src/main/java/io/quarkus/spring/web/deployment/ControllerAdviceExceptionMapperGenerator.java

@@ -32,6 +32,8 @@
 import io.quarkus.gizmo.MethodDescriptor;
 import io.quarkus.gizmo.ResultHandle;
 import io.quarkus.spring.web.runtime.common.ResponseEntityConverter;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
 
 class ControllerAdviceExceptionMapperGenerator extends AbstractExceptionMapperGenerator {
 
@@ -250,6 +252,16 @@ private ResultHandle invokeExceptionHandlerMethod(MethodCreator toResponse) {
                     parameterTypeHandles[i] = getBeanFromArc(toResponse, UriInfo.class.getName());
                 } else if (typesUtil.isAssignable(Request.class, parameterType.name())) {
                     parameterTypeHandles[i] = getBeanFromArc(toResponse, Request.class.getName());
+                } else if (typesUtil.isAssignable(HttpServerRequest.class, parameterType.name())) {
+                    parameterTypeHandles[i] = getBeanFromArc(toResponse, HttpServerRequest.class.getName());
+                } else if (typesUtil.isAssignable(HttpServerResponse.class, parameterType.name())) {
+                    ResultHandle requestHandle = getBeanFromArc(toResponse, HttpServerRequest.class.getName());
+                    ResultHandle responseHandle = toResponse.invokeInterfaceMethod(
+                            MethodDescriptor.ofMethod(HttpServerRequest.class,
+                                    "response",
+                                    HttpServerResponse.class),
+                            requestHandle);
+                    parameterTypeHandles[i] = responseHandle;
                 } else {
                     throw new IllegalArgumentException(
                             "Parameter type '" + parameterType.name() + "' is not supported for method '"

extensions/spring-web/resteasy-classic/tests/src/test/java/io/quarkus/spring/web/resteasy/classic/test/ResponseStatusAndExceptionHandlerTest.java

@@ -3,6 +3,7 @@
 import static io.restassured.RestAssured.when;
 
 import jakarta.servlet.http.HttpServletRequest;
+import jakarta.servlet.http.HttpServletResponse;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -29,6 +30,11 @@ public void testRootResource() {
         when().get("/exception").then().statusCode(400);
     }
 
+    @Test
+    public void testIllegalResource() {
+        when().get("/exception/illegalArgument").then().statusCode(500);
+    }
+
     @RestController
     @RequestMapping("/exception")
     public static class ExceptionController {
@@ -40,6 +46,14 @@ public String throwException() {
             exception.setStackTrace(new StackTraceElement[0]);
             throw exception;
         }
+
+        @GetMapping("/illegalArgument")
+        @ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR)
+        public String throwIllegalException() {
+            IllegalArgumentException exception = new IllegalArgumentException();
+            exception.setStackTrace(new StackTraceElement[0]);
+            throw exception;
+        }
     }
 
     @RestControllerAdvice
@@ -50,9 +64,11 @@ public ResponseEntity<Object> handleException(Exception ex) {
             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         }
 
-        @ExceptionHandler(RuntimeException.class)
-        public ResponseEntity<Object> forbidden(Exception ex, HttpServletRequest request) {
-            return new ResponseEntity<>(HttpStatus.FORBIDDEN);
+        @ExceptionHandler(IllegalArgumentException.class)
+        public ResponseEntity<Object> handleException(Exception ex, HttpServletRequest request, HttpServletResponse response) {
+            response.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
+            request.setAttribute("javax.servlet.error.status_code", HttpStatus.INTERNAL_SERVER_ERROR.value());
+            return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
 }

extensions/spring-web/resteasy-reactive/tests/src/test/java/io/quarkus/spring/web/resteasy/reactive/test/ResponseStatusAndExceptionHandlerTest.java

@@ -1,6 +1,8 @@
 package io.quarkus.spring.web.resteasy.reactive.test;
 
 import static io.restassured.RestAssured.when;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.is;
 
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
@@ -13,6 +15,8 @@
 import org.springframework.web.bind.annotation.RestControllerAdvice;
 
 import io.quarkus.test.QuarkusUnitTest;
+import io.vertx.core.http.HttpServerRequest;
+import io.vertx.core.http.HttpServerResponse;
 
 public class ResponseStatusAndExceptionHandlerTest {
 
@@ -31,6 +35,12 @@ public void testResponseStatusOnException() {
         when().get("/exception2").then().statusCode(202);
     }
 
+    @Test
+    public void testExceptionHandlingWithHttpRequest() {
+        when().get("/exception3").then().statusCode(400)
+                .body(containsString("Request GET /exception3 failed")).header("X-Error-Reason", is("IllegalArgument"));
+    }
+
     @RestController
     public static class ExceptionController {
 
@@ -50,6 +60,13 @@ public String throwMyException() {
             myException.setStackTrace(EMPTY_STACK_TRACE);
             throw myException;
         }
+
+        @GetMapping("/exception3")
+        public String throwIllegalArgumentException() {
+            IllegalArgumentException illegalArgumentException = new IllegalArgumentException();
+            illegalArgumentException.setStackTrace(EMPTY_STACK_TRACE);
+            throw illegalArgumentException;
+        }
     }
 
     @RestControllerAdvice
@@ -59,6 +76,16 @@ public static class RestExceptionHandler {
         public ResponseEntity<Object> handleException(Exception ex) {
             return new ResponseEntity<>(HttpStatus.BAD_REQUEST);
         }
+
+        @ExceptionHandler(IllegalArgumentException.class)
+        public ResponseEntity<Object> handleBadRequestException(Exception ex, HttpServerRequest request,
+                HttpServerResponse response) {
+            String body = String.format(
+                    "Request %s %s failed",
+                    request.method().name(), request.uri());
+            response.putHeader("X-Error-Reason", "IllegalArgument");
+            return new ResponseEntity<>(body, HttpStatus.BAD_REQUEST);
+        }
     }
 
     @ResponseStatus(HttpStatus.ACCEPTED)