El registro con la modernización de 2

En Retrofit 2 debe utilizar HttpLoggingInterceptor.

Añadir dependencia a build.gradle. La última versión de octubre de 2019 es:

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

Crear un Retrofit objeto, como las siguientes:

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);

En caso de ser desaprobado advertencias, simplemente cambiar setLevel a:

interceptor.level(HttpLoggingInterceptor.Level.BODY);

La solución anterior le da logcat mensajes muy similares a los antiguos establecidos por

setLogLevel(RestAdapter.LogLevel.FULL)

En caso de java.lang.ClassNotFoundException:

Mayores de Reconversión de la versión puede requerir una mayor logging-interceptor versión. Echa un vistazo a las secciones de comentarios para obtener más detalles.

Conocí a la cosa, como usted y yo traté de preguntar al autor del libro Retrofit: me Encanta trabajar con las Api de Android (aquí está el enlace)
(nope! No estoy haciendo algunos anuncios para ellos….pero son muy buenas personas 🙂
Y el autor me respondió muy pronto, tanto con el método de Registro en Retrofit 1.9 o 2.0-beta.

Y aquí está el código de Reconversión de 2.0 beta:

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();  
//set your desired log level
logging.setLevel(Level.BODY);

OkHttpClient httpClient = new OkHttpClient();  
//add your other interceptors …

//add logging as last interceptor
httpClient.interceptors().add(logging);  //<-- this is the important line!

Retrofit retrofit = new Retrofit.Builder()  
   .baseUrl(API_BASE_URL)
   .addConverterFactory(GsonConverterFactory.create())
   .client(httpClient)
   .build();

Esta es la forma en agregar método de registro con la ayuda de HttpLoggingInterceptor. También si usted es el lector de ese libro que he mencionado anteriormente, usted puede encontrar que se dice que no hay método de registro con la modernización de 2.0 ya que, que me había pedido el autor, no es correcta y se actualizará el libro el próximo año hablando.

//En caso de que usted no está familiarizado con el método de Registro en Reconversión, me gustaría compartir algo más.

También debe ser notado que hay algunos Niveles de Registro usted podría escoger. Yo uso el Nivel.CUERPO la mayoría de las veces, lo que le da algo como esto:

Usted puede encontrar casi todos los http personal dentro de la imagen: la cabecera, el contenido y la respuesta, etc.

Y, a veces, usted realmente no necesita que todos los invitados a asistir a su fiesta: sólo quiero saber si está conectado correctamente, que la llamada de internet es realizado con éxito dentro de mi Activiy & Fragmetn. Entonces usted es libre de utilizar Nivel.BÁSICA, que devolverá algo como esto:

Se puede encontrar el código de estado 200 OK dentro? Eso es todo 🙂

También hay otro, Nivel.ENCABEZADOS, que sólo devolverá el encabezado de la red. Ya, por supuesto, otra imagen aquí:

Que todo el Registro de truco 😉

Y me gustaría compartir con usted el tutorial he aprendido mucho allí. Tienen un montón de gran post hablando de casi todo lo relacionado con la Instalación, y se siguen actualizando el post, al mismo tiempo Retrofit 2.0 está por venir. Por favor, echa un vistazo a los trabajos, que creo que le va a ahorrar mucho tiempo.

Aquí es un Interceptor que registra tanto la solicitud y la respuesta de los cuerpos (el uso de la Madera, basado en un ejemplo de la OkHttp docs y algunos otros de MODO que las respuestas):

Intente esto:

Después de esto, en el body no es el JSON que usted está interesado en.

El principal problema al que me enfrenté fue dinámico agregar encabezados y registro de ellos en debug logcat. He intentado añadir dos interceptores. Uno para el registro y uno para agregar encabezados on-the-go (token de autorización). El problema fue que nos puede .addInterceptor o .addNetworkInterceptor. Como Jake Wharton me dijo: «Red de interceptores siempre vienen después de la aplicación de los interceptores. Ver https://github.com/square/okhttp/wiki/Interceptors«. Así que aquí es ejemplo de trabajo con los jefes y los registros:

No sé si setLogLevel() devolverá en la final de la versión 2.0 de Retrofit, pero por ahora se puede utilizar un interceptor para el registro.

Un buen ejemplo se puede encontrar en OkHttp wiki: https://github.com/square/okhttp/wiki/Interceptors

Para aquellos que necesitan alto nivel de registro en la Instalación, utilice el interceptor como este

public static class LoggingInterceptor implements Interceptor {
@Override public Response intercept(Chain chain) throws IOException {
Request request = chain.request();
long t1 = System.nanoTime();
String requestLog = String.format("Sending request %s on %s%n%s",
request.url(), chain.connection(), request.headers());
//YLog.d(String.format("Sending request %s on %s%n%s",
//       request.url(), chain.connection(), request.headers()));
if(request.method().compareToIgnoreCase("post")==0){
requestLog ="\n"+requestLog+"\n"+bodyToString(request);
}
Log.d("TAG","request"+"\n"+requestLog);
Response response = chain.proceed(request);
long t2 = System.nanoTime();
String responseLog = String.format("Received response for %s in %.1fms%n%s",
response.request().url(), (t2 - t1) / 1e6d, response.headers());
String bodyString = response.body().string();
Log.d("TAG","response"+"\n"+responseLog+"\n"+bodyString);
return response.newBuilder()
.body(ResponseBody.create(response.body().contentType(), bodyString))
.build();
//return response;
}
}
public 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";
}
}`

Cortesía: https://github.com/square/retrofit/issues/1072#

Si usted está usando Retrofit2 y okhttp3 entonces usted necesita saber que el Interceptor de obras de cola. Para agregar loggingInterceptor al final, después de sus otras Interceptores:

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))//first
.addInterceptor(new OAuthInterceptor(context))//second
.authenticator(new BearerTokenAuthenticator(context))
.addInterceptor(loggingInterceptor)//third, log at the end
.build();

También puede agregar Facebook del Stetho y mirar las trazas de red en Chrome:
http://facebook.github.io/stetho/

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

A continuación, abra «chrome://inspeccionar» en Chrome…

Kotlin Código

        val interceptor = HttpLoggingInterceptor()
interceptor.level = HttpLoggingInterceptor.Level.BODY
val client = OkHttpClient.Builder().addInterceptor(interceptor).build()
val retrofit = Retrofit.Builder()
.baseUrl(BASE_URL)
.client(client)
.addConverterFactory(GsonConverterFactory.create())
.build()
return retrofit.create(PointApi::class.java)

esto creará una actualización de objeto con el Registro. sin la creación de objetos separados.

 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();

Una mejor manera de hacer esto bien en Retrofit 2 es agregar el registrador de interceptor como un networkInterceptor esto va a imprimir los encabezados de red y su encabezados personalizados también. Lo importante es recordar que el interceptor de trabajo como una pila y asegúrese de u agregar el registrador, al final de todo.

OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.addInterceptor(new MyCustomInterceptor());
builder.connectTimeout(60, TimeUnit.SECONDS);
builder.readTimeout(60, TimeUnit.SECONDS);
builder.writeTimeout(60, TimeUnit.SECONDS);
//important line here
builder.addNetworkInterceptor(LoggerInterceptor());

La mayoría de la respuesta aquí cubre casi todo excepto a esta herramienta, una de las mejores maneras para ver el registro.

Es Facebook del Stetho. Este es el excelente herramienta para monitorear/registro de su aplicación en el tráfico de la red en google chrome. Usted también puede encontrar aquí en Github.

para la modificación 2.0.2 el código es como

   **HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient.Builder httpClient=new OkHttpClient.Builder();
httpClient.addInterceptor(logging);**
if (retrofit == null) {
retrofit = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
**.client(httpClient.build())**
.build();
}

Primer Añadir dependencia a construir.gradle:

aplicación ‘com.squareup.okhttp3:registro-interceptor:3.12.1’

Mientras que el uso de Kotlin puede añadir el Registro de Interceptor como este :

companion object {
val okHttpClient = OkHttpClient().newBuilder()
.addInterceptor(HttpLoggingInterceptor().apply {
level = HttpLoggingInterceptor.Level.BODY
})
.build()
fun getRetrofitInstance(): Retrofit {
val retrofit = Retrofit.Builder()
.client(okHttpClient)
.baseUrl(ScanNShopConstants.BASE_URL)
.addCallAdapterFactory(RxJava2CallAdapterFactory.create())
.addConverterFactory(GsonConverterFactory.create())
.build()
return retrofit
}
}

Aquí es una forma sencilla de filtrar cualquier petición/respuesta de parámetros a partir de los registros de uso de HttpLoggingInterceptor :

//Request patterns to filter
private static final String[] REQUEST_PATTERNS = {
"Content-Type",
};
//Response patterns to filter
private static final String[] RESPONSE_PATTERNS = {"Server", "server", "X-Powered-By", "Set-Cookie", "Expires", "Cache-Control", "Pragma", "Content-Length", "access-control-allow-origin"};
//Log requests and response
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
@Override
public void log(String message) {
//Blacklist the elements not required
for (String pattern: REQUEST_PATTERNS) {
if (message.startsWith(pattern)) {
return;
}
}
//Any response patterns as well...
for (String pattern: RESPONSE_PATTERNS) {
if (message.startsWith(pattern)) {
return;
}
}
Log.d("RETROFIT", message);
}
});
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

Aquí está la información completa de:

https://gist.github.com/mankum93/179c2d5378f27e95742c3f2434de7168

He encontrado forma de Registro de Impresión en Retrofit

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);

Funciona para mí.

hola chicos，yo ya encontró la solución:

  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);
}