Como lidar com o corpo de resposta vazio com o Retrofit 2?

Recentemente, comecei a usar o Retrofit 2 e enfrentei um problema ao analisar o corpo de resposta vazio. Eu tenho um servidor que responde apenas com código http sem nenhum conteúdo dentro do corpo da resposta.

Como posso lidar apenas com meta informações sobre a resposta do servidor (cabeçalhos, código de status etc.)?

Editar:

Como Jake Wharton aponta,

@GET("/path/to/get")
Call<Void> getMyData(/* your args here */);

é o melhor caminho a seguir em relação à minha resposta original -

Você pode simplesmente retornar a ResponseBody, que ignorará a análise da resposta.

@GET("/path/to/get")
Call<ResponseBody> getMyData(/* your args here */);

Então, na sua ligação,

Call<ResponseBody> dataCall = myApi.getMyData();
dataCall.enqueue(new Callback<ResponseBody>() {
    @Override
    public void onResponse(Response<ResponseBody> response) {
        // use response.code, response.headers, etc.
    }

    @Override
    public void onFailure(Throwable t) {
        // handle failure
    }
});

Se você usa o RxJava, é melhor usar Completableneste caso

Representa um cálculo adiado sem nenhum valor, mas apenas indicação para conclusão ou exceção. A classe segue um padrão de evento semelhante ao Reactive-Streams: onSubscribe (onError | onComplete)?

http://reactivex.io/RxJava/2.x/javadoc/io/reactivex/Completable.html

na resposta aceita:

@GET("/path/to/get")
Observable<Response<Void>> getMyData(/* your args here */);

Se o nó de extremidade retornar o código de resposta de falha, ele ainda estará no onNexte você precisará verificar o código de resposta.

No entanto, se você usar Completable.

@GET("/path/to/get")
Completable getMyData(/* your args here */);

você terá apenas onCompletee onError. se o código de resposta for bem-sucedido, ele disparará do onCompletecontrário onError.

Se você estiver usando o rxjava, use algo como:

@GET("/path/to/get")
Observable<Response<Void>> getMyData(/* your args here */);

Aqui está como eu o usei com Rx2 e Retrofit2, com solicitação PUT REST: Minha solicitação tinha um corpo json, mas apenas código de resposta http com corpo vazio.

O cliente Api:

public class ApiClient {
public static final String TAG = ApiClient.class.getSimpleName();


private DevicesEndpoint apiEndpointInterface;

public DevicesEndpoint getApiService() {


    Gson gson = new GsonBuilder()
            .setLenient()
            .create();


    OkHttpClient.Builder okHttpClientBuilder = new OkHttpClient.Builder();
    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
    logging.setLevel(HttpLoggingInterceptor.Level.BODY);
    okHttpClientBuilder.addInterceptor(logging);

    OkHttpClient okHttpClient = okHttpClientBuilder.build();

    apiEndpointInterface = new Retrofit.Builder()
            .baseUrl(ApiContract.DEVICES_REST_URL)
            .client(okHttpClient)
            .addConverterFactory(GsonConverterFactory.create(gson))
            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
            .build()
            .create(DevicesEndpoint.class);

    return apiEndpointInterface;

}

A interface:

public interface DevicesEndpoint {
 @Headers("Content-Type: application/json")
 @PUT(ApiContract.DEVICES_ENDPOINT)
 Observable<ResponseBody> sendDeviceDetails(@Body Device device);
}

Então, para usá-lo:

    private void sendDeviceId(Device device){

    ApiClient client = new ApiClient();
    DevicesEndpoint apiService = client.getApiService();
    Observable<ResponseBody> call = apiService.sendDeviceDetails(device);

    Log.i(TAG, "sendDeviceId: about to send device ID");
    call.subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()).subscribe(new Observer<ResponseBody>() {
        @Override
        public void onSubscribe(Disposable disposable) {
        }

        @Override
        public void onNext(ResponseBody body) {
            Log.i(TAG, "onNext");
        }

        @Override
        public void onError(Throwable t) {
            Log.e(TAG, "onError: ", t);

        }

        @Override
        public void onComplete() {
            Log.i(TAG, "onCompleted: sent device ID done");
        }
    });

}