Comment tracer les requêtes et les réponses Spring RestTemplate : un guide complet

Traçage des requêtes et des réponses Spring RestTemplate : un guide complet

Le débogage des requêtes et des réponses Spring RestTemplate peut être une tâche déroutante. Cet article explore une solution efficace pour surmonter ce défi, en fournissant une approche globale pour activer toutes les capacités de journalisation et de débogage.

Le besoin d'une journalisation améliorée

Contrairement à l'utilisation de curl avec le "verbose" option, Spring RestTemplate fournit souvent des informations limitées sur les détails de la demande et de la réponse. Ce manque de visibilité entrave un débogage et un dépannage efficaces.

Personnalisation avec ClientHttpRequestInterceptor

Pour résoudre ce problème, Spring Web Client et RestTemplate proposent l'interface ClientHttpRequestInterceptor. En implémentant cette interface, les développeurs peuvent personnaliser le comportement de l'instance RestTemplate, y compris la possibilité de tracer à la fois les requêtes sortantes et les réponses entrantes.

Une implémentation pratique

Pour implémenter ClientHttpRequestInterceptor, considérez ce qui suit exemple :

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 org.slf4j.Logger;
import org.slf4j.LoggerFactory;

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

}

Utilisation de l'intercepteur et du buffering

Pour utiliser l'intercepteur, instanciez le RestTemplate à l'aide d'un BufferingClientHttpRequestFactory et enregistrez le LoggingRequestInterceptor comme suit :

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

Le BufferingClientHttpRequestFactory est nécessaire pour permettre plusieurs lectures du corps de la réponse.

Conclusion

En implémentant ClientHttpRequestInterceptor, vous pouvez améliorer les capacités de débogage de Spring RestTemplate. L'exemple fourni dans cet article montre comment tracer à la fois les demandes et les réponses, fournissant ainsi des informations complètes sur le processus de communication. Cette approche simplifie le dépannage et améliore l'efficacité des tâches de développement et de maintenance.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!