Retrofit 2로 로깅

요청에서 전송되는 정확한 JSON을 얻으려고합니다. 내 코드는 다음과 같습니다.

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

그러나 나는 로그에서만 이것을 볼 수 있습니다.

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

어떻게 제거 주어진 적절한 로깅을 어떻게해야하고 setLog()그리고 setLogLevel()우리가 개조 1 사용하는 데 사용하는?

Retrofit 2에서는 HttpLoggingInterceptor 를 사용해야합니다 .

에 종속성을 추가하십시오 build.gradle. 2019 년 10 월 기준 최신 버전 :

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

Retrofit다음과 같은 객체를 만듭니다 .

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

사용 중단 경고가 표시되면 다음 setLevel으로 변경 하십시오.

interceptor.level(HttpLoggingInterceptor.Level.BODY);

위의 솔루션은 이전에 설정 한 것과 매우 유사한 logcat 메시지를 제공합니다.

setLogLevel(RestAdapter.LogLevel.FULL)

의 경우java.lang.ClassNotFoundException :

이전 Retrofit 버전에는 이전 버전이 필요할 수 있습니다 logging-interceptor. 자세한 내용은 의견 섹션을보십시오.

나는 당신이 그 일을 만났고 나는 Retrofit : Android에서 API로 작업하는 것을 좋아합니다 (여기 링크가 있습니다 ). guys :) 그리고 저자는 Retrofit 1.9에 대한 Log 메소드와 Retrofit 2.0-beta에 대해 곧 답장을 보냈습니다.

다음은 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();

HttpLoggingInterceptor 의 도움으로 로깅 메소드를 추가하는 방법입니다 . 또한 내가 위에서 언급 한 책의 독자라면 Retrofit 2.0에는 더 이상 로그 방법이 없다고 말할 수 있습니다. 그것에 대해.

// Retrofit의 Log 메소드에 익숙하지 않은 경우 더 공유하고 싶습니다.

또한 선택할 수있는 몇 가지 로깅 수준이 있습니다. 나는 대부분 Level.BODY를 사용합니다 .

그림 내에서 거의 모든 http 직원을 찾을 수 있습니다 : 헤더, 내용 및 응답 등

때로는 파티에 참석할 모든 손님이 필요하지 않습니다. 인터넷 연결이 성공적으로 연결되어 있는지, Activiy & Fragmetn 내에서 인터넷 전화가 제대로 연결되었는지 확인하고 싶습니다. 그런 다음 Level.BASIC을 자유롭게 사용할 수 있습니다 .

상태 코드 200 OK 를 찾을 수 있습니까 ? 그게 다야 :)

또한 또 하나의 Level.HEADERS가 있는데 , 이는 네트워크의 헤더 만 반환합니다. 물론 여기에 다른 그림이 있습니다.

이것이 모든 로깅 트릭입니다.)

그리고 나는 많은 것을 배웠 자습서를 공유하고 싶습니다 있다 . 그들은 Retrofit과 관련된 거의 모든 것에 대해 이야기하는 훌륭한 게시물을 가지고 있으며 Retrofit 2.0이 출시되는 동안 게시물을 계속 업데이트하고 있습니다. 많은 시간을 절약 할 수 있다고 생각되는 작업을 살펴보십시오.

다음은 Interceptor요청 및 응답 본문을 모두 기록하는 로그입니다 (OkHttp 문서 및 기타 SO 답변의 예제를 기반으로 Timber 사용).

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

이 시도:

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

그 후, body관심있는 JSON이 있습니다.

내가 직면 한 주요 문제는 동적으로 헤더를 추가하고 디버그 logcat에 로깅하는 것이 었습니다. 두 개의 인터셉터를 추가하려고했습니다. 하나는 로깅을위한 것이고 다른 하나는 이동 중에 헤더를 추가하기위한 것입니다 (토큰 인증). 문제는 .addInterceptor 또는 .addNetworkInterceptor 일 수 있다는 것이 었습니다. Jake Wharton이 "네트워크 인터셉터는 항상 응용 프로그램 인터셉터를 따릅니다. https://github.com/square/okhttp/wiki/Interceptors "를 참조 하십시오 . 헤더와 로그에 대한 예제는 다음과 같습니다.

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

setLogLevel ()이 최종 2.0 버전의 Retrofit에서 반환되는지 모르겠지만 지금은 인터셉터를 사용하여 로깅 할 수 있습니다.

OkHttp 위키에서 좋은 예를 찾을 수 있습니다 : 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();

Retrofit2 및 okhttp3을 사용하는 경우 인터셉터가 큐별로 작동한다는 것을 알아야합니다. 따라서 다른 인터셉터 다음에 loggingInterceptor를 끝에 추가하십시오.

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

Retrofit에서 높은 수준의 로깅이 필요한 경우 다음과 같이 인터셉터를 사용하십시오.

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

예의 : https://github.com/square/retrofit/issues/1072#

코 틀린 코드

        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)

Facebook의 Stetho를 추가하고 Chrome에서 네트워크 추적을 볼 수도 있습니다. http://facebook.github.io/stetho/

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

그런 다음 Chrome에서 "chrome : // inspect"를 엽니 다 ...

이렇게하면 로깅으로 개량 객체가 생성됩니다. 별도의 개체를 만들지 않고

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

먼저 build.gradle에 대한 종속성을 추가하십시오.

구현 'com.squareup.okhttp3 : logging-interceptor : 3.12.1'

Kotlin을 사용하는 동안 다음과 같이 Logging Interceptor를 추가 할 수 있습니다.

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

다음 코드 세트는 아무런 문제없이 작동합니다.

그래들

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

Android Studio 하단의 프로파일 러 탭으로 이동 한 다음 + 기호를 클릭하여 새 세션 시작을 클릭 한 다음 "네트워크"에서 원하는 스파이크를 선택하여 결과를 확인할 수도 있습니다. 거기에서 모든 것을 얻을 수 있지만 번거롭고 느립니다. 아래 이미지를 참조하십시오.

Retrofit 2에서이 작업을 수행하는 가장 좋은 방법은 로거 인터셉터를 networkInterceptor로 추가하는 것입니다. 이렇게하면 네트워크 헤더와 사용자 정의 헤더도 인쇄됩니다. 중요한 것은 인터셉터가 스택으로 작동한다는 사실을 기억하고 결국에는 로거를 추가해야합니다.

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

여기에있는 대부분의 대답은이 도구를 제외한 거의 모든 것을 다룹니다. 로그를 보는 가장 멋진 방법 중 하나입니다.

그것은이다 페이스 북의 Stetho . 이것은 구글 크롬 에서 앱의 네트워크 트래픽을 모니터링 / 기록하는 훌륭한 도구 입니다. 당신은 또한 찾을 수 있습니다 여기 Github에서에.

Retrofit 2.0.2의 경우 코드는

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

다음을 사용하여 로그에서 요청 / 응답 매개 변수를 필터링하는 간단한 방법은 다음과 같습니다 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);

전체 요점은 다음과 같습니다.

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

나도 비슷한 상황에 갇혀 있었고 setLevel() 있었고, HttpLoggingInterceptor의 인스턴스로 호출하려고 할 때 메소드가 오지 않았다.

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

Retrofit2에 대한 로그를 생성하기 위해 해결 방법은 다음과 같습니다.

나는 당신이 의존성을 추가했다고 가정합니다.

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

최신 버전의 경우 다음 링크를 확인하십시오.

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

여기에서는 추가 방법에 대해서도 설명했습니다.

나는 name이라는 클래스를 만들었습니다. AddLoggingInterceptor여기 내 코드가 있습니다.

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

그런 다음 개조를 인스턴스화하는 위치에서

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

이제 Android Studio에서 생성 된 로그를 볼 수 있으며 okHttp필터링 프로세스를 위해 검색해야 할 수도 있습니다 . 그것은 나를 위해 일했다. 문제가 있으면 여기에 문자를 보내주십시오.

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

나를 위해 작동합니다.

Retrofit의 인터셉터는 http 요청을 처리 할 수있는 훌륭한 기능입니다. 응용 프로그램과 네트워크 인터셉터의 두 가지 유형이 있습니다.

Charles Web Debugging Proxy Application요청 / 응답을 기록 해야하는 경우 사용 하는 것이 좋습니다 . 출력은 Stetho와 매우 유사하지만 더 강력한 계측기이므로 응용 프로그램에 대한 종속성으로 추가 할 필요가 없습니다.

안녕하세요, 나는 이미 해결책을 찾았습니다.

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