拦截http请求打印入参出参（Okhttp3拦截器）

最新推荐文章于 2024-02-17 09:19:01 发布
最新推荐文章于 2024-02-17 09:19:01 发布
阅读量2.9k 收藏 2
点赞数
分类专栏： 工具类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/fajing_feiyue/article/details/121580528
版权

前言

我们应用中经常出现请求其他三方接口，这也是经常会出错，找当时请求参数，返回结果比对的情况。如果自己加打印，很多时候会忘记。这里通过对Okhttp工具添加拦截器方式，将需要入参出参进行打印。

实践

一、引入maven 依赖

 <dependency>
            <groupId>com.squareup.okhttp3</groupId>
            <artifactId>okhttp</artifactId>
            <version>3.10.0</version>
        </dependency>

二、创建日志拦截器

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.TimeInterval;
import okhttp3.*;
import okio.Buffer;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

/**
 * @author Administrator
 */
public class LoggingInterceptor implements Interceptor {

    private Logger logger = LoggerFactory.getLogger(LoggingInterceptor.class);



    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        logForRequest(request);
        TimeInterval timer = DateUtil.timer();
        Response response =  chain.proceed(request);
        return logForResponse(response, timer);
    }

    private Response logForResponse(Response response, TimeInterval timer) {
        try {
            Response.Builder builder = response.newBuilder();
            Response clone = builder.build();
            logger.info("=========repose==log==start======");
            logger.info(String.format("repose url:%s,code:%s,time is:%s,headers:%s", clone.request().url(), clone.code(), timer.intervalMs() + "ms", clone.protocol()));

            ResponseBody body = clone.body();
            if (body != null) {
                MediaType mediaType = body.contentType();
                if (mediaType != null && isText(mediaType)) {
                    String content = body.string();
                    logger.info(String.format("message:%s,contentType:%s,content is:%s,", clone.message(), mediaType.toString(),content ));
                    body = ResponseBody.create(mediaType, content);
                    return response.newBuilder().body(body).build();
                }
            }
        } catch (Exception e) {
            logger.warn("print reponse error", e);
        }finally {
            logger.info("=========repose==log==end======");

        }
        return response;


    }

    private void logForRequest(Request request) {
        String url = request.url().toString();
        String method = request.method();
        Headers headers = request.headers();
        String headerStr = headers != null && headers.size() > 0 ? headers.toString() : "";
        logger.info("=========request==log==start======");
        logger.info(String.format("request url:%s,method:%s,headers:%s", url, method, headerStr));
        RequestBody requestBody = request.body();
        if (requestBody != null) {
            MediaType mediaType = requestBody.contentType();
            if (mediaType != null && isText(mediaType)) {
                logger.info("requestBody mediaType:%s,bodyToString:%s", mediaType.toString(), bodyToString(request));
            }
        }
        logger.info("=========request==log==end======");
    }

    private String bodyToString(final Request request) {
        final Request copy = request.newBuilder().build();
        final Buffer buffer=new Buffer();
        try {
            copy.body().writeTo(buffer);
        } catch (IOException e) {
            return "something error,when show requestBody";
        }
        return buffer.readUtf8();
    }


    private boolean isText(MediaType mediaType) {
        if (mediaType.type() != null && mediaType.type().equals("text")) {
            return true;
        }
        if (mediaType.subtype() != null) {
            if (mediaType.subtype().equals("json") ||
                    mediaType.subtype().equals("xml") ||
                    mediaType.subtype().equals("html") ||
                    mediaType.subtype().equals("webviewhtml")) {
                return true;
            }
        }
        return false;
    }
}

三、使用Okhttp 工具类添加拦截器

package com.yin.common.util;

import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

public class OkHttpClientUtil {

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

    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
    public static OkHttpClient client;
    static {
        client = new OkHttpClient.Builder()
                .readTimeout(20000, TimeUnit.MILLISECONDS)
                .writeTimeout(20000, TimeUnit.MILLISECONDS)
                .connectTimeout(20000, TimeUnit.MILLISECONDS)
                .addInterceptor(new LoggingInterceptor())
                .build();
    }



    public static final String doUpload(Map<String, String> params, Map<String, String> headerParam,
                                        final Map<String, File> fileMap, String mediaTypeStr, String url) {
        Response response = null;
        try {
            if (StringUtils.isEmpty(url)) {
                return null;
            }

            if (StringUtils.isEmpty(mediaTypeStr)) {
                mediaTypeStr = "application/octet-stream";
            }
            MediaType mediaType = MediaType.parse(mediaTypeStr);
            MultipartBody.Builder multipartBody = new MultipartBody.Builder().setType(MultipartBody.FORM);


            for (Map.Entry<String, File> fileEntry : fileMap.entrySet()) {
                File file = fileEntry.getValue();
                RequestBody fileBody = MultipartBody.create(mediaType, file);
                multipartBody.addFormDataPart(fileEntry.getKey(), file.getName(), fileBody);
            }
            if (!Objects.isNull(params) && params.size() > 0) {
                for (Map.Entry<String, String> entry : params.entrySet()) {
                    multipartBody.addFormDataPart(entry.getKey(), entry.getValue());
                }
            }
            MultipartBody requestBody = multipartBody.build();
            Request.Builder builder = new Request.Builder();
            if (!Objects.isNull(headerParam) && headerParam.size() > 0) {
                for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                    builder.addHeader(entry.getKey(), entry.getValue());
                }
            }
            Request request = builder.post(requestBody).url(url).build();
            response= client.newCall(request).execute();
            if (response.isSuccessful()) {
                return new String(response.body().bytes());
            }else {
                logger.error("[{}] having a error，param is:{}",url,String.valueOf(params));
            }
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }finally {
            if (!Objects.isNull(response)) {
                response.close();
            }
        }
        return "";
    }






    /**
     * get 请求
     * @param url       请求url地址
     * @return string
     * */
    public static String doGet(String url) {
        return doGet(url, null, null);
    }


    /**
     * get 请求
     * @param url       请求url地址
     * @param params    请求参数 map
     * @return string
     * */
    public String doGet(String url, Map<String, String> params) {
        return doGet(url, params, null);
    }




    /**
     * get 请求
     *
     * @param url     请求url地址
     * @param params  请求参数 map
     * @param headerMap 请求头字段
     * @return string
     */
    public static String doGet(String url, Map<String, String> params, Map<String, String> headerMap) {

        StringBuilder sb = new StringBuilder(url);
        if (params != null && params.keySet().size() > 0) {
            boolean firstFlag = true;
            for (String key : params.keySet()) {
                if (firstFlag) {
                    sb.append("?").append(key).append("=").append(params.get(key));
                    firstFlag = false;
                } else {
                    sb.append("&").append(key).append("=").append(params.get(key));
                }
            }
        }

        Request.Builder builder = new Request.Builder();
        if (headerMap != null && headerMap.size() > 0) {
            for (Map.Entry<String, String> entry : headerMap.entrySet()) {
                builder.addHeader(entry.getKey(), entry.getValue());
            }
        }

        Request request = builder.url(sb.toString()).build();
        return execute(request);
    }

    /**
     * post 请求
     *
     * @param url    请求url地址
     * @param params 请求参数 map
     * @return string
     */
    public static String doPost(String url, Map<String, String> params, Map<String, String> headerParam) {

        FormBody formBody =addParamToBuilder(params);

        Request.Builder request = buildHeader(headerParam);

        Request buildRequest = request.post(formBody).url(url).build();

        return execute(buildRequest);
    }

    public static String doPut(String url, Map<String, String> params, Map<String, String> headerParam) {

        FormBody formBody =addParamToBuilder(params);

        Request.Builder request = buildHeader(headerParam);

        Request buildRequest = request.put(formBody).url(url).build();
        return execute(buildRequest);
    }

    public static String doDelete(String url, Map<String, String> params, Map<String, String> headerParam) {

        FormBody formBody =addParamToBuilder(params);

        Request.Builder request = buildHeader(headerParam);

        Request buildRequest = request.delete(formBody).url(url).build();
        logger.info("do delete request and url[{}]", url);
        return execute(buildRequest);
    }


    private static FormBody addParamToBuilder(Map<String, String> params){
        FormBody.Builder builder = new FormBody.Builder();

        if (params != null && params.keySet().size() > 0) {
            for (String key : params.keySet()) {
                builder.add(key, params.get(key));
            }
        }

        return builder.build();
    }

    private static  Request.Builder buildHeader(Map<String, String> headerParam){
        Request.Builder request = new Request.Builder();
        if (!Objects.isNull(headerParam) && headerParam.size() > 0) {
            for (Map.Entry<String, String> entry : headerParam.entrySet()) {
                request.addHeader(entry.getKey(), entry.getValue());
            }
        }
        return request;
    }
    /**
     * post 请求, 请求数据为 json 的字符串
     * @param url       请求url地址
     * @param json      请求数据, json 字符串
     * @return string
     */
    public static String doPostJson(String url,Map<String,String> headermap, String json) {
        return exectePost(url, json,headermap, JSON);
    }

    public static String doPutJson(String url, Map<String,String> headermap, String json) {
        return exectePut(url, json,headermap, JSON);
    }

    public static String doDeleteJson(String url, Map<String,String> headermap, String json) {
        return execteDelete(url, json,headermap, JSON);
    }



    private static String exectePost(String url, String data,Map<String,String> headerMap, MediaType contentType) {
        RequestBody requestBody = RequestBody.create(contentType, data);
        Request.Builder builder = buildHeader(headerMap);
        Request request = builder.post(requestBody).url(url).build();
        return execute(request);
    }

    private static String exectePut(String url, String data,Map<String,String> headerMap, MediaType contentType) {
        RequestBody requestBody = RequestBody.create(contentType, data);
        Request.Builder builder = buildHeader(headerMap);
        Request request = builder.put(requestBody).url(url).build();
        return execute(request);
    }

    private static String execteDelete(String url, String data, Map<String,String> headerMap,MediaType contentType) {
        RequestBody requestBody = RequestBody.create(contentType, data);
        Request.Builder builder = buildHeader(headerMap);
        Request request = builder.delete(requestBody).url(url).build();
        return execute(request);
    }




    private static String execute(Request request) {
        Response response = null;
        try {
            response = client.newCall(request).execute();
            if (response.isSuccessful()) {
                return new String(response.body().bytes());
            }
        } catch (Exception e) {
            logger.error(e.getMessage(),e);
        } finally {
            if (response != null) {
                response.close();
            }
        }
        return "";
    }

    public static void main(String[] args) {
        Map<String, String> param = new HashMap<>();
        Map<String, String> header = new HashMap<>();
        param.put("testParam","23");
        header.put("testHeader", "34");
        String s = OkHttpClientUtil.doGet("http://localhost:8028/mybatis", param, header);
        System.out.println("-----------"+s);
    }

}
筏镜
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android-OkHttp的请求拦截器实现请求拦截打印日志到logcat
08-13
OkHttp的请求拦截器，实现请求拦截，打印日志到logcat，链接已经拼接好
okhttp-awssigner:OkHttp拦截器，用于使用AWSv4签名对请求进行签名
05-01
OkHttp AWSv4 Signer拦截器 它是什么？ Square的OkHttpClient的拦截器，用于对要求签名的AWS服务的请求进行签名。 该项目旨在遵循此处描述的AWSv4签名规范： ://docs.aws.amazon.com/general/latest/gr/signature-version-4.html 动机 我找不到不依赖于整个AWS开发工具包的签名拦截器，因此我做了这个。 我的目标是减少依赖项的数量，以使其很容易包含在任何Java项目中。 用法 拦截器应包含在拦截器链的后面，以便在调用签名之前，所有标头（包括Host ）都由OkHttp设置。 < dependency>     < groupId>com.github.esiqveland.okhttp3</ groupId>     < artifactId>aws-interceptor</
JAVA面试题分享五百二十四：使用 Spring Boot + Hutool 实现 JWT Token 生成及拦截功能
最新发布
之乎者也·的博客
02-17 488
这一系列课程将包含Spring Boot 许多关键的技术和工具，包括 Mybatis-Plus、Redis、Mongodb、MinIO、Kafka、MySQL、消息队列（MQ）、OAuth2 等相关内容。使用 Spring Boot + Hutool 实现 JWT Token 生成及拦截功能在使用 Spring Boot 和 Hutool 实现 JWT Token 生成及拦截功能时，首先需要在项目中配置相关的依赖和属性。
Android 中okhttp自定义Interceptor（缓存拦截器）
01-20
Android 中okhttp自定义Interceptor（缓存拦截器） 前言： 新公司项目是没有缓存的，我的天，坑用户流量不是么。不知道有人就喜欢一个界面没事点来点去的么。怎么办？一个字“加”。 由于项目的网络请求被我换成了retrofit。而retrofit的网络请求默认基于okhttp okhttp的缓存由返回的header 来决定。如果服务器支持缓存的话返回的headers里面会有这一句 ”Cache-Control”，“max-age=time” 这里的time是一个单位为秒的时间长度。意思是缓存的时效，比如要设置这个API的缓存时效为一天 返回的header就应该是
OkHttp 源码简要分析 （Request 详解）
Deaht_Huimie的博客
10-30 733
我们知道，http 请求分为三个部分， 请求行、请求头和请求体；对应的消息也分为三个部分：响应行、响应头和响应体。以前使用 HttpURLConnection 时，我们很容易设置消息头及参数，它内部是封装了 Socket 供我们使用。补充一点，我们知道网络运输层是由 TCP 和 UDP 构成的，TCP 建立连接，安全可靠，以流传输数据，没有大小限制，速度慢；UDP 是不建立连接，每次传递数据限制在...
Kotlin实现Android网络请求
m0_56184347的博客
03-23 1737
Android中的网络请求问题Kotlin实现
阅读How Tomcat Works笔记
elsostal的博客
10-13 180
一 概述 1 Servlet容器 Servlet容器为一个Servlet请求提供服务基本要做三件事 创建request对象填充可能被servlet使用的信息，如参数、头部、cookies。一个request对象是javax.servlet.ServletRequest或javax.servlet.http.ServletRequest接口的实例 创建一个response对象给客户端发送响应，一个response对象是javax.servlet.ServletResponse或javax.servlet.h
android okhttp打印请求头_从第一次请求开始，深入探索OkHttp，你永远不可能从我这里学到东西。...
weixin_39527292的博客
12-30 497
OkHttp是Android开发中非常常用的一个网络请求库了，它支持HTTP1、HTTP2等多种协议，是我们日常开发中非常给力的帮手。本篇文章基于OkHttp4.9.0版本代码,从OkHttp的创建开始，探究OkHttp是如何发起一次网络请求的。如果你有耐心看完，相信你会对OkHttp有了一个深刻的了解。如果觉得太长不看的话，看一下总结也是不错的呢（手动滑稽）。OkHttpClient​ 使用Ok...
Android 开发之Okhttp网络请求日志打印
Runt02的博客
01-01 4248
这里写自定义目录标题Android 开发之Okhttp 网络请求日志打印OkHTTP网络日志打印 Android 开发之Okhttp 网络请求日志打印 网络请求是开发的日常工作内容之一，网络日志打印也有很多要注意及优化的部分，本文分享我在开发过程中编写的OkHttp网络请求日志打印方法实现 OkHTTP网络日志打印 直接用OKHTTP请求接口的方式 要在接口请求的回调方法内进行信息获取和打印 ，即在自定义的Callback实现类或实现对象中 public abstract class MyStringC
okhttp请求参数打印字符串RequestBody ，FormBody
glc11223344的博客
08-31 2166
Okhttp打印请求参数body，转换为字符串。
okHttp拦截器的使用
yukaihuaboke的博客
12-17 343
一般通过应用拦截器打印日志，添加公共参数,,,,,网络拦截器添加token，走缓存等。     /**      * 懒汉 安全 加同步      * 私有的静态成员变量 只声明不创建      * 私有的构造方法      * 提供返回实例的静态方法      */     private static OkHttpClient okHttpClient = null;
Android的OkHttp包中的HTTP拦截器Interceptor用法示例
09-02
拦截器是OkHttp处理HTTP请求方面所具有的一个强大特性,这里我们就来看一下Android的OkHttp包中的HTTP拦截器Interceptor用法示例,需要的朋友可以参考下
Android-OkHttp的请求重试拦截器
08-13
OkHttp的拦截器可以存储失败的请求，并将重试请求直到成功或重试次数超过限制，或请求超时时间超过限制
go语言之net/htttp包
weixin_44706011的博客
06-21 228
Go语言内置的net/http包十分的优秀，提供了HTTP客户端和服务端的实现。 net/http介绍 Go语言内置的net/http包提供了HTTP客户端和服务端的实现。 HTTP协议 超文本传输协议（HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络传输协议，所有的WWW文件都必须遵守这个标准。设计HTTP最初的目的是为了提供一种发布和接收HTML页面的方法。 package main import ( "io/ioutil" "net/http"
爬虫基础之基本库requests的使用
降温的博客
10-16 262
文章目录使用requests基本用法1.准备工作2.实例引入3.GET请求4.POST请求5.响应高级用法1.文件上传2.Cooikes3.会话维持4.SSL证书验证5.代理设置6.超时设置7.身份认证8.Prepared Request 使用requests 上一篇文章，我们了解了爬虫基础之基本库urllib的使用，但是其中有一些不方便，比如处理网页验证和Cooikes时，需要写Opener和Handler来处理。为了实现这些操作，就有了更为强大的库requests。 基本用法 1.准备工作 安装requ
OkHttp 用法及解析
夜空中最亮的星
03-03 1102
1、OkHttp介绍          OkHttp是Square公司开发的Http通用库，支持HTTP和HTTPP/2，用于Android和Java应用开发。OkHttp是一款高效的HTTP客户端，支持同一个地址的链接共享同一个socket，通过连接池来减小响应延迟，还有透明的GZIP压缩，请求缓存等优势。如果您的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个...
OKHttp3网络请求，接口处理
唐诺
09-17 918
基于OKHttp3，整理常用的请求处理方法； 1、获取Get请求的参数 private fun paramsToJson4Get(url: String): Map<String, String> { val map = mutableMapOf<String, String>() try { val uri: Uri = Uri.parse(url) for (paramName in ur.
打印完整的okhttp网络请求和响应消息
蓝不蓝编程
11-30 2708
背景 开发中，有时需要核对接口请求和响应参数，需要看到详细的接口调用。本来可以通过Facebook Stetho来监控接口的，但是受限于网络，导致调测界面打不开，所以只要寻求其他方案。 解决方案 通过okhttp添加拦截器，打印接口调用日志。 添加依赖 implementation 'com.squareup.okhttp3:logging-interceptor:3.9.1' 添加拦截器 ...
OkHttp自定义拦截器打印post请求报文
张平的专栏
12-24 2182
OkHttp自定义拦截器打印post请求报文 第一步：自定义日志拦截器 LoggingInterceptor.java public class LoggingInterceptor implements Interceptor { Context context; public LoggingInterceptor(Context mcontext) { t...
OkHttp 拦截所有的 HTTP 请求
03-07
我可以回答这个问题。OkHttp 可以通过拦截器来拦截所有的 HTTP 请求。可以使用 Interceptor 接口来实现自定义的拦截器，也可以使用 OkHttp 提供的现成的拦截器，比如 LoggingInterceptor、RetryInterceptor 等。拦截器可以用来添加请求头、打印请求日志、重试请求等操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值