Protokollierung mit Nachrüstung 2

Ich versuche, den genauen JSON zu erhalten, der in der Anfrage gesendet wird. Hier ist mein Code:

OkHttpClient client = new OkHttpClient();
client.interceptors().add(new Interceptor(){
   @Override public com.squareup.okhttp.Response intercept(Chain chain) throws IOException {
      Request request = chain.request();
      Log.e(String.format("\nrequest:\n%s\nheaders:\n%s",
                          request.body().toString(), request.headers()));
      com.squareup.okhttp.Response response = chain.proceed(request);
      return response;
   }
});
Retrofit retrofit = new Retrofit.Builder()
   .baseUrl(API_URL)
   .addConverterFactory(GsonConverterFactory.create())
   .client(client).build();

Aber ich sehe das nur in den Protokollen:

request:
com.squareup.okhttp.RequestBody$1@3ff4074d
headers:
Content-Type: application/vnd.ll.event.list+json

Wie soll ich die richtige Protokollierung tun, da die Entfernung von setLog()und mit setLogLevel()dem wir mit Retrofit 1 benutzen?

In Retrofit 2 sollten Sie HttpLoggingInterceptor verwenden .

Abhängigkeit hinzufügen zu build.gradle. Neueste Version ab Oktober 2019 ist:

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

Erstellen Sie ein RetrofitObjekt wie folgt:

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

Im Falle von Verfallswarnungen wechseln Sie einfach setLevelzu:

interceptor.level(HttpLoggingInterceptor.Level.BODY);

Mit der obigen Lösung erhalten Sie Logcat-Nachrichten, die den alten von sehr ähnlich sind

setLogLevel(RestAdapter.LogLevel.FULL)

Im Falle vonjava.lang.ClassNotFoundException :

Für ältere Nachrüstversionen ist möglicherweise eine ältere logging-interceptorVersion erforderlich . Weitere Informationen finden Sie in den Kommentaren.

Ich habe das Ding getroffen, als Sie und ich habe versucht, den Autor des Buches Retrofit zu fragen : Ich liebe es, mit APIs auf Android zu arbeiten (hier ist der Link ) (nein! Ich mache keine Werbung für sie ... aber sie sind wirklich nett Jungs :) Und der Autor antwortete mir sehr bald mit der Log-Methode für Retrofit 1.9 und Retrofit 2.0-Beta.

Und hier ist der Code von Retrofit 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();

So fügen Sie mithilfe von HttpLoggingInterceptor eine Protokollierungsmethode hinzu . Auch wenn Sie der Leser dieses Buches sind, das ich oben erwähnt habe, werden Sie möglicherweise feststellen, dass es mit Retrofit 2.0 keine Protokollmethode mehr gibt - was, wie ich den Autor gefragt hatte, nicht korrekt ist und sie das Buch im nächsten Jahr im Gespräch aktualisieren werden darüber.

// Falls Sie mit der Log-Methode in Retrofit nicht so vertraut sind, möchte ich etwas mehr mitteilen.

Beachten Sie auch, dass Sie einige Protokollierungsstufen auswählen können. Ich benutze den Level.BODY die meiste Zeit, was ungefähr so ​​etwas ergibt:

Sie können fast alle http-Mitarbeiter im Bild finden: den Header, den Inhalt und die Antwort usw.

Und manchmal brauchen Sie wirklich nicht alle Gäste, um an Ihrer Party teilzunehmen: Ich möchte nur wissen, ob die Verbindung erfolgreich hergestellt wurde und ob der Internetanruf in meinem Activiy & Fragmetn erfolgreich getätigt wurde. Dann können Sie Level.BASIC verwenden , das ungefähr Folgendes zurückgibt :

Können Sie den Statuscode 200 OK darin finden? Das ist es :)

Es gibt auch eine andere, Level.HEADERS , die nur den Header des Netzwerks zurückgibt . Ya natürlich noch ein Bild hier:

Das ist der ganze Logging-Trick;)

Und ich möchte Sie mit dem Tutorial teilen , die ich viel gelernt dort . Sie haben eine Menge großartiger Posts, die über fast alles im Zusammenhang mit Retrofit sprechen, und sie aktualisieren den Post weiter, während Retrofit 2.0 kommt. Bitte werfen Sie einen Blick auf diese Arbeiten, von denen ich denke, dass Sie viel Zeit sparen werden.

Hier ist ein Interceptor , die sowohl den Anforderungs- als auch den Antworttext protokolliert (unter Verwendung von Timber, basierend auf einem Beispiel aus den OkHttp-Dokumenten und einigen anderen SO-Antworten):

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

Versuche dies:

Request request = chain.request();
Buffer buffer = new Buffer();
request.body().writeTo(buffer);
String body = buffer.readUtf8();

Danach bodygibt es den JSON, an dem Sie interessiert sind.

Das Hauptproblem, mit dem ich konfrontiert war, war das dynamische Hinzufügen von Headern und deren Protokollierung in Debug Logcat. Ich habe versucht, zwei Abfangjäger hinzuzufügen. Eine zum Protokollieren und eine zum Hinzufügen von Headern für unterwegs (Token-Autorisierung). Das Problem war, dass wir .addInterceptor oder .addNetworkInterceptor können. Wie Jake Wharton zu mir sagte: "Netzwerk-Interceptors kommen immer nach Anwendungs-Interceptors. Siehe https://github.com/square/okhttp/wiki/Interceptors. " Hier ist ein Arbeitsbeispiel mit Headern und Protokollen:

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

Ich weiß nicht, ob setLogLevel () in der endgültigen Version 2.0 von Retrofit zurückgegeben wird, aber Sie können vorerst einen Interceptor für die Protokollierung verwenden.

Ein gutes Beispiel finden Sie im 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();

Wenn Sie Retrofit2 und okhttp3 verwenden, müssen Sie wissen, dass Interceptor nach Warteschlange arbeitet. Fügen Sie also am Ende nach Ihren anderen Interceptors loggingInterceptor hinzu:

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

Verwenden Sie den Interceptor wie folgt, wenn Sie sich bei Retrofit auf hoher Ebene anmelden möchten

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";
    }
}`

Mit freundlicher Genehmigung : https://github.com/square/retrofit/issues/1072#

Kotlin Code

        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)

Sie können auch Facebooks Stetho hinzufügen und die Netzwerkspuren in Chrome anzeigen: http://facebook.github.io/stetho/

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

Dann öffnen Sie "chrome: // inspect" in Chrome ...

Dadurch wird ein Nachrüstobjekt mit Protokollierung erstellt. ohne separate Objekte zu erstellen.

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

Fügen Sie zuerst die Abhängigkeit zu build.gradle hinzu:

Implementierung 'com.squareup.okhttp3: Logging-Interceptor: 3.12.1'

Während Sie Kotlin verwenden, können Sie Logging Interceptor wie folgt hinzufügen:

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

Der folgende Code funktioniert für mich ohne Probleme

Gradle

// Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.5.0'
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
implementation 'com.squareup.okhttp3:logging-interceptor:3.12.1'

RetrofitClient

HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
logging.setLevel(HttpLoggingInterceptor.Level.BODY);

OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(logging)
        .build();

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

Sie können die Ergebnisse auch überprüfen, indem Sie auf die Registerkarte "Profiler" unten in Android Studio gehen, dann auf + klicken, um eine neue Sitzung zu starten, und dann die gewünschte Spitze in "Netzwerk" auswählen. Dort kann man alles bekommen, aber es ist umständlich und langsam. Bitte siehe Bild unten.

Eine beste Möglichkeit, dies in Retrofit 2 richtig zu machen, besteht darin, den Logger-Interceptor als networkInterceptor hinzuzufügen. Dadurch werden die Netzwerk-Header und auch Ihre benutzerdefinierten Header ausgedruckt. Das Wichtigste ist, sich daran zu erinnern, dass der Interceptor als Stapel fungiert, und sicherzustellen, dass Sie den Logger am Ende hinzufügen.

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

Die meisten Antworten hier decken fast alles ab, außer diesem Tool, einer der coolsten Möglichkeiten, das Protokoll anzuzeigen.

Es ist Facebooks Stetho . Dies ist das hervorragende Tool zum Überwachen / Protokollieren des Netzwerkverkehrs Ihrer App auf Google Chrome . Sie können auch hier auf Github finden.

für Retrofit 2.0.2 ist der Code wie

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

Hier ist eine einfache Möglichkeit, Anforderungs- / Antwortparameter aus den Protokollen zu filtern, indem Sie Folgendes verwenden 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);

Hier ist das Wesentliche:

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

Ich war auch in einer ähnlichen Situation festgefahren, die setLevel()Methode kam nicht, als ich versuchte, sie mit der Instanz von HttpLoggingInterceptor wie folgt aufzurufen:

HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

Hier ist, wie ich es gelöst habe, um ein Protokoll für Retrofit2 zu generieren:

Ich nehme an, Sie haben die Abhängigkeit hinzugefügt,

implementation "com.squareup.okhttp3:logging-interceptor:4.7.2"

Die neueste Version finden Sie unter folgendem Link:

https://github.com/square/okhttp/tree/master/okhttp-logging-interceptor )

Hier haben sie auch erklärt, wie man hinzufügt.

Ich habe eine Klasse mit Namen erstellt AddLoggingInterceptor. Hier ist mein Code.

public class AddLoggingInterceptor {

    public static OkHttpClient setLogging(){
        HttpLoggingInterceptor loggingInterceptor = new HttpLoggingInterceptor();
        loggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);

        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .addInterceptor(loggingInterceptor)
                .build();

        return okHttpClient;
    }
}

Dann, wo wir unsere Nachrüstung instanziieren,

 public static Retrofit getRetrofitInstance() {
    if (retrofit == null) {
        retrofit = new retrofit2.Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addConverterFactory(GsonConverterFactory.create())
                .client(AddLoggingInterceptor.setLogging()) // here the method is called inside client() method, with the name of class, since it is a static method.
                .build();
    }
    return retrofit;
}

Jetzt können Sie das in Ihrem Android Studio generierte Protokoll sehen. Möglicherweise müssen Sie nach dem okHttpFilterprozess suchen . Es hat bei mir funktioniert. Bei Problemen können Sie mir hier eine SMS schicken.

Ich habe den Weg für Print Log in Retrofit gefunden

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

Funktioniert bei mir.

Der Interceptor von Retrofit ist eine großartige Funktion, mit der Sie mit http-Anforderungen arbeiten können. Es gibt zwei Arten von ihnen: Anwendungs- und Netzwerkabfangjäger.

Ich würde empfehlen, zu verwenden, Charles Web Debugging Proxy Applicationwenn Sie Ihre Anfragen / Antworten protokollieren müssen. Die Ausgabe ist Stetho sehr ähnlich, aber es ist ein leistungsfähigeres Instrument, das Sie nicht als Abhängigkeit zu einer Anwendung hinzufügen müssen

Hey Leute, ich finde bereits eine Lösung:

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