Saya telah menggunakan Spring RestTemplate untuk sementara waktu dan saya secara konsisten menabrak dinding ketika saya mencoba men-debug permintaan dan tanggapannya. Saya pada dasarnya mencari untuk melihat hal yang sama seperti yang saya lihat ketika saya menggunakan ikal dengan opsi "verbose" dihidupkan. Sebagai contoh :

curl -v http://twitter.com/statuses/public_timeline.rss

Akan menampilkan data yang dikirim dan data yang diterima (termasuk header, cookie, dll.).

Saya telah memeriksa beberapa posting terkait seperti: Bagaimana cara mencatat respons di Spring RestTemplate? tapi saya belum berhasil menyelesaikan masalah ini.

Salah satu cara untuk melakukan ini adalah dengan benar-benar mengubah kode sumber RestTemplate dan menambahkan beberapa pernyataan logging tambahan di sana, tapi saya akan menemukan pendekatan ini benar-benar hal terakhir. Seharusnya ada beberapa cara untuk memberi tahu Spring Web Client / RestTemplate untuk mencatat semuanya dengan cara yang lebih ramah.

Tujuan saya adalah dapat melakukan ini dengan kode seperti:

restTemplate.put("http://someurl", objectToPut, urlPathValues);

dan kemudian untuk mendapatkan jenis informasi debug yang sama (seperti yang saya dapatkan dengan curl) di file log atau di konsol. Saya percaya ini akan sangat berguna bagi siapa saja yang menggunakan Spring RestTemplate dan memiliki masalah. Menggunakan curl untuk men-debug masalah RestTemplate Anda tidak berfungsi (dalam beberapa kasus).

Cukup untuk melengkapi contoh dengan implementasi penuh ClientHttpRequestInterceptoruntuk melacak permintaan dan respons:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor {

    final static Logger log = LoggerFactory.getLogger(LoggingRequestInterceptor.class);

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        traceRequest(request, body);
        ClientHttpResponse response = execution.execute(request, body);
        traceResponse(response);
        return response;
    }

    private void traceRequest(HttpRequest request, byte[] body) throws IOException {
        log.info("===========================request begin================================================");
        log.debug("URI         : {}", request.getURI());
        log.debug("Method      : {}", request.getMethod());
        log.debug("Headers     : {}", request.getHeaders() );
        log.debug("Request body: {}", new String(body, "UTF-8"));
        log.info("==========================request end================================================");
    }

    private void traceResponse(ClientHttpResponse response) throws IOException {
        StringBuilder inputStringBuilder = new StringBuilder();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), "UTF-8"));
        String line = bufferedReader.readLine();
        while (line != null) {
            inputStringBuilder.append(line);
            inputStringBuilder.append('\n');
            line = bufferedReader.readLine();
        }
        log.info("============================response begin==========================================");
        log.debug("Status code  : {}", response.getStatusCode());
        log.debug("Status text  : {}", response.getStatusText());
        log.debug("Headers      : {}", response.getHeaders());
        log.debug("Response body: {}", inputStringBuilder.toString());
        log.info("=======================response end=================================================");
    }

}

Kemudian instantiate RestTemplatemenggunakan a BufferingClientHttpRequestFactorydan LoggingRequestInterceptor:

RestTemplate restTemplate = new RestTemplate(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
List<ClientHttpRequestInterceptor> interceptors = new ArrayList<>();
interceptors.add(new LoggingRequestInterceptor());
restTemplate.setInterceptors(interceptors);

The BufferingClientHttpRequestFactorydiperlukan karena kami ingin menggunakan respon tubuh baik dalam pencegat dan untuk kode panggilan awal. Implementasi default memungkinkan untuk membaca badan respons hanya sekali.

di Spring Boot Anda bisa mendapatkan permintaan / respons penuh dengan menyetelnya di properti (atau metode 12 faktor lainnya)

logging.level.org.apache.http=DEBUG

output ini

-DEBUG .i.c.DefaultHttpClientConnectionOperator : Connecting to localhost/127.0.0.1:41827
-DEBUG .i.c.DefaultHttpClientConnectionOperator : Connection established 127.0.0.1:39546<->127.0.0.1:41827
-DEBUG o.a.http.impl.execchain.MainClientExec   : Executing request POST /v0/users HTTP/1.1
-DEBUG o.a.http.impl.execchain.MainClientExec   : Target auth state: UNCHALLENGED
-DEBUG o.a.http.impl.execchain.MainClientExec   : Proxy auth state: UNCHALLENGED
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> POST /v0/users HTTP/1.1
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Content-Type: application/json;charset=UTF-8
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Content-Length: 56
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Host: localhost:41827
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Connection: Keep-Alive
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> User-Agent: Apache-HttpClient/4.5.2 (Java/1.8.0_102)
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Accept-Encoding: gzip,deflate
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "POST /v0/users HTTP/1.1[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Content-Type: application/json;charset=UTF-8[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Content-Length: 56[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Host: localhost:41827[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Connection: Keep-Alive[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "User-Agent: Apache-HttpClient/4.5.2 (Java/1.8.0_102)[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Accept-Encoding: gzip,deflate[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "{"id":null,"email":"xenoterracide@gmail.com","new":true}"

dan tanggapan

-DEBUG .i.c.DefaultHttpClientConnectionOperator : Connecting to localhost/127.0.0.1:41827
-DEBUG .i.c.DefaultHttpClientConnectionOperator : Connection established 127.0.0.1:39546<->127.0.0.1:41827
-DEBUG o.a.http.impl.execchain.MainClientExec   : Executing request POST /v0/users HTTP/1.1
-DEBUG o.a.http.impl.execchain.MainClientExec   : Target auth state: UNCHALLENGED
-DEBUG o.a.http.impl.execchain.MainClientExec   : Proxy auth state: UNCHALLENGED
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> POST /v0/users HTTP/1.1
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Content-Type: application/json;charset=UTF-8
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Content-Length: 56
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Host: localhost:41827
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Connection: Keep-Alive
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> User-Agent: Apache-HttpClient/4.5.2 (Java/1.8.0_102)
-DEBUG org.apache.http.headers                  : http-outgoing-0 >> Accept-Encoding: gzip,deflate
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "POST /v0/users HTTP/1.1[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Content-Type: application/json;charset=UTF-8[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Content-Length: 56[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Host: localhost:41827[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Connection: Keep-Alive[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "User-Agent: Apache-HttpClient/4.5.2 (Java/1.8.0_102)[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "Accept-Encoding: gzip,deflate[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "[\r][\n]"
-DEBUG org.apache.http.wire                     : http-outgoing-0 >> "{"id":null,"email":"xenoterracide@gmail.com","new":true}"

atau logging.level.org.apache.http.wire=DEBUGyang sepertinya mengandung semua informasi yang relevan

Memperluas jawaban @hstoerr dengan beberapa kode:

Buat LoggingRequestInterceptor untuk mencatat respons permintaan

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor {

    private static final Logger log = LoggerFactory.getLogger(LoggingRequestInterceptor.class);

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {

        ClientHttpResponse response = execution.execute(request, body);

        log(request,body,response);

        return response;
    }

    private void log(HttpRequest request, byte[] body, ClientHttpResponse response) throws IOException {
        //do logging
    }
}

Setup RestTemplate

RestTemplate rt = new RestTemplate();

//set interceptors/requestFactory
ClientHttpRequestInterceptor ri = new LoggingRequestInterceptor();
List<ClientHttpRequestInterceptor> ris = new ArrayList<ClientHttpRequestInterceptor>();
ris.add(ri);
rt.setInterceptors(ris);
rt.setRequestFactory(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory());

Taruhan terbaik Anda adalah menambahkan logging.level.org.springframework.web.client.RestTemplate=DEBUGke application.propertiesfile.

Solusi lain seperti pengaturan log4j.logger.httpclient.wiretidak akan selalu berhasil karena mereka menganggap Anda menggunakan log4jdan Apache HttpClient, yang tidak selalu benar.

Namun, perhatikan bahwa sintaks ini hanya akan berfungsi pada versi terbaru dari Spring Boot.

Tidak satu pun dari jawaban ini yang benar-benar menyelesaikan 100% masalah. mjj1409 mendapatkan sebagian besar darinya, tetapi dengan mudah menghindari masalah logging respons, yang membutuhkan sedikit lebih banyak pekerjaan. Paul Sabou memberikan solusi yang tampaknya realistis, tetapi tidak memberikan detail yang cukup untuk benar-benar diterapkan (dan itu tidak berhasil sama sekali bagi saya). Sofiene mendapatkan pencatatan tetapi dengan masalah kritis: responsnya tidak lagi dapat dibaca karena aliran input telah digunakan!

Saya sarankan menggunakan BufferingClientHttpResponseWrapper untuk membungkus objek respons untuk memungkinkan membaca tubuh respons beberapa kali:

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor {

    private static final Logger logger = LoggerFactory.getLogger(LoggingRequestInterceptor.class);

    @Override
    public ClientHttpResponse intercept(final HttpRequest request, final byte[] body,
            final ClientHttpRequestExecution execution) throws IOException {
        ClientHttpResponse response = execution.execute(request, body);

        response = log(request, body, response);

        return response;
    }

    private ClientHttpResponse log(final HttpRequest request, final byte[] body, final ClientHttpResponse response) {
        final ClientHttpResponse responseCopy = new BufferingClientHttpResponseWrapper(response);
        logger.debug("Method: ", request.getMethod().toString());
        logger.debug("URI: ", , request.getURI().toString());
        logger.debug("Request Body: " + new String(body));
        logger.debug("Response body: " + IOUtils.toString(responseCopy.getBody()));
        return responseCopy;
    }

}

Ini tidak akan mengkonsumsi InputStream karena tubuh respons dimuat ke dalam memori dan dapat dibaca beberapa kali. Jika Anda tidak memiliki BufferingClientHttpResponseWrapper di classpath Anda, Anda dapat menemukan implementasi sederhana di sini:

https://github.com/spring-projects/spring-android/blob/master/spring-android-rest-template/src/main/java/org/springframework/http/client/BufferingClientHttpResponseWrapper.java

Untuk mengatur RestTemplate:

LoggingRequestInterceptor loggingInterceptor = new LoggingRequestInterceptor();
restTemplate.getInterceptors().add(loggingInterceptor);

Solusi yang diberikan oleh xenoterracide untuk digunakan

logging.level.org.apache.http=DEBUG

bagus tapi masalahnya adalah bahwa secara default Apache HttpComponents tidak digunakan.

Untuk menggunakan Apache HttpComponents tambahkan ke pom.xml Anda

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpasyncclient</artifactId>
</dependency>

dan konfigurasikan RestTemplatedengan:

RestTemplate restTemplate = new RestTemplate();
restTemplate.setRequestFactory(new HttpComponentsAsyncClientHttpRequestFactory());

Anda bisa menggunakan spring-rest-template-logger untuk loginRestTemplate lalu lintas HTTP.

Tambahkan ketergantungan ke proyek Maven Anda:

<dependency>
    <groupId>org.hobsoft.spring</groupId>
    <artifactId>spring-rest-template-logger</artifactId>
    <version>2.0.0</version>
</dependency>

Kemudian sesuaikan RestTemplatesebagai berikut:

RestTemplate restTemplate = new RestTemplateBuilder()
    .customizers(new LoggingCustomizer())
    .build()

Pastikan bahwa debug logging diaktifkan di application.properties:

logging.level.org.hobsoft.spring.resttemplatelogger.LoggingCustomizer = DEBUG

Sekarang semua lalu lintas HTTP RestTemplate akan dicatat org.hobsoft.spring.resttemplatelogger.LoggingCustomizer tingkat debug.

PENOLAKAN: Saya menulis perpustakaan ini.

Saya akhirnya menemukan cara untuk melakukan ini dengan cara yang benar. Sebagian besar solusi berasal dari Bagaimana cara mengkonfigurasi Spring dan SLF4J sehingga saya bisa mendapatkan logging?

Sepertinya ada dua hal yang perlu dilakukan:

1. Tambahkan baris berikut di log4j.properties: log4j.logger.httpclient.wire=DEBUG
2. Pastikan pegas tidak mengabaikan konfigurasi logging Anda

Masalah kedua kebanyakan terjadi pada lingkungan pegas di mana slf4j digunakan (seperti kasus saya). Dengan demikian, ketika slf4j digunakan pastikan bahwa dua hal berikut terjadi:

1. Tidak ada pustaka penebangan commons di classpath Anda: ini bisa dilakukan dengan menambahkan deskriptor pengecualian di pom Anda:

           <exclusions><exclusion>
               <groupId>commons-logging</groupId>
               <artifactId>commons-logging</artifactId>
           </exclusion>
       </exclusions>

2. File log4j.properties disimpan di suatu tempat di classpath di mana pegas dapat menemukan / melihatnya. Jika Anda memiliki masalah dengan ini, solusi terakhir adalah dengan meletakkan file log4j.properties dalam paket default (bukan praktik yang baik tetapi hanya untuk melihat bahwa semuanya berjalan seperti yang Anda harapkan)

Log RestTemplate

Opsi 1. Buka logging debug.

Konfigurasikan RestTemplate

• Secara default, RestTemplate bergantung pada fasilitas JDK standar untuk membuat koneksi HTTP. Anda dapat beralih untuk menggunakan pustaka HTTP yang berbeda seperti Apache HttpComponents

  @Bean publik RestTemplate restTemplate (pembuat RestTemplateBuilder) {RestTemplate restTemplate = builder.build (); mengembalikan restTemplate; }

Konfigurasikan pencatatan

• application.yml

  logging: level: org.springframework.web.client.RestTemplate: DEBUG

Opsi 2. Menggunakan Interceptor

Tanggapan Wrapper

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.util.StreamUtils;

public final class BufferingClientHttpResponseWrapper implements ClientHttpResponse {

    private final ClientHttpResponse response;

    private byte[] body;


    BufferingClientHttpResponseWrapper(ClientHttpResponse response) {
        this.response = response;
    }

    public HttpStatus getStatusCode() throws IOException {
        return this.response.getStatusCode();
    }

    public int getRawStatusCode() throws IOException {
        return this.response.getRawStatusCode();
    }

    public String getStatusText() throws IOException {
        return this.response.getStatusText();
    }

    public HttpHeaders getHeaders() {
        return this.response.getHeaders();
    }

    public InputStream getBody() throws IOException {
        if (this.body == null) {
            this.body = StreamUtils.copyToByteArray(this.response.getBody());
        }
        return new ByteArrayInputStream(this.body);
    }

    public void close() {
        this.response.close();
    }
}

Menerapkan Interceptor

package com.example.logging;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

public class LoggingRestTemplate implements ClientHttpRequestInterceptor {

    private final static Logger LOGGER = LoggerFactory.getLogger(LoggingRestTemplate.class);

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body,
            ClientHttpRequestExecution execution) throws IOException {
        traceRequest(request, body);
        ClientHttpResponse response = execution.execute(request, body);
        return traceResponse(response);
    }

    private void traceRequest(HttpRequest request, byte[] body) throws IOException {
        if (!LOGGER.isDebugEnabled()) {
            return;
        }
        LOGGER.debug(
                "==========================request begin==============================================");
        LOGGER.debug("URI                 : {}", request.getURI());
        LOGGER.debug("Method            : {}", request.getMethod());
        LOGGER.debug("Headers         : {}", request.getHeaders());
        LOGGER.debug("Request body: {}", new String(body, "UTF-8"));
        LOGGER.debug(
                "==========================request end================================================");
    }

    private ClientHttpResponse traceResponse(ClientHttpResponse response) throws IOException {
        if (!LOGGER.isDebugEnabled()) {
            return response;
        }
        final ClientHttpResponse responseWrapper = new BufferingClientHttpResponseWrapper(response);
        StringBuilder inputStringBuilder = new StringBuilder();
        BufferedReader bufferedReader = new BufferedReader(
                new InputStreamReader(responseWrapper.getBody(), "UTF-8"));
        String line = bufferedReader.readLine();
        while (line != null) {
            inputStringBuilder.append(line);
            inputStringBuilder.append('\n');
            line = bufferedReader.readLine();
        }
        LOGGER.debug(
                "==========================response begin=============================================");
        LOGGER.debug("Status code    : {}", responseWrapper.getStatusCode());
        LOGGER.debug("Status text    : {}", responseWrapper.getStatusText());
        LOGGER.debug("Headers            : {}", responseWrapper.getHeaders());
        LOGGER.debug("Response body: {}", inputStringBuilder.toString());
        LOGGER.debug(
                "==========================response end===============================================");
        return responseWrapper;
    }

}

Konfigurasikan RestTemplate

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    RestTemplate restTemplate = builder.build();
    restTemplate.setInterceptors(Collections.singletonList(new LoggingRestTemplate()));
    return restTemplate;
}

Konfigurasikan pencatatan

• Periksa paket LoggingRestTemplate, misalnya dalam application.yml:

  logging: level: com.example.logging: DEBUG

Opsi 3. Menggunakan httpcomponent

Impor dependensi httpcomponent

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpasyncclient</artifactId>

Konfigurasikan RestTemplate

@Bean
public RestTemplate restTemplate(RestTemplateBuilder builder) {
    RestTemplate restTemplate = builder.build();
    restTemplate.setRequestFactory(new HttpComponentsAsyncClientHttpRequestFactory());
    return restTemplate;
}

Konfigurasikan pencatatan

• Periksa paket LoggingRestTemplate, misalnya dalam application.yml:

  logging: level: org.apache.http: DEBUG

---- Juli 2019 ----

(menggunakan Spring Boot)

Saya terkejut bahwa Boot Spring, dengan semua sihir Konfigurasi Nol, tidak menyediakan cara mudah untuk memeriksa atau mencatat badan respons JSON sederhana dengan RestTemplate. Saya melihat melalui berbagai jawaban dan komentar yang diberikan di sini, dan saya membagikan versi suling saya sendiri tentang apa yang (masih) berfungsi dan menurut saya seperti solusi yang masuk akal, mengingat opsi saat ini (saya menggunakan Spring Boot 2.1.6 dengan Gradle 4.4 )

1. Menggunakan Fiddler sebagai proksi http

Ini sebenarnya solusi yang cukup elegan, karena mem-bypass semua upaya rumit untuk membuat interseptor Anda sendiri atau mengubah klien http yang mendasarinya menjadi apache (lihat di bawah).

Instal dan jalankan Fiddler

lalu

tambahkan -DproxySet=true -Dhttp.proxyHost=localhost -Dhttp.proxyPort=8888ke Opsi VM Anda

2. Menggunakan Apache HttpClient

Tambahkan Apache HttpClient ke dependensi Maven atau Gradle Anda.

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
    <version>4.5.9</version>
</dependency>

Gunakan HttpComponentsClientHttpRequestFactorysebagai RequestFactory untuk RestTemplate. Cara paling sederhana untuk melakukannya adalah:

RestTemplate restTemplate = new RestTemplate();

restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());

Aktifkan DEBUG di application.propertiesfile Anda (jika Anda menggunakan Spring Boot)

logging.level.org.apache.http=DEBUG

Jika Anda menggunakan Spring Boot, Anda harus memastikan bahwa Anda memiliki kerangka kerja logging, misalnya dengan menggunakan dependensi spring-boot-starter yang mencakup spring-boot-starter-logging.

3. Gunakan Pencegat

Saya akan membiarkan Anda membaca proposal, proposal tandingan, dan mendapat jawaban di jawaban dan komentar lainnya dan memutuskan sendiri apakah Anda ingin menempuh jalan itu.

4. Log URL dan Status Respons tanpa Badan

Meskipun ini tidak memenuhi persyaratan yang disebutkan untuk mencatat badan, itu adalah cara yang cepat dan sederhana untuk mulai mencatat panggilan REST Anda. Ini menampilkan URL lengkap dan status respons.

Cukup tambahkan baris berikut ke application.propertiesfile Anda (dengan asumsi Anda menggunakan Spring Boot, dan dengan asumsi Anda menggunakan dependensi starter boot spring yang mencakup spring-boot-starter-logging)

logging.level.org.springframework.web.client.RestTemplate = DEBUG

Outputnya akan terlihat seperti ini:

2019-07-29 11:53:50.265 DEBUG o.s.web.client.RestTemplate : HTTP GET http://www.myrestservice.com/Endpoint?myQueryParam=myValue
2019-07-29 11:53:50.276 DEBUG o.s.web.client.RestTemplate : Accept=[application/json]
2019-07-29 11:53:50.584 DEBUG o.s.web.client.RestTemplate : Response 200 OK
2019-07-29 11:53:50.585 DEBUG o.s.web.client.RestTemplate : Reading to [org.mynamespace.MyJsonModelClass]

Selain pencatatan HttpClient yang dijelaskan dalam jawaban lain , Anda juga dapat memperkenalkan ClientHttpRequestInterceptor yang membaca isi permintaan dan respons serta mencatatnya. Anda mungkin ingin melakukan ini jika hal-hal lain juga menggunakan HttpClient, atau jika Anda menginginkan format log kustom. Perhatian: Anda ingin memberikan RestTemplate BufferingClientHttpRequestFactory sehingga Anda dapat membaca responsnya dua kali.

Seperti yang dinyatakan dalam respons lain, badan respons membutuhkan perlakuan khusus sehingga dapat dibaca berulang kali (secara default, isinya dikonsumsi pada pembacaan pertama).

Alih-alih menggunakan BufferingClientHttpRequestFactorysaat mengatur permintaan, pencegat itu sendiri dapat membungkus respons dan memastikan konten dipertahankan dan dapat dibaca berulang kali (oleh logger serta oleh konsumen respons):

Pencegat saya, yang

• buffer tubuh respon menggunakan pembungkus
• log dengan cara yang lebih kompak
• mencatat pengidentifikasi kode status juga (mis. 201 Dibuat)
• termasuk nomor urut permintaan yang memungkinkan untuk dengan mudah membedakan entri log bersamaan dari beberapa utas

Kode:

public class LoggingInterceptor implements ClientHttpRequestInterceptor {

    private final Logger log = LoggerFactory.getLogger(getClass());
    private AtomicInteger requestNumberSequence = new AtomicInteger(0);

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        int requestNumber = requestNumberSequence.incrementAndGet();
        logRequest(requestNumber, request, body);
        ClientHttpResponse response = execution.execute(request, body);
        response = new BufferedClientHttpResponse(response);
        logResponse(requestNumber, response);
        return response;
    }

    private void logRequest(int requestNumber, HttpRequest request, byte[] body) {
        if (log.isDebugEnabled()) {
            String prefix = requestNumber + " > ";
            log.debug("{} Request: {} {}", prefix, request.getMethod(), request.getURI());
            log.debug("{} Headers: {}", prefix, request.getHeaders());
            if (body.length > 0) {
                log.debug("{} Body: \n{}", prefix, new String(body, StandardCharsets.UTF_8));
            }
        }
    }

    private void logResponse(int requestNumber, ClientHttpResponse response) throws IOException {
        if (log.isDebugEnabled()) {
            String prefix = requestNumber + " < ";
            log.debug("{} Response: {} {} {}", prefix, response.getStatusCode(), response.getStatusCode().name(), response.getStatusText());
            log.debug("{} Headers: {}", prefix, response.getHeaders());
            String body = StreamUtils.copyToString(response.getBody(), StandardCharsets.UTF_8);
            if (body.length() > 0) {
                log.debug("{} Body: \n{}", prefix, body);
            }
        }
    }

    /**
     * Wrapper around ClientHttpResponse, buffers the body so it can be read repeatedly (for logging & consuming the result).
     */
    private static class BufferedClientHttpResponse implements ClientHttpResponse {

        private final ClientHttpResponse response;
        private byte[] body;

        public BufferedClientHttpResponse(ClientHttpResponse response) {
            this.response = response;
        }

        @Override
        public HttpStatus getStatusCode() throws IOException {
            return response.getStatusCode();
        }

        @Override
        public int getRawStatusCode() throws IOException {
            return response.getRawStatusCode();
        }

        @Override
        public String getStatusText() throws IOException {
            return response.getStatusText();
        }

        @Override
        public void close() {
            response.close();
        }

        @Override
        public InputStream getBody() throws IOException {
            if (body == null) {
                body = StreamUtils.copyToByteArray(response.getBody());
            }
            return new ByteArrayInputStream(body);
        }

        @Override
        public HttpHeaders getHeaders() {
            return response.getHeaders();
        }
    }
}

Konfigurasi:

 @Bean
    public RestTemplateBuilder restTemplateBuilder() {
        return new RestTemplateBuilder()
                .additionalInterceptors(Collections.singletonList(new LoggingInterceptor()));
    }

Contoh keluaran log:

2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 >  Request: POST http://localhost:53969/payment/v4/private/payment-lists/10022/templates
2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 >  Headers: {Accept=[application/json, application/json], Content-Type=[application/json;charset=UTF-8], Content-Length=[986]}
2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 >  Body: 
{"idKey":null, ...}
2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 <  Response: 200 OK 
2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 <  Headers: {Content-Type=[application/json;charset=UTF-8], Transfer-Encoding=[chunked], Date=[Mon, 08 Oct 2018 08:58:53 GMT]}
2018-10-08 10:58:53 [main] DEBUG x.y.z.LoggingInterceptor - 2 <  Body: 
{ "idKey" : "10022", ...  }

properti aplikasi

logging.level.org.springframework.web.client=DEBUG

application.yml

logging:
  level:  
    root: WARN
    org.springframework.web.client: DEBUG

Ini mungkin bukan cara yang benar untuk melakukannya, tetapi saya pikir ini adalah pendekatan paling sederhana untuk mencetak permintaan dan tanggapan tanpa mengisi terlalu banyak dalam log.

Dengan menambahkan di bawah 2 baris application.properties mencatat semua permintaan dan tanggapan baris ke-1 untuk mencatat permintaan dan baris ke-2 untuk mencatat respons.

logging.level.org.springframework.web.client.RestTemplate=DEBUG
logging.level.org.springframework.web.servlet.mvc.method.annotation.HttpEntityMethodProcessor=DEBUG

Asumsi RestTemplateyang dikonfigurasi untuk menggunakan HttpClient 4.x, Anda dapat membaca tentang dokumentasi logging HttpClient ini di sini . Para penebang berbeda dari yang ditentukan dalam jawaban lainnya.

Konfigurasi logging untuk HttpClient 3.x tersedia di sini .

Begitu banyak respons di sini yang membutuhkan perubahan koding dan kelas khusus dan itu benar-benar tidak perlu. Gte proxy debugging seperti fiddler dan atur lingkungan java Anda untuk menggunakan proxy pada baris perintah (-Dhttp.proxyHost dan -Dhttp.proxyPort) kemudian jalankan fiddler dan Anda dapat melihat permintaan dan respons secara keseluruhan. Juga hadir dengan banyak keuntungan tambahan seperti kemampuan untuk mengotak-atik hasil dan tanggapan sebelum dan setelah mereka dikirim untuk menjalankan percobaan sebelum melakukan modifikasi server.

Bit terakhir dari masalah yang dapat muncul adalah jika Anda harus menggunakan HTTPS, Anda harus mengekspor sertifikat SSL dari fiddler dan mengimpornya ke petunjuk java keystore (cacerts): kata sandi java keystore default biasanya "changeit".

Untuk masuk ke Logback dengan bantuan dari Apache HttpClient:

Anda membutuhkan Apache HttpClient di classpath:

<dependency>
  <groupId>org.apache.httpcomponents</groupId>
  <artifactId>httpclient</artifactId>
  <version>4.5.10</version>
</dependency>

Konfigurasikan Anda RestTemplateuntuk menggunakan HttpClient:

restTemplate.setRequestFactory(new HttpComponentsClientHttpRequestFactory());

Untuk mencatat permintaan dan tanggapan, tambahkan ke file konfigurasi Logback:

<logger name="org.apache.http.wire" level="DEBUG"/>

Atau untuk lebih masuk:

<logger name="org.apache.http" level="DEBUG"/>

Trik mengonfigurasi Anda RestTemplatedengan a BufferingClientHttpRequestFactorytidak berfungsi jika Anda menggunakan apa pun ClientHttpRequestInterceptor, yang akan Anda lakukan jika Anda mencoba masuk melalui pencegat. Ini karena cara yang InterceptingHttpAccessor(yang RestTemplatesubclass) bekerja.

Singkat cerita ... cukup gunakan kelas ini sebagai pengganti RestTemplate(perhatikan ini menggunakan API logging SLF4J, edit seperlunya):

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;

import javax.annotation.PostConstruct;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpRequest;
import org.springframework.http.HttpStatus;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.RestTemplate;

/**
 * A {@link RestTemplate} that logs every request and response.
 */
public class LoggingRestTemplate extends RestTemplate {

    // Bleh, this class is not public
    private static final String RESPONSE_WRAPPER_CLASS = "org.springframework.http.client.BufferingClientHttpResponseWrapper";

    private Logger log = LoggerFactory.getLogger(this.getClass());

    private boolean hideAuthorizationHeaders = true;
    private Class<?> wrapperClass;
    private Constructor<?> wrapperConstructor;

    /**
     * Configure the logger to log requests and responses to.
     *
     * @param log log destination, or null to disable
     */
    public void setLogger(Logger log) {
        this.log = log;
    }

    /**
     * Configure the logger to log requests and responses to by name.
     *
     * @param name name of the log destination, or null to disable
     */
    public void setLoggerName(String name) {
        this.setLogger(name != null ? LoggerFactory.getLogger(name) : null);
    }

    /**
     * Configure whether to hide the contents of {@code Authorization} headers.
     *
     * <p>
     * Default true.
     *
     * @param hideAuthorizationHeaders true to hide, otherwise false
     */
    public void setHideAuthorizationHeaders(boolean hideAuthorizationHeaders) {
        this.hideAuthorizationHeaders = hideAuthorizationHeaders;
    }

    /**
     * Log a request.
     */
    protected void traceRequest(HttpRequest request, byte[] body) {
        this.log.debug("xmit: {} {}\n{}{}", request.getMethod(), request.getURI(), this.toString(request.getHeaders()),
          body != null && body.length > 0 ? "\n\n" + new String(body, StandardCharsets.UTF_8) : "");
    }

    /**
     * Log a response.
     */
    protected void traceResponse(ClientHttpResponse response) {
        final ByteArrayOutputStream bodyBuf = new ByteArrayOutputStream();
        HttpStatus statusCode = null;
        try {
            statusCode = response.getStatusCode();
        } catch (IOException e) {
            // ignore
        }
        String statusText = null;
        try {
            statusText = response.getStatusText();
        } catch (IOException e) {
            // ignore
        }
        try (final InputStream input = response.getBody()) {
            byte[] b = new byte[1024];
            int r;
            while ((r = input.read(b)) != -1)
                bodyBuf.write(b, 0, r);
        } catch (IOException e) {
            // ignore
        }
        this.log.debug("recv: {} {}\n{}{}", statusCode, statusText, this.toString(response.getHeaders()),
          bodyBuf.size() > 0 ? "\n\n" + new String(bodyBuf.toByteArray(), StandardCharsets.UTF_8) : "");
    }

    @PostConstruct
    private void addLoggingInterceptor() {
        this.getInterceptors().add(new ClientHttpRequestInterceptor() {
            @Override
            public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution)
              throws IOException {

                // Log request
                if (LoggingRestTemplate.this.log != null && LoggingRestTemplate.this.log.isDebugEnabled())
                    LoggingRestTemplate.this.traceRequest(request, body);

                // Perform request
                ClientHttpResponse response = execution.execute(request, body);

                // Log response
                if (LoggingRestTemplate.this.log != null && LoggingRestTemplate.this.log.isDebugEnabled()) {
                    final ClientHttpResponse bufferedResponse = LoggingRestTemplate.this.ensureBuffered(response);
                    if (bufferedResponse != null) {
                        LoggingRestTemplate.this.traceResponse(bufferedResponse);
                        response = bufferedResponse;
                    }
                }

                // Done
                return response;
            }
        });
    }

    private ClientHttpResponse ensureBuffered(ClientHttpResponse response) {
        try {
            if (this.wrapperClass == null)
                this.wrapperClass = Class.forName(RESPONSE_WRAPPER_CLASS, false, ClientHttpResponse.class.getClassLoader());
            if (!this.wrapperClass.isInstance(response)) {
                if (this.wrapperConstructor == null) {
                    this.wrapperConstructor = this.wrapperClass.getDeclaredConstructor(ClientHttpResponse.class);
                    this.wrapperConstructor.setAccessible(true);
                }
                response = (ClientHttpResponse)this.wrapperConstructor.newInstance(response);
            }
            return response;
        } catch (Exception e) {
            this.log.error("error creating {} instance: {}", RESPONSE_WRAPPER_CLASS, e);
            return null;
        }
    }

    private String toString(HttpHeaders headers) {
        final StringBuilder headerBuf = new StringBuilder();
        for (Map.Entry<String, List<String>> entry : headers.entrySet()) {
            if (headerBuf.length() > 0)
                headerBuf.append('\n');
            final String name = entry.getKey();
            for (String value : entry.getValue()) {
                if (this.hideAuthorizationHeaders && name.equalsIgnoreCase(HttpHeaders.AUTHORIZATION))
                    value = "[omitted]";
                headerBuf.append(name).append(": ").append(value);
            }
        }
        return headerBuf.toString();
    }
}

Saya setuju itu konyol bahwa ini membutuhkan banyak pekerjaan hanya untuk melakukan ini.

Menambahkan ke diskusi di atas ini hanya merupakan skenario Selamat. mungkin Anda tidak akan dapat mencatat respons jika terjadi kesalahan .

Dalam hal ini ditambah semua kasus di atas Anda harus menimpa DefaultResponseErrorHandler dan mengaturnya seperti di bawah ini

restTemplate.setErrorHandler(new DefaultResponseErrorHandlerImpl());

Anehnya, tidak ada solusi yang berfungsi karena RestTemplate tampaknya tidak mengembalikan respons pada beberapa kesalahan 500x klien dan server. Dalam hal ini, Anda harus mencatatnya juga dengan menerapkan ResponseErrorHandler sebagai berikut. Berikut adalah konsep kode, tetapi Anda mendapatkan intinya:

Anda dapat mengatur interseptor yang sama dengan penangan kesalahan:

restTemplate.getInterceptors().add(interceptor);
restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
restTemplate.setErrorHandler(interceptor);

Dan intersep mengimplementasikan kedua antarmuka:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpRequest;
import org.springframework.http.HttpStatus.Series;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.web.client.DefaultResponseErrorHandler;
import org.springframework.web.client.ResponseErrorHandler;

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor, ResponseErrorHandler {
    static final Logger log = LoggerFactory.getLogger(LoggingRequestInterceptor.class);
    static final DefaultResponseErrorHandler defaultResponseErrorHandler = new DefaultResponseErrorHandler();
    final Set<Series> loggableStatuses = new HashSet();

    public LoggingRequestInterceptor() {
    }

    public LoggingRequestInterceptor(Set<Series> loggableStatuses) {
        loggableStatuses.addAll(loggableStatuses);
    }

    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        this.traceRequest(request, body);
        ClientHttpResponse response = execution.execute(request, body);
        if(response != null) {
            this.traceResponse(response);
        }

        return response;
    }

    private void traceRequest(HttpRequest request, byte[] body) throws IOException {
        log.debug("===========================request begin================================================");
        log.debug("URI         : {}", request.getURI());
        log.debug("Method      : {}", request.getMethod());
        log.debug("Headers     : {}", request.getHeaders());
        log.debug("Request body: {}", new String(body, "UTF-8"));
        log.debug("==========================request end================================================");
    }

    private void traceResponse(ClientHttpResponse response) throws IOException {
        if(this.loggableStatuses.isEmpty() || this.loggableStatuses.contains(response.getStatusCode().series())) {
            StringBuilder inputStringBuilder = new StringBuilder();

            try {
                BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), "UTF-8"));

                for(String line = bufferedReader.readLine(); line != null; line = bufferedReader.readLine()) {
                    inputStringBuilder.append(line);
                    inputStringBuilder.append('\n');
                }
            } catch (Throwable var5) {
                log.error("cannot read response due to error", var5);
            }

            log.debug("============================response begin==========================================");
            log.debug("Status code  : {}", response.getStatusCode());
            log.debug("Status text  : {}", response.getStatusText());
            log.debug("Headers      : {}", response.getHeaders());
            log.debug("Response body: {}", inputStringBuilder.toString());
            log.debug("=======================response end=================================================");
        }

    }

    public boolean hasError(ClientHttpResponse response) throws IOException {
        return defaultResponseErrorHandler.hasError(response);
    }

    public void handleError(ClientHttpResponse response) throws IOException {
        this.traceResponse(response);
        defaultResponseErrorHandler.handleError(response);
    }
}

Seperti @MilacH tunjukkan, ada kesalahan dalam implementasi. Jika statusCode> 400 dikembalikan, IOException dilemparkan, karena errorHandler tidak dipanggil, dari interseptor. Pengecualian dapat diabaikan dan kemudian ditangkap lagi dalam metode handler.

package net.sprd.fulfillment.common;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.HttpRequest;
import org.springframework.http.client.ClientHttpRequestExecution;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.ClientHttpResponse;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import static java.nio.charset.StandardCharsets.UTF_8;

public class LoggingRequestInterceptor implements ClientHttpRequestInterceptor {

    final static Logger log = LoggerFactory.getLogger(LoggingRequestInterceptor.class);

    @SuppressWarnings("HardcodedLineSeparator")
    public static final char LINE_BREAK = '\n';

    @Override
    public ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        try {
            traceRequest(request, body);
        } catch (Exception e) {
            log.warn("Exception in LoggingRequestInterceptor while tracing request", e);
        }

        ClientHttpResponse response = execution.execute(request, body);

        try {
            traceResponse(response);
        } catch (IOException e) {
            // ignore the exception here, as it will be handled by the error handler of the restTemplate
            log.warn("Exception in LoggingRequestInterceptor", e);
        }
        return response;
    }

    private void traceRequest(HttpRequest request, byte[] body) {
        log.info("===========================request begin================================================");
        log.info("URI         : {}", request.getURI());
        log.info("Method      : {}", request.getMethod());
        log.info("Headers     : {}", request.getHeaders());
        log.info("Request body: {}", new String(body, UTF_8));
        log.info("==========================request end================================================");
    }

    private void traceResponse(ClientHttpResponse response) throws IOException {
        StringBuilder inputStringBuilder = new StringBuilder();
        try (BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(response.getBody(), UTF_8))) {
            String line = bufferedReader.readLine();
            while (line != null) {
                inputStringBuilder.append(line);
                inputStringBuilder.append(LINE_BREAK);
                line = bufferedReader.readLine();
            }
        }

        log.info("============================response begin==========================================");
        log.info("Status code  : {}", response.getStatusCode());
        log.info("Status text  : {}", response.getStatusText());
        log.info("Headers      : {}", response.getHeaders());
        log.info("Response body: {}", inputStringBuilder);
        log.info("=======================response end=================================================");
    }

}

Solusi terbaik sekarang, tambahkan saja ketergantungan:

<dependency>
  <groupId>com.github.zg2pro</groupId>
  <artifactId>spring-rest-basis</artifactId>
  <version>v.x</version>
</dependency>

Ini berisi kelas LoggingRequestInterceptor yang bisa Anda tambahkan ke RestTemplate Anda:

mengintegrasikan utilitas ini dengan menambahkannya sebagai pencegat ke pegas RestTemplate, dengan cara berikut:

restTemplate.setRequestFactory(LoggingRequestFactoryFactory.build());

dan tambahkan implementasi slf4j ke kerangka kerja Anda seperti log4j.

atau langsung menggunakan "Zg2proRestTemplate" . "Jawaban terbaik" oleh @PaulSabou tampak begitu, karena httpclient dan semua lib apache.http tidak selalu dimuat saat menggunakan spring RestTemplate.

Ingin menambahkan implementasi saya ini juga. Saya minta maaf untuk semua semi-titik dua yang hilang, ini ditulis dalam Groovy.

Saya membutuhkan sesuatu yang lebih dapat dikonfigurasi daripada jawaban yang diterima. Inilah kacang templat sisa yang sangat gesit dan akan mencatat semuanya seperti yang dicari OP.

Kelas Interceptor Penebangan Kustom:

import org.springframework.http.HttpRequest
import org.springframework.http.client.ClientHttpRequestExecution
import org.springframework.http.client.ClientHttpRequestInterceptor
import org.springframework.http.client.ClientHttpResponse
import org.springframework.util.StreamUtils

import java.nio.charset.Charset

class HttpLoggingInterceptor implements ClientHttpRequestInterceptor {

    private final static Logger log = LoggerFactory.getLogger(HttpLoggingInterceptor.class)

    @Override
    ClientHttpResponse intercept(HttpRequest request, byte[] body, ClientHttpRequestExecution execution) throws IOException {
        logRequest(request, body)
        ClientHttpResponse response = execution.execute(request, body)
        logResponse(response)
        return response
    }

    private void logRequest(HttpRequest request, byte[] body) throws IOException {
        if (log.isDebugEnabled()) {
            log.debug("===========================request begin================================================")
            log.debug("URI         : {}", request.getURI())
            log.debug("Method      : {}", request.getMethod())
            log.debug("Headers     : {}", request.getHeaders())
            log.debug("Request body: {}", new String(body, "UTF-8"))
            log.debug("==========================request end================================================")
        }
    }

    private void logResponse(ClientHttpResponse response) throws IOException {
        if (log.isDebugEnabled()) {
            log.debug("============================response begin==========================================")
            log.debug("Status code  : {}", response.getStatusCode())
            log.debug("Status text  : {}", response.getStatusText())
            log.debug("Headers      : {}", response.getHeaders())
            log.debug("Response body: {}", StreamUtils.copyToString(response.getBody(), Charset.defaultCharset()))
            log.debug("=======================response end=================================================")
        }
    }
}

Definisi Bean Templat Tempel:

@Bean(name = 'myRestTemplate')
RestTemplate myRestTemplate(RestTemplateBuilder builder) {

    RequestConfig requestConfig = RequestConfig.custom()
            .setConnectTimeout(10 * 1000) // 10 seconds
            .setSocketTimeout(300 * 1000) // 300 seconds
            .build()

    PoolingHttpClientConnectionManager connectionManager = new PoolingHttpClientConnectionManager()
    connectionManager.setMaxTotal(10)
    connectionManager.closeIdleConnections(5, TimeUnit.MINUTES)

    CloseableHttpClient httpClient = HttpClients.custom()
            .setConnectionManager(connectionManager)
            .setDefaultRequestConfig(requestConfig)
            .disableRedirectHandling()
            .build()

    RestTemplate restTemplate = builder
            .rootUri("https://domain.server.com")
            .basicAuthorization("username", "password")
            .requestFactory(new BufferingClientHttpRequestFactory(new HttpComponentsClientHttpRequestFactory(httpClient)))
            .interceptors(new HttpLoggingInterceptor())
            .build()

    return restTemplate
}

Penerapan:

@Component
class RestService {

    private final RestTemplate restTemplate
    private final static Logger log = LoggerFactory.getLogger(RestService.class)

    @Autowired
    RestService(
            @Qualifier("myRestTemplate") RestTemplate restTemplate
    ) {
        this.restTemplate = restTemplate
    }

    // add specific methods to your service that access the GET and PUT methods

    private <T> T getForObject(String path, Class<T> object, Map<String, ?> params = [:]) {
        try {
            return restTemplate.getForObject(path, object, params)
        } catch (HttpClientErrorException e) {
            log.warn("Client Error (${path}): ${e.responseBodyAsString}")
        } catch (HttpServerErrorException e) {
            String msg = "Server Error (${path}): ${e.responseBodyAsString}"
            log.error(msg, e)
        } catch (RestClientException e) {
            String msg = "Error (${path})"
            log.error(msg, e)
        }
        return null
    }

    private <T> T putForObject(String path, T object) {
        try {
            HttpEntity<T> request = new HttpEntity<>(object)
            HttpEntity<T> response = restTemplate.exchange(path, HttpMethod.PUT, request, T)
            return response.getBody()
        } catch (HttpClientErrorException e) {
            log.warn("Error (${path}): ${e.responseBodyAsString}")
        } catch (HttpServerErrorException e) {
            String msg = "Error (${path}): ${e.responseBodyAsString}"
            log.error(msg, e)
        } catch (RestClientException e) {
            String msg = "Error (${path})"
            log.error(msg, e)
        }
        return null
    }
}