How to handle different type of Exception in Spring Integration using java DSL? - spring-boot

Question

I have following simple proxy integration flow. The main task of which is to take request from the proxy send it to the actual endpoint, get the respond and send it back to the client. I would like to handle different type of exceptions.
#SpringBootApplication
#EnableIntegration
public class IntegrationApp {
#Value("${narko.pin}")
private String pinUrl;
public static void main(String[] args) {
SpringApplication.run(MinzdravApplication.class, args);
}
#Bean
public DirectChannel requestPinChannel() {
return new DirectChannel();
}
#Bean
public DirectChannel replyPinChannel() {
return new DirectChannel();
}
#Bean
public IntegrationFlow httpProxyFlowPin() throws Exception {
return IntegrationFlows
.from(Http.inboundGateway("/narko/api/patient/by-pinpp")
.requestChannel(requestPinChannel())
.mappedRequestHeaders("activityid")
.errorChannel("httpProxyErrorFlow.input")
)
.wireTap(sf->sf.handle(new InwardMessageHandler()))
.enrichHeaders(h -> h.header("Content-Type", "application/json"))
.handle(Http.outboundGateway(pinUrl).charset("utf-8")
.expectedResponseType(String.class))
.get();
}
#Bean
public IntegrationFlow httpProxyErrorFlow() {
return f -> f
.transform(Throwable::getCause)
.<RuntimeException>handle(
(p, h) ->
MessageBuilder.fromMessage(new Message<ErrorDto>() {
final Map<String, Object> headers=new HashMap<>();
#Override
public ErrorDto getPayload() {
if(p instanceof JSONException){
headers.put(HttpHeaders.STATUS_CODE,HttpStatus.BAD_REQUEST);
return new ErrorDto(HttpStatus.BAD_REQUEST.value(),p.getMessage());
}else if(p instanceof MethodNotAllowedException){
headers.put(HttpHeaders.STATUS_CODE,HttpStatus.METHOD_NOT_ALLOWED);
return new ErrorDto(HttpStatus.METHOD_NOT_ALLOWED.value(),p.getMessage());
}
else{
headers.put(HttpHeaders.STATUS_CODE,HttpStatus.INTERNAL_SERVER_ERROR);
return new ErrorDto(HttpStatus.INTERNAL_SERVER_ERROR.value(),p.getMessage());
}
}
#Override
public MessageHeaders getHeaders() {
return new MessageHeaders(headers);
}
})
).transform(Transformers.toJson())
;
}
As you can see the code above I have to check every possible exception type, then form corresponding ErrorDto, which makes the code difficult to maintain. Is it possible to handle them as one can do it with #ControllerAdvice? For instance :
#ControllerAdvice
public class ApiExceptionHandler {
#ExceptionHandler(JSONException.class)
#ResponseStatus(HttpStatus.BAD_REQUEST)
public ResponseEntity<ApiError> onRuntimeException(JSONException ex) {
ErrorDto apiError = new ErrorDto(HttpStatus.BAD_REQUEST, ex.getMessage(), ex);
return buildResponseEntity(apiError);
}
#ExceptionHandler(MethodNotAllowedException.class)
#ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED)
public ResponseEntity<ApiError> onIllegalException(MethodNotAllowedException ex) {
ErrorDto apiError = new ErrorDto(HttpStatus.METHOD_NOT_ALLOWED, ex.getMessage(), ex);
return buildResponseEntity(apiError);
}
...
}

Answer 1

Sure! You can do something similar with Spring Integration. See an ErrorMessageExceptionTypeRouter and its Java DSL routeByException():
/**
* Populate the {#link ErrorMessageExceptionTypeRouter} with options from the {#link RouterSpec}.
* Typically, used with a Lambda expression:
* <pre class="code">
* {#code
* .routeByException(r -> r
* .channelMapping(IllegalArgumentException.class, "illegalArgumentChannel")
* .subFlowMapping(MessageHandlingException.class, sf ->
* sf.handle(...))
* )
* }
* </pre>
* #param routerConfigurer the {#link Consumer} to provide {#link ErrorMessageExceptionTypeRouter} options.
* #return the current {#link BaseIntegrationFlowDefinition}.
* #see ErrorMessageExceptionTypeRouter
*/
public B routeByException(
Consumer<RouterSpec<Class<? extends Throwable>, ErrorMessageExceptionTypeRouter>> routerConfigurer) {
https://docs.spring.io/spring-integration/docs/current/reference/html/message-routing.html#router-implementations-exception-router
You also can just throw those exceptions back to the proxy and have that #ControllerAdvice for handling them on the MVC level.