Retrofit 2.0 how to get deserialised error response.body

Advanced error handling techniques

In case of complex API responses, getting the full picture of the error body becomes an art. Here's where you can show off some advanced techniques.

Customized error response with specific error codes

In some scenarios, you might want to handle specific error codes differently, like a chameleon changing colors. Check your deserialized error object and play with the error attributes to channel each HTTP status code on its unique path:

if (apiError != null && apiError.getStatus() == HttpStatus.UNAUTHORIZED.value()) {
    // Blinking red lights!! You've been caught trespassing. Handle unauthorized error.
}


Tailored error handling classes

Design your own error handling classes, like MyErrorMessage, to let your structured error handling fashion shine. This approach doesn't just keep things organized but lets you reuse your parsing logic, like your favorite pair of jeans:

public class MyErrorMessage {
    // Tailored fields matching the API error code and message – Your style. Your rules. 
    private String message;
    private int code;

    // Parse the error response - Your secret code deciphering technique goes here
    public static MyErrorMessage parseError(ResponseBody errorBody) {
        // Your secret code deciphering technique goes here
    }

    // Getters for our fabulous error message and dazzling code
}


Retrofit's latest vogue in error handling

Starting from Retrofit 2.5.0, the error handling mechanisms had a makeover. So why not style it up a level? Utilize the responseConverter method to transform the errorBody right into a MyErrorMessage object:

// Get the latest, most fabulous Retrofit instance, loaded with GsonConverterFactory
Retrofit retrofit = getRetrofitInstance(); // Wink wink... Implement as you see fit ;)

// Let the magic begin! Convert the raw, error body into your exclusive 'MyErrorMessage' object
MyErrorMessage errorMessage = null;
if (!response.isSuccessful()) {
    Converter<ResponseBody, MyErrorMessage> converter =
            retrofit.responseBodyConverter(MyErrorMessage.class, new Annotation[0]);
    errorMessage = converter.convert(response.errorBody());
}


Mastering Retrofit error handling

Exploring best habits to manage error handling in Retrofit can feel like taming a wild beast. But these practices can save you time and help your API errors yield to your commands:

Eliminating empty errorBody challenges

Avoid the ghost town issue – calling errorBody only to find it vanished after the first call. Like catching a golden snitch, store the error string as soon as you get it:

String errorString = null;
if (response.errorBody() != null) {
    // Catch the golden snitch i.e., error string
    errorString = response.errorBody().string();
}
// Now use 'errorString' for all your quidditch matches (or just parsing, up to you!)


Syncing error handling for synchronous and asynchronous calls

Model your error handling methods for asynchronous and synchronous Retrofit calls like a skilled conductor managing a splendid symphony:

• In asynchronous calls, set the tune with the onResponse and onFailure callbacks:

call.enqueue(new Callback<MyApiResponse>() {
    @Override
    public void onResponse(Call<MyApiResponse> call, Response<MyApiResponse> response) {
        // Oops! The music went off-key. Handle false note (API error response).
    }

    @Override
    public void onFailure(Call<MyApiResponse> call, Throwable t) {
        // Oh no! There's a hole in the tuba (network error)! 
        if (t instanceof IOException) {
            // Quick! Tape and carry on playing (Handle network error).
        }
    }
});


• In synchronous calls, infuse some try-catch magic to handle the rhythm of error responses:

try {
    Response<MyApiResponse> response = call.execute();
    if (!response.isSuccessful()) {
        // Magicians only gathered false props. Handle API error response.
    }
} catch (IOException e) {
    // Rabbit refused to come out of the hat. Handle network error.
}


Converter: The universal error handling translator

Use a converter like GsonConverterFactory to create a universal translator for the API error responses. This nifty tool can easily convert the raw JSON data into a Java object that your application can graciously understand.

Always keep track of Retrofit's latest updates—you never know when a new shiny feature might come in handy. With Retrofit, your error handling skills are always evolving, so remain on top of the game!