Okhttp拦截器统一异常处理并多次读取response.body().string()

参考：https://blog.csdn.net/a624806998/article/details/73863606

引言： 写这篇文章，因为在自己编写实现Http日志拦截器的时候，在拦截器中使用 response.body().string() 获取了返回的数据，但是在经过拦截器后，针对输出处理的时候，会再次调用 response.body().string()，这里就会导致流已关闭的异常。

参考上面的链接，修改了在拦截器中的response中的数据获取。保证了下一步的输出流的处理获取操作。

下面的就是能使用的的Http拦截器代码

package com.ztkj.common.log.interceptors;

import com.alibaba.fastjson.JSON;
import com.ztkj.common.log.aspect.bean.HttpHandlerBean;
import com.ztkj.common.log.aspect.bean.LinkTrackingBean;
import com.ztkj.common.log.aspect.threadlocals.LinkTrackingThreadLocal;
import okhttp3.*;
import okio.Buffer;
import okio.BufferedSource;
import org.apache.commons.lang3.exception.ExceptionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.EOFException;
import java.io.IOException;
import java.net.URLDecoder;
import java.nio.charset.Charset;
import java.nio.charset.UnsupportedCharsetException;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * okhttp 拦截器定义: 统计请求信息以及耗时
 *
 * @author hzb-ztkj
 */
public class HttpLogInterceptor implements Interceptor {

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

    private static final Charset UTF8 = Charset.forName("UTF-8");

    /**
     * 拦截过程中 收集 http请求输入、输出等信息，日志输出打印
     *
     * @param chain
     * @return
     * @throws IOException
     */
    @Override
    public Response intercept(Chain chain) throws IOException {

        //获取当前请求
        Request request = chain.request();

        //根据请求类型分析
        HttpHandlerBean httpHandlerBean = new HttpHandlerBean();

        //从http request中获取请求信息
        httpHandlerBean.setUrl(request.url().toString());

        //设置请求头信息
        Headers headers = request.headers();
        Map<String, List<String>> stringListMap = headers.toMultimap();
        httpHandlerBean.setParamHeaderStr(JSON.toJSONString(stringListMap));

        //设置请求body信息
        RequestBody requestBody = request.body();
        if (requestBody != null) {
            httpHandlerBean.setParamStr(getParam(requestBody));
        }

        //设置请求方式
        httpHandlerBean.setRequestMode(request.method());

        Response response = null;
        try {
            response = chain.proceed(request);

            //设置状态码
            httpHandlerBean.setCode(response.code() + "");

            //设置响应头信息
            Map<String, List<String>> responseHeaderMap = response.headers().toMultimap();
            httpHandlerBean.setResultHeaderStr(JSON.toJSONString(responseHeaderMap));

            //设置响应信息
            ResponseBody responseBody = response.body();
            if (responseBody != null) {
                //httpHandlerBean.setResultStr(JSON.toJSONString(responseBody.string()));
                httpHandlerBean.setResultStr(getResponseBody(responseBody));
            }

            //设置用时信息
            httpHandlerBean.setSendTime(response.sentRequestAtMillis());
            httpHandlerBean.setReceiveTime(response.receivedResponseAtMillis());

            //设置唯一性id
            LinkTrackingBean linkTrackingBean = LinkTrackingThreadLocal.get();
            if (linkTrackingBean == null) {
                httpHandlerBean.setRequestId(UUID.randomUUID().toString());
            } else {
                httpHandlerBean.setRequestId(linkTrackingBean.getRequestId());
                httpHandlerBean.setUserId(linkTrackingBean.getUserId());
                httpHandlerBean.setProductId(linkTrackingBean.getProductId());
            }

            //响应消息
            httpHandlerBean.setMessage(response.message());


        } catch (Exception e) {
            logger.error("处理请求异常，异常原因:{}", ExceptionUtils.getStackTrace(e));
            httpHandlerBean.setMessage(ExceptionUtils.getStackTrace(e));
        }


        //输出，打印日志
        logger.info(httpHandlerBean.httpLogPrint());

        return response;
    }


    private String getResponseBody(ResponseBody responseBody) throws Exception {
        BufferedSource source = responseBody.source();
        source.request(Long.MAX_VALUE);
        Buffer buffer = source.buffer();

        Charset charset = UTF8;
        MediaType contentType = responseBody.contentType();
        if (contentType != null) {
            try {
                charset = contentType.charset(UTF8);
            } catch (UnsupportedCharsetException e) {
                logger.error("将http数据写入流异常,异常原因：{}", ExceptionUtils.getStackTrace(e));
            }
        }

        if (!isPlaintext(buffer)) {
            return null;
        }

        if (responseBody.contentLength() != 0) {
            String result = buffer.clone().readString(charset);
            return result;
        }
        return null;
    }


    private boolean isPlaintext(Buffer buffer) throws EOFException {
        try {
            Buffer prefix = new Buffer();
            long byteCount = buffer.size() < 64 ? buffer.size() : 64;
            buffer.copyTo(prefix, 0, byteCount);
            for (int i = 0; i < 16; i++) {
                if (prefix.exhausted()) {
                    break;
                }
                int codePoint = prefix.readUtf8CodePoint();
                if (Character.isISOControl(codePoint) && !Character.isWhitespace(codePoint)) {
                    return false;
                }
            }
            return true;
        } catch (EOFException e) {
            return false;
        }
    }


    /**
     * 读取参数
     *
     * @param requestBody
     * @return
     */
    private String getParam(RequestBody requestBody) {
        Buffer buffer = new Buffer();
        String logparm;
        try {
            requestBody.writeTo(buffer);
            logparm = buffer.readUtf8();
            logparm = URLDecoder.decode(logparm, "utf-8");
        } catch (IOException e) {
            e.printStackTrace();
            return "";
        }
        return logparm;
    }
}