Comment enregistrer la demande et le corps de réponse avec Retrofit-Android?

Adaptation 2.0 :

Mise à jour: @ par Marcus Pöhls

La Journalisation Pour Le Rétrofit 2

Retrofit 2 repose entièrement sur OkHttp pour toute opération de réseau. Puisque OkHttp est une dépendance homologue de Retrofit 2, vous n'aurez pas besoin d'ajouter une dépendance supplémentaire une fois Retrofit 2 publié en tant que version stable.

OkHttp 2.6.0 est livré avec un intercepteur de journalisation en tant que dépendance interne et vous pouvez l'utiliser directement pour votre client de modification. Rénovation 2.0.0-beta2 utilise toujours OkHttp 2.5.0. Les versions futures vont augmenter la dépendance aux versions OkHttp supérieures. C'est pourquoi vous devez importer manuellement l'intercepteur de journalisation. Ajoutez la ligne suivante à vos importations gradle dans votre build.fichier gradle pour récupérer la dépendance de l'intercepteur de journalisation.

compile 'com.squareup.okhttp3:logging-interceptor:3.9.0'

Vous pouvez également visiter la page Github de Square à propos de cet intercepteur

Ajouter de la Journalisation pour la Rénovation 2

Lors du développement de votre application et à des fins de débogage, c'est agréable d'avoir une fonctionnalité de journal intégrée pour afficher les informations de demande et de réponse. Puisque la journalisation n'est plus intégrée par défaut dans Retrofit 2, nous devons ajouter un intercepteur de journalisation pour OkHttp. Heureusement OkHttp est déjà livré avec cet intercepteur et vous avez seulement besoin de l'activer pour votre OkHttpClient.

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();  
// set your desired log level
logging.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient.Builder httpClient = new OkHttpClient.Builder();   
// add your other interceptors …
// add logging as last interceptor
httpClient.addInterceptor(logging);  // <-- this is the important line!
Retrofit retrofit = new Retrofit.Builder()  
.baseUrl(API_BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
.client(httpClient.build())
.build();

Nous vous recommandons d'ajouter la journalisation en tant que dernier intercepteur, car cela enregistrera également les informations que vous avez ajoutées avec les intercepteurs précédents à votre requête.

Journal Niveaux

La journalisation trop d'informations va exploser votre moniteur Android, c'est pourquoi l'intercepteur de journalisation D'OkHttp a quatre niveaux de journal: aucun, BASIC, HEADERS, BODY. Nous allons vous guider à travers chacun des niveaux de journal et de décrire leur sortie.

Pour plus d'informations, veuillez visiter: Retrofit 2-Log demandes et réponses

ANCIENNE RÉPONSE:

Plus de connexion dans Retrofit 2. L'équipe de développement a supprimé la fonctionnalité de journalisation. Pour être honnête, l' la fonctionnalité de journalisation n'était pas si fiable de toute façon. Jake Wharton a explicitement déclaré que les messages ou les objets enregistrés sont les valeurs supposées et qu'ils ne pouvaient pas être prouvés comme vrais. La requête réelle qui arrive sur le serveur peut avoir un corps de requête modifié ou autre chose.

Même s'il n'y a pas de journalisation intégrée par défaut, vous pouvez utiliser N'importe quel enregistreur Java et l'utiliser dans un intercepteur OkHttp personnalisé.

Pour plus d'informations sur Retrofit 2, veuillez consulter : Retrofit-mise en route et créer un client Android

Mise à Jour de Rénovation 2.0.0-beta3

Maintenant, vous devez utiliser okhttp3 avec builder. Aussi l'ancien intercepteur ne fonctionnera pas. Cette réponse est adaptée pour Android.

Voici un copier-coller rapide pour vous avec les nouvelles choses.

1. Modifiez votre fichier gradle à

  compile 'com.squareup.retrofit2:retrofit:2.0.0-beta3'
  compile "com.squareup.retrofit2:converter-gson:2.0.0-beta3"
  compile "com.squareup.retrofit2:adapter-rxjava:2.0.0-beta3"
  compile 'com.squareup.okhttp3:logging-interceptor:3.0.1'

2. Vérifiez cet exemple de code:

, Avec les nouvelles importations. Vous pouvez supprimer Rx si vous ne l'utilisez pas, supprimez également ce que vous ne faites pas utiliser.

import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import retrofit2.GsonConverterFactory;
import retrofit2.Retrofit;
import retrofit2.RxJavaCallAdapterFactory;
import retrofit2.http.GET;
import retrofit2.http.Query;
import rx.Observable;

public interface APIService {

  String ENDPOINT = "http://api.openweathermap.org";
  String API_KEY = "2de143494c0b2xxxx0e0";

  @GET("/data/2.5/weather?appid=" + API_KEY) Observable<WeatherPojo> getWeatherForLatLon(@Query("lat") double lat, @Query("lng") double lng, @Query("units") String units);


  class Factory {

    public static APIService create(Context context) {

      OkHttpClient.Builder builder = new OkHttpClient().newBuilder();
      builder.readTimeout(10, TimeUnit.SECONDS);
      builder.connectTimeout(5, TimeUnit.SECONDS);

      if (BuildConfig.DEBUG) {
        HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
        builder.addInterceptor(interceptor);
      }

      //Extra Headers

      //builder.addNetworkInterceptor().add(chain -> {
      //  Request request = chain.request().newBuilder().addHeader("Authorization", authToken).build();
      //  return chain.proceed(request);
      //});

      builder.addInterceptor(new UnauthorisedInterceptor(context));
      OkHttpClient client = builder.build();

      Retrofit retrofit =
          new Retrofit.Builder().baseUrl(APIService.ENDPOINT).client(client).addConverterFactory(GsonConverterFactory.create()).addCallAdapterFactory(RxJavaCallAdapterFactory.create()).build();

      return retrofit.create(APIService.class);
    }
  }
}

Bonus

Je sais que c'est offtopic mais je trouve ça cool.

Dans le cas où il y a un code d'erreur http de unauthorized , Voici un intercepteur. J'utilise eventbus pour transmettre l'événement.

import android.content.Context;
import android.os.Handler;
import android.os.Looper;
import com.androidadvance.ultimateandroidtemplaterx.BaseApplication;
import com.androidadvance.ultimateandroidtemplaterx.events.AuthenticationErrorEvent;

import de.greenrobot.event.EventBus;
import java.io.IOException;
import javax.inject.Inject;
import okhttp3.Interceptor;
import okhttp3.Response;

public class UnauthorisedInterceptor implements Interceptor {

  @Inject EventBus eventBus;

  public UnauthorisedInterceptor(Context context) {
    BaseApplication.get(context).getApplicationComponent().inject(this);
  }

  @Override public Response intercept(Chain chain) throws IOException {
    Response response = chain.proceed(chain.request());
    if (response.code() == 401) {
      new Handler(Looper.getMainLooper()).post(() -> eventBus.post(new AuthenticationErrorEvent()));
    }
    return response;
  }
}

Code pris à partir de https://github.com/AndreiD/UltimateAndroidTemplateRx (mon projet).

Il ne semble pas y avoir de moyen de faire basic + body , mais vous pouvez utiliser FULL et filtrer les en-têtes que vous ne voulez pas.

RestAdapter adapter = new RestAdapter.Builder()
                          .setEndpoint(syncServer)
                          .setErrorHandler(err)
                          .setConverter(new GsonConverter(gson))
                          .setLogLevel(logLevel)
                          .setLog(new RestAdapter.Log() {
                              @Override
                              public void log(String msg) {
                                  String[] blacklist = {"Access-Control", "Cache-Control", "Connection", "Content-Type", "Keep-Alive", "Pragma", "Server", "Vary", "X-Powered-By"};
                                  for (String bString : blacklist) {
                                      if (msg.startsWith(bString)) {
                                          return;
                                      }
                                  }
                                  Log.d("Retrofit", msg);
                              }
                          }).build();

Il semble que lorsque vous remplacez le journal, le corps est préfixé avec une balise similaire à

[ 02-25 10:42:30.317 25645:26335 D/Retrofit ]

Il devrait donc être facile de se connecter basic + body en ajustant le filtre personnalisé. J'utilise une liste noire, mais une liste blanche pourrait également être utilisée en fonction de vos besoins.

Le code ci-dessous fonctionne à la fois avec l'en-tête et sans en-tête pour imprimer la demande et la réponse du journal. Remarque: Il suffit de commenter .addHeader () ligne si ne sont pas en utilisant l'en-tête.

HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
        interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(interceptor)
                //.addInterceptor(REWRITE_CACHE_CONTROL_INTERCEPTOR)
                .addNetworkInterceptor(new Interceptor() {

                    @Override

                    public okhttp3.Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder()
                                // .addHeader(Constant.Header, authToken)
                                   .build();
                        return chain.proceed(request);
                    }
                }).build();

        final Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Constant.baseUrl)
                .client(client) // This line is important
                .addConverterFactory(GsonConverterFactory.create())
                .build();

Si vous utilisez Retrofit2 et okhttp3, vous devez savoir que Interceptor fonctionne par file d'attente. Ajoutez donc loggingInterceptor à la fin, après vos autres intercepteurs:

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        if (BuildConfig.DEBUG)
            loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.HEADERS);

 new OkHttpClient.Builder()
                .connectTimeout(60, TimeUnit.SECONDS)
                .readTimeout(60, TimeUnit.SECONDS)
                .writeTimeout(60, TimeUnit.SECONDS)
                .addInterceptor(new CatalogInterceptor(context))
                .addInterceptor(new OAuthInterceptor(context))
                .authenticator(new BearerTokenAuthenticator(context))
                .addInterceptor(loggingInterceptor)//at the end
                .build();

Pour android studio avant 3.0 (à l'aide d'android motinor)
https://futurestud.io/tutorials/retrofit-2-log-requests-and-responses
https://www.youtube.com/watch?v=vazLpzE5y9M

Et pour Android studio à partir de 3.0 et au-dessus (en utilisant Android profiler comme Moniteur android est remplacé par android profiler)
https://futurestud.io/tutorials/retrofit-2-analyze-network-traffic-with-android-studio-profiler