如何使用 microprofile 记录内部错误

Question

Assume following code written with Quarkus. But can as well be with micronaut.

@POST
@Produces(MediaType.APPLICATION_JSON)
    @Consumes(MediaType.APPLICATION_JSON)
    @APIResponses(
            value = {
                    @APIResponse(
                            responseCode = "201",
                            description = "Customer Created"),
                    @APIResponse(
                            responseCode = "400",
                            description = "Customer already exists for customerId")
            }
    )
    public Response post(@Valid Customer customer) {
        final Customer saved = customerService.save(customer);
        return Response.status(Response.Status.CREATED).entity(saved).build();
    }

The Customer definition includes a field pictureUrl. CustomerService is responsible to validate the the URL is a valid URL and that the image really exists.

This means that following exception will be processed by the service: MalformedURLException and IOException. The CustomerService catches these errors and throws an application specific exception to report that the image does not exist or the path is not correct: ApplicationException.

How do you document this error case with microprofile?

My research suggests that I have to implement an exception mapper of the form:

public class ApplicationExceptionMapper implements ExceptionMapper<NotFoundException> {

    @Override
    @APIResponse(responseCode = "404", description = "Image not Found",
        content = @Content(
            schema = @Schema(implementation = Customer.class)
        )
    )
    public Response toResponse(NotFoundException t) {
        return Response.status(404, t.getMessage()).build();
    }

}

And once I have a such mapper, the framework would know how to convert my exception into Response. Is my analysis correct? What is the best practice?

Answer 1

You are more or less pointed in the right direction, your question can be divided in two, let me answer separately both:

1. How to document an error using microprofile openapi: Using the api responses and the operation description is the correct way as you are doing, you can include a extended description of your errors and the specific Http error code associated with each if you want. This annotations should be present in the Rest Resource not in the ExceptionMapper.
2. Handling custom errors with micro profile or just the Jax-RS way of dealing with exceptions: A endpoint implemented with Jax-RS Apis knows how to hande WebApplicationExceptions automatically, By launching a custom exception which has this one us parent, the Jax-RS implementation automatically will know how to map your Exception to a Response.
3. Dealing with Unexpected exceptions or customizing responses for certain exceptions: By implementing the interface ExceptionMapper, you can further customize the response generation for specific exceptions if you want but this is not generally required.

A common good strategy for dealing with the scenario you have explained is to have a family of custom exceptions that extend the WebApplicationException where you can specify the response code and message, Or just using the ones provided by jax-rs . And if you need further customization with i18n support or its important to provide a response entity with details associated to the error, then implement the ExceptionMapper.

Answer 2

For the actual error handling and conversion of exceptions to corresponding HTTP responses you would use the JaxRS exception mapper as you already started. But the exception mapper itself, is not considered at all during the creation of the OpenAPI schema, as the OpenAPI extension has no way of obtaining the information about the actual error responses produced by your exception mapper. So you need to declare the possible error cases on the actual endpoint methods -which can be a bit tedious, especially if your endpoint methods can result in multiple error responses (400, 500, 409..). But you can reduce the amount of duplicated code by creating a shared error response definitions.

A common pattern for error handling on API layer is to explicitly define the models for your error responses eg I want all my endpoints to return error responses in a form of json document that looks sth like this:

{
  "errorCode" : "MY_API_123",
  "errorDescription" : "This operation is not allowed"
  //anything else, details, links etc
}

So I create a POJO model for the response:

@Data
@AllArgsConstructor
public class ErrorResponse {
   private String errorCode;
   private String errorDescription;
}

And in my exception mapper I can convert my exception to the error response above:

public Response toResponse(Exception e) {
  // you can define a mapper for a more general type of exception and then create specific error responses based on actual type, or you could define your own application level exception with custom error info, keys, maybe even i18n, that you catch here, you get the idea
  if (e instanceOf NotFoundException) {
     return Response.status(404,  new ErrorResponse("MY_API_400", "Object not found")).build();
  }
  if (e instanceOf IllegalArgumentException) {
    return Response.status(400, new ErrorResponse("MY_API_400", "Invalid request")).build();
  }
  
  // fallback if we dont have any better error info
  return Response.status(500,  new ErrorResponse("MY_API_100", "Internal server error")).build();
}

You can then document the possible error responses using the OpenAPi annotations:

@APIResponses({
  @APIResponse(responseCode = "201", description = "Customer Created"),
  @APIResponse(responseCode = "400", description = "Other object exists for customerId", content = @Content(schema = @Schema(implementation = ErrorResponse.class))),
  @APIResponse(responseCode = "500", description = "Internal error", content = @Content(schema = @Schema(implementation = ErrorResponse.class)))
})
public Response yourMethod()

Or if you have some responses that are repeated often (such as generic internal server error, unathorized/unathenticated) you can document them on your class extending JaxRS Application and then reference them in your endpoints like this:

@Authenticated
@APIResponses({
   @APIResponse(responseCode = "200", description = "Ok"),
   @APIResponse(responseCode = "401", ref = "#/components/responses/Unauthorized"),
   @APIResponse(responseCode = "500", ref = "#/components/responses/ServerError")
})
public Response someAPIMethod() {

Example JaxRS application class(useful for other common top level openapi schema attributes)

@OpenAPIDefinition(
   info = @Info(title = "My cool API", version = "1.0.0"),
   components = @Components(
       schemas = {@Schema(name = "ErrorResponse", implementation = ErrorResponse.class)},
       responses = {
          @APIResponse(name = "ServerError", description = "Server side error", content = @Content(mediaType = MediaType.APPLICATION_JSON, schema = @Schema(ref = "#/components/schemas/ErrorResponse")), responseCode = "500"),
          @APIResponse(name = "NotFound", description = "Requested object not found", content = @Content(schema = @Schema(ref = "#/components/schemas/ErrorResponse")), responseCode = "404"),
          @APIResponse(name = "Forbidden", description = "Authorization error", responseCode = "403"),
          @APIResponse(name = "BadRequest", description = "Bad Request", responseCode = "400"),
          @APIResponse(name = "Unauthorized", description = "Authorization error", responseCode = "401")})
)
public class RESTApplication extends Application {

}