Retrofit 2.0 Wie drucke ich die volle json Antwort?

Ich bin bewegt von Volley Retrofit-aktuell version 2.0.

Drucken das vollständige json-response-code ?

umfasst:

compile 'com.squareup.retrofit:converter-gson:2.0.0-beta2'
compile 'com.squareup.retrofit:retrofit:2.0.0-beta2'

RestClient:

OkHttpClient client = new OkHttpClient();
        client.interceptors().add(new Interceptor() {
            @Override
            public Response intercept(Interceptor.Chain chain) throws IOException {
                Response response = chain.proceed(chain.request());                
                return response;
            }
        });


        Gson gson = new GsonBuilder()
                .setDateFormat("yyyy'-'MM'-'dd'T'HH':'mm':'ss'.'SSS'Z'")
                .create();


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

        REST_CLIENT = retrofit.create(APIService.class);

APIService:

   @GET("my/json")
    Call<Model> getFeed();

In Aktivität - Aufrufen von API -:

Call<Model> call = RestClient.get().getFeed();
call.enqueue(new Callback<Model>() {
    @Override
    public void onResponse(Response<Model> response, Retrofit retrofit) {

        Log.w("2.0 getFeed > response.raw() => ", response.raw().toString());//DONT WORK
        Log.w("2.0 getFeed > retrofit => ", retrofit.toString());//DONT WORK
        Log.w("2.0 getFeed > body => ", response.body().toString()); //DONT WORK
        Log.w("2.0 getFeed > getStatus => ", response.body().getStatus());

    }

    @Override
    public void onFailure(Throwable t) {
        t.printStackTrace();
        Log.e("2.0 getFeed > onFailure => ", t.toString());
    }
});

InformationsquelleAutor der Frage Joolah | 2015-10-06

33

Drucken die vollständige Antwort ist in json:
```
Log.w("2.0 getFeed > Full json res wrapped in gson => ",new Gson().toJson(response));
```
Wenn Sie möchte haben pretty print Funktion verwenden:
```
Log.w("2.0 getFeed > Full json res wrapped in pretty printed gson => ",new GsonBuilder().setPrettyPrinting().create().toJson(response));
```
Beachten Sie, dass diese druckt die Daten deserialisiert (nicht Roh als Antwort zurückgegeben vom server). Die roh-Reaktion, würden Sie brauchen, um deal mit HttpLoggingInterceptor oder Ihre eigene version von interceptor. Ein anderer Ansatz für die Verwendung von http debuf-tools wie Stetho oder Charles Web Debugging Proxy .

InformationsquelleAutor der Antwort Maher Abuthraa

Plug in der folgenden interceptor-Klasse wie diese

OkHttpClient client = new OkHttpClient();
        client.interceptors().add(new LoggingInterceptor());

//////Interceptor-Klasse

public static class LoggingInterceptor implements Interceptor {
        @Override
        public com.squareup.okhttp.Response intercept(Chain chain) throws IOException {
            Log.i("LoggingInterceptor","inside intercept callback");
            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());
            if(request.method().compareToIgnoreCase("post")==0){
                requestLog ="\n"+requestLog+"\n"+bodyToString(request);
            }
            Log.d("TAG","request"+"\n"+requestLog);
            com.squareup.okhttp.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 only"+"\n"+bodyString);

            Log.d("TAG","response"+"\n"+responseLog+"\n"+bodyString);

            return response.newBuilder()
                    .body(ResponseBody.create(response.body().contentType(), bodyString))
                    .build();

        }


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#

InformationsquelleAutor der Antwort DGN

12

Eigentlich Platz schon eine Klasse erstellen, die nur für diese, fügen Sie einfach
```
HttpLoggingInterceptor interceptor = new HttpLoggingInterceptor();
interceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(interceptor).build();
```
Und in Retrofit -
```
Retrofit retrofit = new Retrofit.Builder()
            .client(client)               
            .baseUrl("https://yourapi.com/api/")
            .build();
```
Die interceptor-Klasse ist in maven central
```
compile 'com.squareup.okhttp3:logging-interceptor:3.5.0'
```
Können Sie den Protokolliergrad festlegen in HttpLoggingInterceptor Klasse. KÖRPER ist der verbose-one (drucken alles, was den Körper). Weitere Informationen finden Sie auf OkHttp github

Vorsicht!

Vergessen Sie nicht, entfernen Abfangjäger (oder ändern Logging-Level auf "NONE") in der Produktion! Ansonsten Leute sehen Ihre Anfrage und Reaktion auf Log Cat.

InformationsquelleAutor der Antwort aldok

Versuchen, diese !!

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

    /** Handles Log */
    retrofit.client().interceptors().add(new LoggingInterceptor());

    mRestClient = retrofit.create(RestServices.class);





class LoggingInterceptor implements Interceptor {
@Override
public Response intercept(Interceptor.Chain chain) throws IOException {
    Request request = chain.request();

    long t1 = System.nanoTime();
    Logger.d(String.format("Sending request %s on %s%n%s",
            request.url(), chain.connection(), request.headers()));

    Response response = chain.proceed(request);

    long t2 = System.nanoTime();
    Logger.d(String.format("Received response for %s in %.1fms%n%s",
            response.request().url(), (t2 - t1) / 1e6d, response.headers()));


    final String responseString = new String(response.body().bytes());

    Logger.d("Response: " + responseString);

    return  response.newBuilder()
            .body(ResponseBody.create(response.body().contentType(), responseString))
            .build();
}

Schauen Sie sich diese Demo !!!

InformationsquelleAutor der Antwort sreekumar

Erhalten Sie die volle Antwort im Json-in retrofit2.3.0 verwenden Sie unten.

dies funktioniert für mich.

call.enqueue(new Callback<someList>() {
        @Override
        public void onResponse(Call<someList> call, Response<someList> response) {
            if (response.isSuccessful())
                Log.e("Success", new Gson().toJson(response.body()));
            else
                Log.e("unSuccess", new Gson().toJson(response.errorBody()));
        }

        @Override
        public void onFailure(Call<someList> call, Throwable t) {
            Log.e("onFailure", t.toString());
        }
    });

InformationsquelleAutor der Antwort Dhiren

Call<Model> call = RestClient.get().getFeed();call.enqueue(new Callbstrong




textack<Model>() {

@Override


public void onResponse(Response<Model> response, Retrofit retrofit) {


//try this 


Call<Model> call = response.body();

// this is enough for retrieve model


}

@Override
public void onFailure(Throwable t) {

  t.printStackTrace();

        og.e("2.0 getFeed > onFailure => ", t.toString());

}

});

InformationsquelleAutor der Antwort user3551205

0

Versuchen Sie dies :
```
 Log.d("LOG","RESPONSE ==="+response.raw().toString());
```
InformationsquelleAutor der Antwort Saurabh Mistry
0

Werfen Sie einen Blick auf okhttp3.logging-Paket Sie haben bereits HttpLoggingInterceptor, die Sie verwenden können, für Ihre Bedürfnisse.
Und von Ihnen abhängig, Sie können auch festlegen, Anmeldung Ebene.

und Sie können diese Abfangjäger zu Ihrer Anfrage wie bereits erwähnt - über OkHttpClient.Builder:
```
public OkHttpClient provideOkHttpClient() {
    final OkHttpClient.Builder okHttpBuilder = new OkHttpClient.Builder();
    okHttpBuilder.addInterceptor(new HttpLoggingInterceptor().setLevel(HttpLoggingInterceptor.Level.BODY));
    return okHttpBuilder.build();
}
```
InformationsquelleAutor der Antwort Anton Kogan

public class HttpLoggingInterceptor {
    HttpLoggingInterceptor provideHttpLoggingInterceptor(){
        return new HttpLoggingInterceptor(message ->
                Log.d("TAG", message)).setLevel(HttpLoggingInterceptor.Level.BODY);
    }
}


public class OkHttpClient {
    OkHttpClient provideOkHttpClient(@NonNull HttpLoggingInterceptor interceptor){
        return new OkHttpClient.Builder()
               .addInterceptor(interceptor)
               .build();
    }  
}

InformationsquelleAutor der Antwort Антон Лялин

-1

Können Sie set log-level für Ihr retrofit-adapter wie unten, und sehen, Reaktion und andere Daten wie header -, response-code vs.
```
setLogLevel(LogLevel.FULL)
```
Edit: Dies funktioniert nicht bei Retrofit-2.0. Wenn Sie mit den 1.9, die Sie verwenden können.

InformationsquelleAutor der Antwort savepopulation

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.