okHttp 的使用

项目的通信

在开发的过程中，我们平时会面临两种通信，一种是项目之间的通信，一种是项目以外的通信。对于前者，我们通常会使用 openFeign 来解决。而项目以外的通信我们则会有 restTemplate、okHttp 以及 Retrofit 等众多通信框架。我之前也是一直使用 restTemplate，但最近接触到 okHttp 发现，用着比 restTemplate 更省心更方便一点，并且支持异步通信。这次就针对 okHttp 来简单做一下文章。

为什么选择 okHttp

从性能方面考虑，其支持 HTTP2 并且使用链接池复用资源；在实际使用方面，只需要进行一次封装，后续即可直接调用，省心省力；最后就是支持异步通信功能；这些对于日常开发完全够用了，下面直接在项目中进行演示

项目实践

引入依赖

<!--okhttp-->
<dependency>
  <groupId>com.squareup.okhttp3</groupId>
  <artifactId>okhttp</artifactId>
  <version>4.11.0</version>
</dependency>

<!--jackson 序列化对象使用-->
<dependency>
  <groupId>com.fasterxml.jackson.core</groupId>
  <artifactId>jackson-databind</artifactId>
  <version>2.15.0</version>
</dependency>

<!--引入hutool工具类包 -->
<dependency>
  <groupId>cn.hutool</groupId>
  <artifactId>hutool-all</artifactId>
  <version>5.8.16</version>
</dependency>

okHttp 工具类

这个工具类是我自己封装的一个，提供了 get、post 的请求，并在其基础上分别实现了异步的通信调用

/**
 * @Classname OkHttpUtils
 * @Description http请求工具类
 * @Date 2023/09/05 13:26
 * @Author by Sora33
 */
public class OkHttpUtils {

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

    private static final String METHOD_GET = "get";
    private static final String METHOD_POST = "post";

    private static ObjectMapper objectMapperService = SpringUtil.getBean(ObjectMapper.class);

    private static OkHttpClient okHttpClient;

    static {
        // 设置默认连接和超时时间都是5s
        OkHttpUtils.okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5L, TimeUnit.SECONDS)
                .readTimeout(5L, TimeUnit.SECONDS)
                .build();
    }


    /**
     * 发起get请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @param headersMap 请求头map
     * @return
     */
    public static String get(String URL, HashMap<String, Object> paramMap, Map<String, String> headersMap) {
        // 获取headers
        Headers headers = getHeaders(headersMap);
        // 获取参数
        String param = getParam(paramMap);
        // 拼接URL
        URL = URL + param;

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_GET);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_GET);

        return newCall(request);
    }


    /**
     * 以异步方式发起get请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @param headersMap 请求头map
     * @return
     */
    public static void getAsync(String URL, HashMap<String, Object> paramMap, Map<String, String> headersMap) {
        // 获取headers
        Headers headers = getHeaders(headersMap);
        // 获取参数
        String param = getParam(paramMap);
        // 拼接URL
        URL = URL + param;

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_GET);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_GET);

        // 发起异步调用
        newCallAsync(request);
    }


    /**
     * 发起get请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @return
     */
    public static String get(String URL, HashMap<String, Object> paramMap) {
        // 获取headers
        Headers headers = getHeaders(new HashMap<>());
        // 获取参数
        String param = getParam(paramMap);
        // 拼接URL
        URL = URL + param;

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_GET);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_GET);

        return newCall(request);
    }


    /**
     * 以异步方式发起get请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @return
     */
    public static void getAsync(String URL, HashMap<String, Object> paramMap) {
        // 获取headers
        Headers headers = getHeaders(new HashMap<>());
        // 获取参数
        String param = getParam(paramMap);
        // 拼接URL
        URL = URL + param;

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_GET);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_GET);

        // 发起异步调用
        newCallAsync(request);
    }


    /**
     * 发起post请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @param headersMap 请求头map
     * @return
     */
    public static String post(String URL, HashMap<String, Object> paramMap, Map<String, String> headersMap) {
        // 获取headers
        Headers headers = getHeaders(headersMap);
        // 创建请求body
        RequestBody body = getRequestBody(paramMap);

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_POST);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_POST,body);
        return newCall(request);
    }


    /**
     * 以异步方式发起post请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @param headersMap 请求头map
     * @return
     */
    public static void postAsync(String URL, HashMap<String, Object> paramMap, Map<String, String> headersMap) {
        // 获取headers
        Headers headers = getHeaders(headersMap);
        // 创建请求body
        RequestBody body = getRequestBody(paramMap);

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_POST);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_POST,body);

        // 发起异步调用
        newCallAsync(request);
    }


    /**
     * 发起post请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @return
     */
    public static String post(String URL, HashMap<String, Object> paramMap) {
        // 获取headers
        Headers headers = getHeaders(new HashMap<>());
        // 创建请求body
        RequestBody body = getRequestBody(paramMap);
        
        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_POST);
        
        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_POST,body);
        return newCall(request);
    }


    /**
     * 以异步方式发起post请求调用
     * @param URL 请求地址
     * @param paramMap 参数map
     * @return
     */
    public static void postAsync(String URL, HashMap<String, Object> paramMap) {
        // 获取headers
        Headers headers = getHeaders(new HashMap<>());
        // 创建请求body
        RequestBody body = getRequestBody(paramMap);

        logger.info("本次访问请求地址：[{}]，请求方式：[{}]，正在发起请求……", URL, OkHttpUtils.METHOD_POST);

        Request request = getRequest(URL, headers, OkHttpUtils.METHOD_POST,body);

        // 发起异步调用
        newCall(request);
    }


    /**
     * 获取requestBody对象
     * @param paramMap
     * @return
     */
    private static RequestBody getRequestBody(HashMap<String, Object> paramMap) {
        try {
            String value = objectMapperService.writeValueAsString(paramMap);
            return RequestBody.create(MediaType.parse("application/json"), value);
        } catch (JsonProcessingException e) {
            logger.error("json序列化出错！", e);
        }
        return RequestBody.create(MediaType.parse("application/json"),"{}");
    }


    /**
     * 获取request请求
     * @param URL
     * @param headers
     * @param method
     * @param requestBody
     * @return
     */
    private static Request getRequest(String URL, Headers headers, String method, RequestBody... requestBody) {
        if (requestBody.length > 1) {
            throw new RuntimeException("requestBody最多只允许一个！");
        }
        if (OkHttpUtils.METHOD_GET.equalsIgnoreCase(method)) {
            return new Request.Builder()
                    .get()
                    .url(URL)
                    .headers(headers)
                    .build();
        } else if (OkHttpUtils.METHOD_POST.equalsIgnoreCase(method)) {
            return new Request.Builder()
                    .post(requestBody[0])
                    .url(URL)
                    .headers(headers)
                    .build();
        }
        return new Request.Builder().build();
    }


    /**
     * 发起请求
     * @param request
     * @return
     */
    private static String newCall(Request request) {
        try(Response execute = okHttpClient.newCall(request).execute()) {
            if (execute.isSuccessful()) {
                ResponseBody body = execute.body();
                String result = body == null ? null : body.string();
                logger.info("接口请求访问成功，返回值：[{}]", result);
                return result;
            }
            logger.error("接口请求失败！错误码：[{}]", execute.code());
        } catch (IOException e) {
            logger.error("接口请求失败！失败原因：", e);
        }
        return null;
    }


    /**
     * 发起异步请求
     * @param request
     * @return
     */
    private static void newCallAsync(Request request) {
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(@NotNull Call call, @NotNull IOException e) {
                logger.error("接口请求失败！", e);
            }
            @Override
            public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
                if (response.isSuccessful()) {
                    ResponseBody body = response.body();
                    String result = body == null ? null : body.string();
                    logger.info("接口请求访问成功，返回值：[{}]", result);
                    return;
                }
                logger.error("接口请求失败！错误码：[{}]", response.code());
            }
        });
    }


    /**
     * map转为get参数
     * @param paramMap
     * @return
     */
    private static String getParam(Map<String, Object> paramMap) {
        if (paramMap.isEmpty()) {
            return "";
        }
        StringBuffer sb = new StringBuffer();
        paramMap.forEach((key, value) -> {
            sb.append("&").append(key).append("=").append(value);
        });
        return sb.toString().replaceFirst("&", "?");
    }


    /**
     * 创建并装载请求头
     *
     * @param headersMap
     * @return
     */
    private static Headers getHeaders(Map<String, String> headersMap) {
        Headers.Builder builder = new Headers.Builder();
        headersMap.forEach(builder::add);
        return builder.build();
    }
}

测试代码

下面是 get 的测试代码，我们通过远程调用的方式来访问 add 方法，并将 param 作为 id 传过去。

@GetMapping("/test/{param}")
public Result httpClient(@PathVariable("param") String param) {
  String url = "http://127.0.0.1:9999/sora/auth/http/" + param;
  HashMap<String, String> headerMap = new HashMap<>();
  headerMap.put("token", "123");
  HashMap<String, Object> paramMap = new HashMap<>();
  paramMap.put("id", param);
  String result = OkHttpUtils.get(url, paramMap,headerMap);
  logger.info("请求返回值：[{}]", result);
  return Result.success();
}

@GetMapping("/{id}")
public Result add(@PathVariable("id") String id) {
  logger.info("Get-请求参数：[{}]", id);
  return Result.success();
}

通过日志打印，我们也可以了解到接口的具体地址以及返回状态，成功进入 get 方法。

下面我们直接测试 post + 异步的方式，我在异步请求中让程序休眠五秒，这样可以直接观测到程序的运行状态。

@GetMapping("/test/{param}")
public Result httpClient(@PathVariable("param") String param) {
  String url = "http://127.0.0.1:9999/sora/auth/http";
  HashMap<String, String> headerMap = new HashMap<>();
  headerMap.put("token", "123");
  HashMap<String, Object> paramMap = new HashMap<>();
  paramMap.put("id", param);
  OkHttpUtils.postAsync(url, paramMap,headerMap);
  return Result.success();
}

@PostMapping
public Result add(@RequestBody HashMap<String, Object> paramMap) {
  logger.info("Post-请求参数：[{}]", paramMap);
  return Result.success();
}

接口耗时 29ms，明显比五秒要短，成功完成了一次异步请求

那么这次就到这里，毕竟是很简单的东西。感兴趣的也可以看看封装的工具类，很快就可以明白其原理。