L'enregistrement à l'aide de Rénovation 2

En Rénovation 2, vous devriez utiliser HttpLoggingInterceptor.

Ajouter la dépendance à build.gradle:

implementation 'com.squareup.okhttp3:logging-interceptor:3.12.1'

Créer un Retrofit objet comme suit:

HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient client = new OkHttpClient.Builder().addInterceptor(interceptor).build();

Retrofit retrofit = new Retrofit.Builder()
        .baseUrl("https://backend.example.com")
        .client(client)
        .addConverterFactory(GsonConverterFactory.create())
        .build();

return retrofit.create(ApiClient.class);

La solution ci-dessus vous donne logcat messages très similaire à l'ancienne celles prévues par

setLogLevel(RestAdapter.LogLevel.FULL)

En cas de java.lang.ClassNotFoundException:

Âgés de Rénovation version peut nécessiter une ancienne logging-interceptor version. Regardez les commentaires des sections pour plus de détails.

Voici un Interceptor qui enregistre à la fois la demande et la réponse des organismes (à l'aide de Bois, basé sur un exemple de la OkHttp docs et des réponses):

public class TimberLoggingInterceptor implements Interceptor {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.nanoTime();
Timber.i("Sending request %s on %s%n%s", request.url(), chain.connection(), request.headers());
Timber.v("REQUEST BODY BEGIN\n%s\nREQUEST BODY END", bodyToString(request));
Response response = chain.proceed(request);
ResponseBody responseBody = response.body();
String responseBodyString = response.body().string();
//now we have extracted the response body but in the process
//we have consumed the original reponse and can't read it again
//so we need to build a new one to return from this method
Response newResponse = response.newBuilder().body(ResponseBody.create(responseBody.contentType(), responseBodyString.getBytes())).build();
long t2 = System.nanoTime();
Timber.i("Received response for %s in %.1fms%n%s", response.request().url(), (t2 - t1) / 1e6d, response.headers());
Timber.v("RESPONSE BODY BEGIN:\n%s\nRESPONSE BODY END", responseBodyString);
return newResponse;
}
private static String bodyToString(final Request request){
try {
final Request copy = request.newBuilder().build();
final Buffer buffer = new Buffer();
copy.body().writeTo(buffer);
return buffer.readUtf8();
} catch (final IOException e) {
return "did not work";
}
}
}

Je ne sais pas si setLogLevel() sera de retour dans la finale de la version 2.0 de Rénovation mais pour l'instant, vous pouvez utiliser un intercepteur pour la journalisation.

Un bon exemple on peut trouver dans OkHttp wiki: https://github.com/square/okhttp/wiki/Interceptors

OkHttpClient client = new OkHttpClient();
client.interceptors().add(new LoggingInterceptor());
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("http://www.yourjsonapi.com")
.addConverterFactory(GsonConverterFactory.create())
.client(client)
.build();

Le principal problème auquel j'ai été confronté a été dynamique en ajoutant des en-têtes et la journalisation en debug logcat. J'ai essayé d'ajouter deux intercepteurs. L'un pour l'enregistrement et l'autre pour ajouter des en-têtes sur-le-aller (jeton d'autorisation). Le problème était que nous pouvons .addInterceptor ou .addNetworkInterceptor. Comme Jake Wharton m'a dit: "Réseau d'intercepteurs de viennent toujours après l'application d'intercepteurs. Voir https://github.com/square/okhttp/wiki/Interceptors". Donc, ici, est exemple de travail avec les en-têtes et les journaux:

OkHttpClient httpClient = new OkHttpClient.Builder()
//here we can add Interceptor for dynamical adding headers
.addNetworkInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request().newBuilder().addHeader("test", "test").build();
return chain.proceed(request);
}
})
//here we adding Interceptor for full level logging
.addNetworkInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
.build();
Retrofit retrofit = new Retrofit.Builder()
.addConverterFactory(GsonConverterFactory.create(gsonBuilder.create()))
.addCallAdapterFactory(RxJavaCallAdapterFactory.create())
.client(httpClient)
.baseUrl(AppConstants.SERVER_ADDRESS)
.build();

Vous pouvez également ajouter Facebook du Stetho et regarder le réseau des traces dans google Chrome:
http://facebook.github.io/stetho/

final OkHttpClient.Builder builder = new OkHttpClient.Builder();
if (BuildConfig.DEBUG) {
builder.networkInterceptors().add(new StethoInterceptor());
}

Puis ouvrez "chrome://inspecter" dans Chrome...

cela va créer une rénovation de l'objet avec l'exploitation forestière. sans la création d'objets distincts.

 private static final Retrofit retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.client(new OkHttpClient().newBuilder()
.addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY))
.readTimeout(READ_TIMEOUT_SECONDS, TimeUnit.SECONDS)
.writeTimeout(WRITE_TIMEOUT_SECONDS, TimeUnit.SECONDS)
.connectTimeout(CONNECTION_TIMEOUT_SECONDS, TimeUnit.SECONDS)
.build())
.addConverterFactory(GsonConverterFactory.create())
.build();

Plus de la réponse, qui couvre près de tout, sauf de cet outil, l'un des plus cool des façons de voir le journal.

Il est Facebook est Stetho. C'est un superbe outil pour surveiller/journal de votre application à un réseau de trafic sur google chrome. Vous pouvez également trouver ici sur Github.

Je l'ai trouvé moyen, pour l'Impression de Journaux en Rénovation

OkHttpClient okHttpClient = new OkHttpClient.Builder()
.addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
if (BuildConfig.DEBUG) {
Log.e(getClass().getName(), request.method() + " " + request.url());
Log.e(getClass().getName(), "" + request.header("Cookie"));
RequestBody rb = request.body();
Buffer buffer = new Buffer();
if (rb != null)
rb.writeTo(buffer);
LogUtils.LOGE(getClass().getName(), "Payload- " + buffer.readUtf8());
}
return chain.proceed(request);
}
})
.readTimeout(60, TimeUnit.SECONDS)
.connectTimeout(60, TimeUnit.SECONDS)
.build();
iServices = new Retrofit.Builder()
.baseUrl("Your Base URL")
.client(okHttpClient)
.addConverterFactory(GsonConverterFactory.create())
.build()
.create(Your Service Interface .class);

Fonctionne pour moi.

hé les gars，j'ai déjà trouver solution:

  public static <T> T createApi(Context context, Class<T> clazz, String host, boolean debug) {
if (singleton == null) {
synchronized (RetrofitUtils.class) {
if (singleton == null) {
RestAdapter.Builder builder = new RestAdapter.Builder();
builder
.setEndpoint(host)
.setClient(new OkClient(OkHttpUtils.getInstance(context)))
.setRequestInterceptor(RequestIntercepts.newInstance())
.setConverter(new GsonConverter(GsonUtils.newInstance()))
.setErrorHandler(new ErrorHandlers())
.setLogLevel(debug ? RestAdapter.LogLevel.FULL : RestAdapter.LogLevel.NONE)/*LogLevel.BASIC will cause response.getBody().in() close*/
.setLog(new RestAdapter.Log() {
@Override
public void log(String message) {
if (message.startsWith("{") || message.startsWith("["))
Logger.json(message);
else {
Logger.i(message);
}
}
});
singleton = builder.build();
}
}
}
return singleton.create(clazz);
}