Retrofit 2.0 come eliminare?

Question

Uso il retrofit 2.0 e sto implementando una funzione di eliminazione nella mia app per Android, tuttavia, non riesco a farlo correttamente, qualcuno può darmi un suggerimento?

Ho provato entrambi:

@DELETE("books/{id}") void deleteBook(@Path("id") int itemId); 

@DELETE("books/{id}") void deleteBook(@Path("id") int bookId, Callback<Response> callback); 

ottengo l'errore java.lang.IllegalArgumentException: metodi di servizio non possono tornare vuoto. per metodo LibraryService.deleteBook.

ho anche dato una prova su questo:

Response deleteBook(@Path("id") int bookId); 

Call<Response> deleteBook(@Path("id") int bookId);

non importa che uso okhttp3.Response o retrofit2.Response, mi metterò l'errore: '* .Response' è non è un tipo di corpo risposta valido. Intendevi ResponseBody?

Qualcuno può darmi un esempio di cancellazione riuscito? Ho cercato su Google online ma non riesco a trovare abbastanza informazioni. Molte grazie.

Answer 1

farlo in questo modo come avrete notato ultima:

Call<ResponseBody> deleteBook(@Path("id") int bookId); 

Assicurarsi si effettua la chiamata al largo della UI-thread tramite AsyncTask o qualche altro meccanismo threading. Non sono sicuro se hai già usato RxJava + Retrofit 2, ma è bello.

L'oggetto ResponseBody restituirà i risultati della chiamata. È ciò che utilizzo per alcune richieste API REST che non restituiscono un oggetto entità e tutto ciò a cui tengo è il codice di risposta.

Call<ResponseBody> deleteRequest = mService.deleteBook(123); 
deleteRequest.enqueue(new Callback<ResponseBody>() { 
    @Override 
    public void onResponse(Call<ResponseBody> call, Response<ResponseBody> response) { 
     // use response.code, response.headers, etc. 
    } 

    @Override 
    public void onFailure(Call<ResponseBody> call, Throwable t) { 
     // handle failure 
    } 
}); 

Oppure, Jake Wharton suggerisce

Use Void which not only has better semantics but is (slightly) more efficient in the empty case and vastly more efficient in a non-empty case (when you just don't care about body).

In modo da avere:

Call<Void> deleteBook(@Path("id") int bookId); 

Usage:

deleteRequest.enqueue(new Callback<Void>() { 
    @Override 
    public void onResponse(Call<Void> call, Response<Void> response) { 
     // use response.code, response.headers, etc. 
    } 

    @Override 
    public void onFailure(Call<Void> call, Throwable t) { 
     // handle failure 
    } 
}); 

Questo è meglio se tutto ciò che interessa è la risposta codice e nessun corpo alla risposta

MODIFICA 2: omettendo la corretta definizione di richiamata. Risolto :)