Http请求工具类：Get/Post

自己写或者用Hutool工具类里HttpUtil的都可以 

第一种 (目前没发现问题)

package com.cn.utils;


import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.Map;

public class HttpUtil {
    /**
     * get请求
     *
     * @param url     url
     * @param params  参数
     * @param headers 请求头
     * @return 结果
     * headers.put("Content-Type", "application/x-www-form-urlencoded");
     * headers.put("User-Agent", "Mozilla/5.0");
     */
    public static String sendGet(String url, Map<String, String> params, Map<String, String> headers) throws Exception {
        StringBuilder result = new StringBuilder();
        String paramString = "";

        // 将参数拼接在URL上
        if (params != null && !params.isEmpty()) {
            for (String key : params.keySet()) {
                paramString += key + "=" + params.get(key) + "&";
            }
            paramString = paramString.substring(0, paramString.length() - 1);
            url += "?" + paramString;
        }

        // 创建连接
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();

        // 设置请求头
        if (headers != null && !headers.isEmpty()) {
            for (String key : headers.keySet()) {
                con.setRequestProperty(key, headers.get(key));
            }
        }

        // 发送GET请求
        con.setRequestMethod("GET");
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        while ((inputLine = in.readLine()) != null) {
            result.append(inputLine);
        }
        in.close();

        return result.toString();
    }

    /**
     * post请求 参数形式
     *
     * @param url        url
     * @param parameters 参数
     * @param headers    请求头
     * @return 结果
     * headers.put("Content-Type", "application/x-www-form-urlencoded");
     * headers.put("User-Agent", "Mozilla/5.0");
     */
    public static String sendPost(String url, Map<String, String> parameters, Map<String, String> headers) throws Exception {
        // 创建链接对象
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();

        // 设置请求方法为POST
        con.setRequestMethod("POST");

        // 设置请求头信息
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            con.setRequestProperty(entry.getKey(), entry.getValue());
        }

        // 发送POST请求
        con.setDoOutput(true);
        DataOutputStream wr = new DataOutputStream(con.getOutputStream());
        StringBuilder params = new StringBuilder();
        for (Map.Entry<String, String> entry : parameters.entrySet()) {
            if (params.length() != 0) {
                params.append('&');
            }
            params.append(entry.getKey()).append('=').append(entry.getValue());
        }
        wr.writeBytes(params.toString());
        wr.flush();
        wr.close();

        // 获取响应信息
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        return response.toString();
    }

    /**
     * post请求 json形式
     *
     * @param url      url
     * @param jsonBody 参数
     * @param headers  请求头
     * @return 结果
     * headers.put("Content-Type", "application/json");
     * headers.put("User-Agent", "Mozilla/5.0");
     */
    public static String sendPost2(String url, String jsonBody, Map<String, String> headers) throws Exception {

        // 创建链接对象
        URL obj = new URL(url);
        HttpURLConnection con = (HttpURLConnection) obj.openConnection();

        // 设置请求方法为POST
        con.setRequestMethod("POST");

        // 设置请求头信息
        for (Map.Entry<String, String> entry : headers.entrySet()) {
            con.setRequestProperty(entry.getKey(), entry.getValue());
        }

        // 发送POST请求
        con.setDoOutput(true);
        try (DataOutputStream wr = new DataOutputStream(con.getOutputStream())) {
            wr.writeBytes(jsonBody);
            wr.flush();
        }

        // 获取响应信息
        int responseCode = con.getResponseCode();
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();
        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();

        return response.toString();
    }

    /**
     * 调用豆瓣接口
     */
    public static void main(String[] args) throws Exception {
        Map<String, String> params = new HashMap<>();
        params.put("type", "11");
        params.put("interval_id", "100:90");

        Map<String, String> headers = new HashMap<>();
        headers.put("Content-Type", "application/x-www-form-urlencoded");
        headers.put("User-Agent", "Mozilla/5.0");

        String response = HttpUtil.sendGet("https://movie.douban.com/j/chart/top_list_count", params, headers);
        System.out.println(response);
    }
}

第二种 (打印了日志)

import com.alibaba.fastjson.JSONObject;
import org.apache.http.HttpEntity;
import org.apache.http.ParseException;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.config.ConnectionConfig;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.config.SocketConfig;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContexts;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;

import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.nio.charset.Charset;
import java.security.KeyManagementException;
import java.security.KeyStore;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;


/**
 * @program: http请求工具类
 * @Description
 * @Author Yph
 */
public class HttpUtil {

    public static String defaultEncoding = "utf-8";

    /**
     * @Description: 发送http post请求，并返回响应实体
     * @Author: Yph
     * @Param [url：url]
     * @Return: java.lang.String
     **/
    public static String postRequest(String url) {
        return postRequest(url, null, null);
    }

    /**
     * @Description: 发送http post请求，并返回响应实体
     * @Author: Yph
     * @Param [url：url, params：json对象格式参数]
     * @Return: java.lang.String
     **/
    public static String postRequest(String url, JSONObject params) {
        return postRequest(url, null, params);
    }

    /**
     * @Description: 发送http post请求，并返回响应实体
     * @Author: Yph
     * @Param [url：url, headersMap：请求头，params：json对象格式参数]
     * @Return: java.lang.String
     **/
    public static String postRequest(String url, Map<String, String> headersMap,
                                     JSONObject params) {
        String result = null;
        CloseableHttpClient httpClient = buildHttpClient();
        HttpPost httpPost = new HttpPost(url);
        //请求头
        if (null != headersMap && headersMap.size() > 0) {
            for (Entry<String, String> entry : headersMap.entrySet()) {
                String key = entry.getKey();
                String value = entry.getValue();
                httpPost.addHeader(new BasicHeader(key, value));
            }
        }
        //参数JSON格式
        if (null != params && params.size() > 0) {
            StringEntity stringEntity = new StringEntity(params.toString(), "utf-8");
            stringEntity.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/json"));
            httpPost.setEntity(stringEntity);
        }

        try {
            CloseableHttpResponse response = null;
            if (httpClient != null) {
                response = httpClient.execute(httpPost);
            }
            try {
                HttpEntity entity = null;
                if (response != null) {
                    entity = response.getEntity();
                }
                if (entity != null) {
                    result = EntityUtils.toString(entity,
                            Charset.forName(defaultEncoding));
                }
            } finally {
                if (response != null) {
                    response.close();
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        } finally {
            try {
                if (httpClient != null) {
                    httpClient.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

        return result;
    }

    /**
     * @Description: 发送http get请求，并返回响应实体
     * @Author: Yph
     * @Param [url]
     * @Return: java.lang.String
     **/
    public static String getRequest(String url) {
        return getRequest(url, null);
    }


    /**
     * @Description: 发送http get请求，并返回响应实体
     * @Author: Yph
     * @Param [url：url, params：参数]
     * @Return: java.lang.String
     **/
    public static String getRequest(String url, Map<String, Object> params) {
        return getRequest(url, null, params);
    }

    /**
     * @Description:
     * @Author: Yph
     * @Param [url：url, headersMap：请求头, params：参数]
     * @Return: java.lang.String
     **/
    public static String getRequest(String url, Map<String, String> headersMap, Map<String, Object> params) {
        String result = null;
        CloseableHttpClient httpClient = buildHttpClient();
        try {
            String apiUrl = url;
            if (null != params && params.size() > 0) {
                StringBuffer param = new StringBuffer();
                int i = 0;
                for (String key : params.keySet()) {
                    if (i == 0)
                        param.append("?");
                    else
                        param.append("&");
                    param.append(key).append("=").append(params.get(key));
                    i++;
                }
                apiUrl += param;
            }

            HttpGet httpGet = new HttpGet(apiUrl);
            if (null != headersMap && headersMap.size() > 0) {
                for (Entry<String, String> entry : headersMap.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    httpGet.addHeader(new BasicHeader(key, value));
                }
            }
            CloseableHttpResponse response = httpClient.execute(httpGet);
            try {
                HttpEntity entity = response.getEntity();
                if (null != entity) {
                    result = EntityUtils.toString(entity, defaultEncoding);
                }
            } finally {
                response.close();
            }
        } catch (ClientProtocolException e) {
            e.printStackTrace();
        } catch (ParseException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                httpClient.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    /**
     * 创建httpclient
     */
    public static CloseableHttpClient buildHttpClient() {
        try {
            RegistryBuilder<ConnectionSocketFactory> builder = RegistryBuilder
                    .create();
            ConnectionSocketFactory factory = new PlainConnectionSocketFactory();
            builder.register("http", factory);
            KeyStore trustStore = KeyStore.getInstance(KeyStore
                    .getDefaultType());
            SSLContext context = SSLContexts.custom().useTLS()
                    .loadTrustMaterial(trustStore, new TrustStrategy() {
                        public boolean isTrusted(X509Certificate[] chain,
                                                 String authType) throws CertificateException {
                            return true;
                        }
                    }).build();
            LayeredConnectionSocketFactory sslFactory = new SSLConnectionSocketFactory(
                    context,
                    SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            builder.register("https", sslFactory);
            Registry<ConnectionSocketFactory> registry = builder.build();
            PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager(
                    registry);
            ConnectionConfig connConfig = ConnectionConfig.custom()
                    .setCharset(Charset.forName(defaultEncoding)).build();
            SocketConfig socketConfig = SocketConfig.custom()
                    .setSoTimeout(100000).build();
            manager.setDefaultConnectionConfig(connConfig);
            manager.setDefaultSocketConfig(socketConfig);
            return HttpClientBuilder.create().setConnectionManager(manager)
                    .build();
        } catch (KeyStoreException e) {
            e.printStackTrace();
        } catch (KeyManagementException e) {
            e.printStackTrace();
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args) {
        String url = "http://127.0.0.1:8080/ListAll";

        JSONObject params = new JSONObject();
        params.put("userId", "1");
        params.put("pageNo", 1);
        params.put("pageSize", 10);
        System.out.println(params);

        Map<String, String> heardMap = new HashMap<String, String>();
        heardMap.put("X-Access-Token", "1");

        String result = HttpUtil.postRequest(url, heardMap, params);
        System.out.println("响应--->>> " + result);
    }

    /**
     * @Description: 发送post请求
     * @Author: Yph
     * @Param [url：url, jsonObject：参数(json类型), encoding：编码格式]
     * @Return: java.lang.String
     **/
    public static String send(String url, JSONObject jsonObject, String encoding) throws ParseException, IOException {
        String body = "";

        //创建httpclient对象
        CloseableHttpClient client = HttpClients.createDefault();
        //创建post方式请求对象
        HttpPost httpPost = new HttpPost(url);

        //装填参数
        StringEntity s = new StringEntity(jsonObject.toString(), "utf-8");
        s.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE,
                "application/json"));
        //设置参数到请求对象中
        httpPost.setEntity(s);
        System.out.println("请求地址：" + url);
        
        //设置header信息
        //指定报文头【Content-type】、【User-Agent】
        //httpPost.setHeader("Content-type", "application/x-www-form-urlencoded");

        httpPost.setHeader("Content-type", "application/json");
        httpPost.setHeader("User-Agent", "Mozilla/4.0 (compatible; MSIE 5.0; Windows NT; DigExt)");

        //执行请求操作，并拿到结果（同步阻塞）
        CloseableHttpResponse response = client.execute(httpPost);
        //获取结果实体
        HttpEntity entity = response.getEntity();
        if (entity != null) {
            //按指定编码转换结果实体为String类型
            body = EntityUtils.toString(entity, encoding);
        }
        EntityUtils.consume(entity);
        //释放链接
        response.close();
        return body;
    }

}

第三种 (处理部分请求有问题需要改)

package com.shinkeer.core.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import lombok.extern.slf4j.Slf4j;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.URL;
import java.net.URLConnection;
import java.util.HashMap;
import java.util.Map;


/**
 * @description: http请求工具类
 * @author: Yph
 * @date: 2022/12/7
 **/
@Slf4j
public class HttpUtils {
    /**
     * @description: post请求
     * @author: Yph
     * @date: 2022/12/7
     * @param: [url：url, headersMap：请求头, param：入参（json格式字符串）]
     * @return: java.lang.String（json格式字符串）
     **/
    public static String sendJsonPost(String url, Map<String, String> headersMap, String params) {
        System.out.println("\n==============================POST请求开始==============================");
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            URL realUrl = new URL(url);
            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            //设置Content-type 为 application/json
            conn.addRequestProperty("Content-type", "application/json");

            //自定义请求头如Token之类
            if (null != headersMap && headersMap.size() > 0) {
                for (Map.Entry<String, String> entry : headersMap.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    conn.setRequestProperty(key, value);
                }
            }

            // 发送POST请求必须设置如下两行
            conn.setDoOutput(true);
            conn.setDoInput(true);
            // 获取URLConnection对象对应的输出流
            out = new PrintWriter(conn.getOutputStream());
            // 发送请求参数
            out.print(params);
            // flush输出流的缓冲
            out.flush();
            // 定义BufferedReader输入流来读取URL的响应

            in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送 POST 请求出现异常！" + e);
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("url:" + url);
        System.out.println("POST请求结果：" + result);
        System.out.println("==============================POST请求结束==============================\n");
        return result;
    }

    /**
     * @description: get请求
     * @author: Yph
     * @date: 2022/12/7
     * @param: [url：url, headersMap：请求头, param：入参（json格式字符串）]
     * @return: java.lang.String（json格式字符串）
     **/
    public static String sendJsonGet(String url, Map<String, String> headersMap, String params) {
        System.out.println("\n==============================GET请求开始==============================");
        PrintWriter out = null;
        BufferedReader in = null;
        String result = "";
        try {
            Map<String, Object> mapJson = JSON.parseObject(params);
            String param = setParams(mapJson);
            String urlNameString = url + "?" + param;
            log.info("sendGet - {}", urlNameString);
            URL realUrl = new URL(urlNameString);

            // 打开和URL之间的连接
            URLConnection conn = realUrl.openConnection();
            // 设置通用的请求属性
            conn.setRequestProperty("accept", "*/*");
            conn.setRequestProperty("connection", "Keep-Alive");
            conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            //设置Content-type 为 application/json
            conn.addRequestProperty("Content-type", "application/json");

            //自定义请求头如Token之类
            if (null != headersMap && headersMap.size() > 0) {
                for (Map.Entry<String, String> entry : headersMap.entrySet()) {
                    String key = entry.getKey();
                    String value = entry.getValue();
                    conn.setRequestProperty(key, value);
                }
            }

            conn.getInputStream();
            in = new BufferedReader(new InputStreamReader(conn.getInputStream()));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e) {
            System.out.println("发送 GET 请求出现异常！" + e);
            e.printStackTrace();
        }
        //使用finally块来关闭输出流、输入流
        finally {
            try {
                if (out != null) {
                    out.close();
                }
                if (in != null) {
                    in.close();
                }
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        }
        System.out.println("url:" + url);
        System.out.println("GET请求结果：" + result);
        System.out.println("==============================GET请求结束==============================\n");
        return result;
    }

    /**
     * 拼装参数到url
     *
     * @param params 参数
     * @return 参数字符串
     */
    public static String setParams(Map<String, Object> params) {
        StringBuilder param = new StringBuilder();
        for (Map.Entry<String, Object> entry : params.entrySet()) {
            param.append("&").append(entry.getKey()).append("=").append(entry.getValue());
        }
        return param.substring(1);
    }

    public static void main(String[] args) {
        String url = "https:";//post
        String url2 = "https:";//get

        JSONObject params = new JSONObject();
        params.put("platformOrderCode", "7J961670376400639ls844848");
        params.put("pageNo", 1);
        params.put("pageSize", 10);
        System.out.println(params.toString());

        JSONObject params2 = new JSONObject();
        params2.put("categoryId", "5a490093e57a457cbad34f5fc494f49d");
        System.out.println(params2.toString());

        Map<String, String> heardMap = new HashMap<String, String>();
        heardMap.put("Access-Token", "eHCMNrBS4382qCTuJXz4FKrUYYFu7GTR+ZVTkxLyq1OnacedVl9qr17Q6P6l/+1H");

        String result = sendJsonPost(url, heardMap, params.toString());
        Map map = JSON.parseObject(result);

        String result2 = sendJsonGet(url2, heardMap, params2.toString());
        Map map2 = JSON.parseObject(result2);

        System.out.println("请求结果POST>>> " + map);
        System.out.println("请求结果GET>>> " + map2);
    }
}