java代码发送http请求

java代码发送http请求

例一：（post请求，带参数）

private Map<String, String> getXXX(String aa) {
    // 定义一个map集合用于存储相应内容
    Map<String, String> map = new HashMap<>();
    // 创建HttpClient
    CloseableHttpClient client = HttpClients.createDefault();
    // 创建url
    String url = "xxx";
    // 创建HttpPost
    HttpPost httpPost = new HttpPost(url);
    // 设置Headers
    httpPost.setHeader("xxx", "xxx");
    // 设置参数
    Map<String, Object> params = setParams(aa);
    StringEntity entity = new StringEntity(JSONObject.toJSONString(params), "UTF-8");
    httpPost.setEntity(entity);
    // 创建HttpResponse
    CloseableHttpResponse response = null;
    try {
        // 发送post请求
        response = client.execute(httpPost);
        // 处理响应
        return dealRankItemResponse(response, partNo, url);
    } catch (IOException e) {
        log.error(ResultCode.HTTP_FAIL.message() + ",url:" + url + ".", e);
    } finally {
        if (response != null) {
            try {
                response.close();
            } catch (IOException e) {
                log.error(ResultCode.IO_FAIL.message(), e);
            }
        }
        try {
            client.close();
        } catch (IOException e) {
            log.error(ResultCode.IO_FAIL.message(), e);
        }
    }
    return map;
}

// 设置参数
private Map<String, Object> setParams(String aa) {
    Map<String, Object> params = new HashMap<>();
    params.put("xxx", "xxx");
    params.put("xxx", "xxx");
    Map<String, Object> params2 = new HashMap<>();
    params2.put("xxx", aa);
    params2.put("xxx", "xxx");
    params.put("xxx", params2);
    return params;
}

// 处理响应
private Map<String, String> dealRankItemResponse(CloseableHttpResponse response,
    String aa, String url) throws IOException {
    // 定义一个map集合用于存储相应内容
    Map<String, String> map = new HashMap<>();
    // 获取状态码
    int state = response.getStatusLine().getStatusCode();
    if (state == HttpStatus.OK.value()) {
        // 获取返回体
        HttpEntity responseEntity = response.getEntity();
        // 获取json字符串
        String jsonString = EntityUtils.toString(responseEntity);
        // 获取json对象
        JSONObject jsonObject = JSONObject.parseObject(jsonString);
        // 获取data
        Object data = jsonObject.get("data");
        if (data instanceof String) {
            // dataObject是字符串，json解析之后是集合
            List dataList = JSONObject.parseObject((String) data, List.class);
            // 如果集合为空，返回
            if (dataList.isEmpty()) {
                return map;
            }
            // 取出集合中第一个对象，将其转换为JSONObject类型
            // JSONObject first = (JSONObject) JSONObject.toJSON(dataList.get(0));
            JSONObject first = JSONObject.parseObject(dataList.get(0).toString());
            // 获取partAtts
            Object partAtts = first.get("partAtts");
            dealPartAtts(partAtts, map);
        }
    } else if (state == HttpStatus.NOT_FOUND.value()) {
        log.error("The access token is incorrect");
        // 数据请求返回429，等0.2s，重新请求
    } else if (state == HttpStatus.TOO_MANY_REQUESTS.value()) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new IOException(e);
        }
        return getxxx(partNo);
    } else {
        log.error("state:" + state + "(" + url + ")");
    }
    return map;
}

private void dealPartAtts(Object partAtts, Map<String, String> map) {
    if (partAtts instanceof List) {
        // 遍历集合
        for (Object partAttObject : (List) partAtts) {
            // partAttObject是PartAtt对象，将其转换为PartAtt对象
            PartAtt partAtt = JSONObject.parseObject(partAttObject.toString(), PartAtt.class);
            // 以key值为键，value值为值，存入map集合
            map.put(partAtt.getKey(), partAtt.getValue());
        }
    }
}

例二：（get请求，无参数）

private String getxxx(String mfgPart) {
    // 对mpn进行处理，防止其中包含空格，后面url请求报错
    String mpn = mfgPart.replace(" ", "");
    // 创建HttpClient
    CloseableHttpClient client = HttpClients.createDefault();
    // 创建url
    String url = "xxx";
    // 创建HttpPost
    HttpGet httpGet = new HttpGet(url);
    // 设置Headers
    httpGet.setHeader("xxx", "xxx");
    // 创建HttpResponse
    CloseableHttpResponse response = null;
    try {
        // 发送post请求
        response = client.execute(httpGet);
        // 处理响应
        return dealMfgCountryResponse(response, mpn, url);
    } catch (IOException e) {
        log.error(ResultCode.HTTP_FAIL.message() + ",url:" + url + ".", e);
    } finally {
        if (response != null) {
            try {
                response.close();
            } catch (IOException e) {
                log.error(ResultCode.IO_FAIL.message(), e);
            }
        }
        try {
            client.close();
        } catch (IOException e) {
            log.error(ResultCode.IO_FAIL.message(), e);
        }
    }
    return "";
}

// 处理响应
private String dealMfgCountryResponse(CloseableHttpResponse response, String mpn, String url) throws IOException {
    // 定义一个返回结果
    String mfgCountry = "";
    // 获取状态码
    int state = response.getStatusLine().getStatusCode();
    if (state == HttpStatus.OK.value()) {
        // 获取返回体
        HttpEntity responseEntity = response.getEntity();
        // 获取json字符串
        String jsonString = EntityUtils.toString(responseEntity);
        // 获取json对象
        JSONObject jsonObject = JSONObject.parseObject(jsonString);
        // 获取data
        Object datas = jsonObject.get("datas");
        mfgCountry = dealDatas(datas);
    } else if (state == HttpStatus.NOT_FOUND.value()) {
        log.error("The access token is incorrect");
        // 数据请求返回429，等0.2s，重新请求
    } else if (state == HttpStatus.TOO_MANY_REQUESTS.value()) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new IOException(e);
        }
        return getxxx(mpn);
    } else {
        log.error("state:" + state + "(" + url + ")");
    }
    return mfgCountry;
}

private String dealDatas(Object datas) {
    String mfgCountry = "";
    if (datas instanceof List) {
        // 遍历集合，寻找其中"name"为"country"的那一个
        for (Object data : (List) datas) {
            // 将data转换为JSONObject对象
            JSONObject dataJSONObject = JSONObject.parseObject(data.toString());
            if (dataJSONObject.get("name").equals("country")) {
                mfgCountry = dataJSONObject.get("value").toString();
            }
        }
    }
    return mfgCountry;
}

例三：（post请求，有参数，其中获取到jsonString后，对其字符编码解码）

private List<MpnItem> getxxx(String aa) {
    // 创建url
    String url = "xxx";
    // 创建HttpPost
    HttpPost httpPost = new HttpPost(url);
    // 设置Headers
    httpPost.setHeader("xxx", "xxx");
    // 设置参数
    String body = "xxx";
    StringEntity entity = new StringEntity(body, "UTF-8");
    httpPost.setEntity(entity);
    // 创建HttpResponse
    CloseableHttpResponse response = null;
    // 创建HttpClient
    CloseableHttpClient client = HttpClients.createDefault();
    try {
        // 发送post请求
        response = client.execute(httpPost);
        // 处理响应
        return dealMpnItemResponse(response, aa, url);
    } catch (IOException e) {
        log.error(ResultCode.HTTP_FAIL.message() + ",url：" + url + ".", e);
    } finally {
        if (response != null) {
            try {
                response.close();
            } catch (IOException e) {
                log.error(ResultCode.IO_FAIL.message(), e);
            }
        }
        try {
            client.close();
        } catch (IOException e) {
            log.error(ResultCode.IO_FAIL.message(), e);
        }
    }
    return new ArrayList<>();
}

// 处理响应
private List<MpnItem> dealMpnItemResponse(CloseableHttpResponse response,
    String aa, String url) throws IOException {
    // 定义一个list集合用于存储相应内容
    List<MpnItem> list = new ArrayList<>();
    // 获取状态码
    int state = response.getStatusLine().getStatusCode();
    if (state == HttpStatus.OK.value()) {
        // 获取返回体
        HttpEntity responseEntity = response.getEntity();
        // 获取json字符串
        String jsonString = EntityUtils.toString(responseEntity);
        String jsonStringNew = URLDecoder.decode(jsonString, "UTF-8");
        // 获取json对象
        JSONObject jsonObject = JSONObject.parseObject(jsonStringNew);
        // 获取data
        Object data = jsonObject.get("datas");
        log.info("partNo:" + aa+ ",firms:" + data.toString());
        if (data instanceof List) {
            // 遍历集合
            for (Object mpnItemObject : (List) data) {
                // mpnItemObject是MpnItem对象，将其转换为MpnItem对象
                MpnItem mpnItem = JSONObject.parseObject(mpnItemObject.toString(), MpnItem.class);
                // 添入集合
                list.add(mpnItem);
            }
            return list;
        }
    } else if (state == HttpStatus.NOT_FOUND.value()) {
        log.error("The access token is incorrect");
        // 数据请求返回429，等0.2s，重新请求
    } else if (state == HttpStatus.TOO_MANY_REQUESTS.value()) {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            throw new IOException(e);
        }
        return getxxx(partNo);
    } else {
        log.error("state:" + state + "(" + url + ")");
    }
    return list;
}