Can we throw an exception in fallback or fallbackFactory of @FeignClient

Question

I'm use the @FeignClient and want to do some logic(like record the exception information) when Feign throw Exception and then reply the result to front end.

I noticed Feign will throw FeignException when connection fail or http status not expect.

So I defined a @ExceptionHandler to caught FeignException after the callback method was invoked.

    @ExceptionHandler(value = FeignException.class)
    @ResponseBody
    public ResponseResult feignException(FeignException exception){
        String message = exception.getMessage();
        byte[] content = exception.content();
        int status = exception.status();
        if(content!=null){
            String response=new String(content);
            message=String.format("%s response message : %s",message,response);
        }
        log.warn("{} : {} , cause by : {}",exception.getClass().getSimpleName(),message,exception.getCause());
        return ResponseResult.fail(HttpStatus.valueOf(status),String.format("9%s00",status),message);

But it can't caught when I set the callback or callbackFactory of @FeignClient.

    @FeignClient(url = "${onboardingcase.uri}",name = "OnBoardingCaseService",
            fallbackFactory = OnBoardingCaseServiceFallBack.class)


@Component
@Slf4j
public class OnBoardingCaseServiceFallBack implements FallbackFactory<OnBoardingCaseService> {

    @Override
    public OnBoardingCaseService create(Throwable throwable) {
        return new OnBoardingCaseService() {
            @Override
            public OnBoardingCaseVo query(String coid) {

                if(throwable instanceof FeignException){
                    throw (FeignException)throwable;
                }
                return null;
            }
        };
    }
}

I noticed because hystrix took over this method.And will catch exception in HystrixInvocationHandler.

try {
                                Object fallback = HystrixInvocationHandler.this.fallbackFactory.create(this.getExecutionException());
                                Object result = ((Method)HystrixInvocationHandler.this.fallbackMethodMap.get(method)).invoke(fallback, args);
                                if (HystrixInvocationHandler.this.isReturnsHystrixCommand(method)) {
                                    return ((HystrixCommand)result).execute();
                                } else if (HystrixInvocationHandler.this.isReturnsObservable(method)) {
                                    return ((Observable)result).toBlocking().first();
                                } else if (HystrixInvocationHandler.this.isReturnsSingle(method)) {
                                    return ((Single)result).toObservable().toBlocking().first();
                                } else if (HystrixInvocationHandler.this.isReturnsCompletable(method)) {
                                    ((Completable)result).await();
                                    return null;
                                } else {
                                    return HystrixInvocationHandler.this.isReturnsCompletableFuture(method) ? ((Future)result).get() : result;
                                }
                            } catch (IllegalAccessException var3) {
                                throw new AssertionError(var3);
                            } catch (ExecutionException | InvocationTargetException var4) {
                                throw new AssertionError(var4.getCause());
                            } catch (InterruptedException var5) {
                                Thread.currentThread().interrupt();
                                throw new AssertionError(var5.getCause());
                            }

So I want to know how can I throw an exception when I using callback / callbackFactory or there is another way to instead callbackFactory to do the "call back"?

Many Thanks

Answer 1

I found a solution to this problem.

public class OnBoardingCaseServiceFallBack implements FallbackFactory<OnBoardingCaseService> {

    @Override
    public OnBoardingCaseService create(Throwable throwable) {
        return new OnBoardingCaseService() {
            @Override
            public OnBoardingCaseVo query(String coid) {
                log.error("OnBoardingCaseService#query fallback , exception",throwable);
                if(throwable instanceof FeignException){
                    throw (FeignException)throwable;
                }

                return null;
            }
        };
    }
}

And then caught the HystrixRuntimeException and get the cause of exception in ExceptionHandler for get the realException that was wrapped by Hystrix.

    @ExceptionHandler(value = HystrixRuntimeException.class)
    @ResponseBody
    public ResponseResult hystrixRuntimeException(HystrixRuntimeException exception){
        Throwable fallbackException = exception.getFallbackException();
        Throwable assertError = fallbackException.getCause();
        Throwable realException = assertError.getCause();
        if(realException instanceof FeignException){
            FeignException feignException= (FeignException) realException;
            String message = feignException.getMessage();
            byte[] content = feignException.content();
            int status = feignException.status();
            if(content!=null){
                String response=new String(content);
                message=String.format("%s response message : %s",message,response);
            }
            return ResponseResult.fail(HttpStatus.valueOf(status),String.format("9%s00",status),message);
        }
        String message = exception.getMessage();
        log.warn("{} : {} , cause by : {}",exception.getClass().getSimpleName(),message,exception.getCause());
        return ResponseResult.fail(ResultCode.FAIL.httpStatus(),ResultCode.FAIL.code(),message);
    }

But I don't think that's a good way~

Answer 2

I have never done this in fallback, I have implemented custom error decoder(“CustomFeignErrorDecoder”) class and extended feign.codec.ErrorDecoder, every time an error occurs it comes to this class.

In decode function throw a custom exception and catch it in the controller or service layer to show your message to the frontend.

Example:

@Component
public class CustomFeignErrorDecoder implements ErrorDecoder {

   @Override
   public Exception decode(String methodKey, Response response) {
       throw new CustomFeignErrorDecoderException(methodKey +" response status "+ response.status() +" request "+ response.request()+ " method "+ response.request().httpMethod());
   }
}