1,导入依赖

    <dependency>  
        <groupId>org.apache.httpcomponents</groupId>  
        <artifactId>httpclient</artifactId>  

　　　　　　　4.5.12

2,http发送请求工具类

@Value("${spring.profiles.active}") 获取配置文件中对应的值
注解很详细

package com.hl.analyze.utils;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Maps;
import com.integration.utils.DateUtils;
import lombok.AccessLevel;
import lombok.NoArgsConstructor;
import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.entity.UrlEncodedFormEntity;
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.client.utils.URIBuilder;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.net.URI;
import java.text.DecimalFormat;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
* @program: sgitg-micro-service
* @description: HttpClient工具类
**/
@Component
@NoArgsConstructor(access = AccessLevel.PRIVATE)
public class HttpClientUtil {
private static final Logger log = LoggerFactory.getLogger(HttpClientUtil.class);

private final static String ACTIVE\_TAG = "dev";  
private static String active;  
private static String loginUrl;  
private static String loginUrlNew;  
private static String userName;  
private static String userNameNew;  
private static String passWord;  
private static String passWordNew;  
private static String distributedPredictUrl;  
private static String distribsunStationUrl;

@Value("${spring.profiles.active}")  
public void setActive(String active) {  
    HttpClientUtil.active = active;  
}

@Value("${hlkj.new-power-sys.login-url}")  
public void setLoginUrl(String loginUrl) {  
    HttpClientUtil.loginUrl = loginUrl;  
}  
@Value("${hlkj.new-power-sys.login-url-new}")  
public void setLoginUrlNew(String loginUrl) {  
    HttpClientUtil.loginUrlNew = loginUrl;  
}

@Value("${hlkj.new-power-sys.user-name}")  
public void setUserName(String userName) {  
    HttpClientUtil.userName = userName;  
}  
@Value("${hlkj.new-power-sys.user-name-new}")  
public void setUserNameNew(String userName) {  
    HttpClientUtil.userNameNew = userName;  
}

@Value("${hlkj.new-power-sys.pass-word}")  
public void setPassWord(String passWord) {  
    HttpClientUtil.passWord = passWord;  
}  
@Value("${hlkj.new-power-sys.pass-word-new}")  
public void setPassWordNew(String passWord) {  
    HttpClientUtil.passWordNew = passWord;  
}

@Value("${hlkj.new-power-sys.distributed-predict-url}")  
public void setDistributedPredictUrl(String distributedPredictUrl) {  
    HttpClientUtil.distributedPredictUrl = distributedPredictUrl;  
}

@Value("${hlkj.new-power-sys.distribsun-station-url}")  
public void setDistribsunStationUrl(String distribsunStationUrl) {  
    HttpClientUtil.distribsunStationUrl = distribsunStationUrl;  
}

/\*\*  
 \* @return java.lang.String  
 \* @Description get map参数  
 \* @Date 2020/12/8 13:56  
 \* @Param \[url, param\]  
 \*\*/  
public static String doGet(String url, Map<String, String> param) {  
    // 创建Httpclient对象  
    CloseableHttpClient httpclient = HttpClients.createDefault();  
    String resultString = "";  
    CloseableHttpResponse response = null;  
    try {  
        // 创建uri  
        URIBuilder builder = new URIBuilder(url);  
        if (param != null) {  
            for (String key : param.keySet()) {  
                builder.addParameter(key, param.get(key));  
            }  
        }  
        URI uri = builder.build();

        // 创建http GET请求  
        HttpGet httpGet = new HttpGet(uri);  
        // 执行请求  
        response = httpclient.execute(httpGet);  
        // 判断返回状态是否为200  
        if (response.getStatusLine().getStatusCode() == 200) {  
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");  
        }  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpclient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    return resultString;  
}

public static String doGet(String url, Map<String, String> headMap, Map<String, String> param) {  
    // 创建Httpclient对象  
    CloseableHttpClient httpclient = HttpClients.createDefault();  
    String resultString = "";  
    CloseableHttpResponse response = null;  
    try {  
        // 创建uri  
        URIBuilder builder = new URIBuilder(url);  
        if (param != null) {  
            for (String key : param.keySet()) {  
                builder.addParameter(key, param.get(key));  
            }  
        }  
        URI uri = builder.build();

        // 创建http GET请求  
        HttpGet httpGet = new HttpGet(uri);  
        // 执行请求  
        response = httpclient.execute(httpGet);  
        // 判断返回状态是否为200  
        if (response.getStatusLine().getStatusCode() == 200) {  
            resultString = EntityUtils.toString(response.getEntity(), "UTF-8");  
        }  
        // 添加head参数  
        if (headMap != null && !headMap.isEmpty()) {  
            for (String key : headMap.keySet()) {  
                httpGet.addHeader(key, headMap.get(key));  
            }  
        }  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpclient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    return resultString;  
}

/\*\*  
 \* @return java.lang.String  
 \* @Description get无参  
 \* @Date 2020/12/8 13:56  
 \* @Param \[url\]  
 \*\*/  
public static String doGet(String url) {  
    return doGet(url, null);  
}

/\*\*  
 \* @return java.lang.String  
 \* @Description post map参数  
 \* @Date 2020/12/8 13:56  
 \* @Param \[url, param\]  
 \*\*/  
public static String doPost(String url, Map<String, String> param) {  
    log.debug("接口地址【{}】", url);  
    log.debug("接口参数【{}】", param);  
    // 创建Httpclient对象  
    CloseableHttpClient httpClient = HttpClients.createDefault();  
    CloseableHttpResponse response = null;  
    String resultString = "";  
    try {  
        // 创建Http Post请求  
        HttpPost httpPost = new HttpPost(url);  
        // 创建参数列表  
        if (param != null) {  
            List<NameValuePair> paramList = new ArrayList<>();  
            for (String key : param.keySet()) {  
                paramList.add(new BasicNameValuePair(key, param.get(key)));  
            }  
            // 模拟表单  
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");  
            httpPost.setEntity(entity);  
            httpPost.setHeader("sppp-id", "fe8de0-3749-43b1-9b7e-e652763a682d");  
        }  
        // 执行http请求  
        response = httpClient.execute(httpPost);  
        resultString = EntityUtils.toString(response.getEntity(), "utf-8");  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpClient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    log.debug("接口返回值【{}】", resultString);  
    return resultString;  
}

public static Header\[\] doPostForHeader(String url, Map<String, String> param) {  
    log.debug("接口地址【{}】", url);  
    log.debug("接口参数【{}】", param);  
    // 创建Httpclient对象  
    CloseableHttpClient httpClient = HttpClients.createDefault();  
    CloseableHttpResponse response = null;  
    Header\[\] allHeaders = new Header\[0\];  
    try {  
        // 创建Http Post请求  
        HttpPost httpPost = new HttpPost(url);  
        // 创建参数列表  
        if (param != null) {  
            List<NameValuePair> paramList = new ArrayList<>();  
            for (String key : param.keySet()) {  
                paramList.add(new BasicNameValuePair(key, param.get(key)));  
            }  
            // 模拟表单  
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");  
            httpPost.setEntity(entity);  
            httpPost.setHeader("sppp-id", "fe8de0-3749-43b1-9b7e-e652763a682d");  
        }  
        // 执行http请求  
        response = httpClient.execute(httpPost);  
        allHeaders = response.getAllHeaders();  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpClient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    log.debug("返回值【{}】", allHeaders);  
    return allHeaders;  
}

/\*\*  
 \* @return java.lang.String  
 \* @Description post head map参数  
 \* @Date 2021/04/28 15:15  
 \* @Param \[url, headMap, param\]  
 \*\*/  
public static String doPost(String url, Map<String, String> headMap, Map<String, String> param) {  
    log.debug("接口地址【{}】", url);  
    log.debug("接口参数【{}】", param);  
    // 创建Httpclient对象  
    CloseableHttpClient httpClient = HttpClients.createDefault();  
    CloseableHttpResponse response = null;  
    String resultString = "";  
    try {  
        // 创建Http Post请求  
        HttpPost httpPost = new HttpPost(url);  
        // 创建参数列表  
        if (param != null) {  
            List<NameValuePair> paramList = new ArrayList<>();  
            for (String key : param.keySet()) {  
                paramList.add(new BasicNameValuePair(key, param.get(key)));  
            }  
            // 模拟表单  
            UrlEncodedFormEntity entity = new UrlEncodedFormEntity(paramList, "utf-8");  
            httpPost.setEntity(entity);  
        }  
        // 添加head参数  
        if (headMap != null && !headMap.isEmpty()) {  
            for (String key : headMap.keySet()) {  
                httpPost.addHeader(key, headMap.get(key));  
            }  
        }  
        // 执行http请求  
        response = httpClient.execute(httpPost);  
        resultString = EntityUtils.toString(response.getEntity(), "utf-8");  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpClient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    log.debug("接口返回值【{}】", resultString);  
    return resultString;  
}

public static String doPostByFormData(String url, Map<String, String> param) throws Exception {  
    log.debug("接口地址【{}】", url);  
    log.debug("接口参数【{}】", param);  
    String result = "";  
    CloseableHttpClient client = null;  
    CloseableHttpResponse response = null;  
    RequestConfig defaultRequestConfig = RequestConfig.custom().setSocketTimeout(6000).setConnectTimeout(5000)  
            .setConnectionRequestTimeout(6000).setStaleConnectionCheckEnabled(true).build();  
    client = HttpClients.custom().setDefaultRequestConfig(defaultRequestConfig).build();  
    // client = HttpClients.createDefault();  
    URIBuilder uriBuilder = new URIBuilder(url);

    HttpPost httpPost = new HttpPost(uriBuilder.build());  
    httpPost.setHeader("Connection", "Keep-Alive");  
    httpPost.setHeader("Charset", "UTF-8");  
    httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded");  
    Iterator<Map.Entry<String, String>> it = param.entrySet().iterator();  
    List<NameValuePair> params = new ArrayList<NameValuePair>();

    while (it.hasNext()) {  
        Map.Entry<String, String> entry = it.next();  
        NameValuePair pair = new BasicNameValuePair(entry.getKey(), entry.getValue());  
        params.add(pair);  
    }

    httpPost.setEntity(new UrlEncodedFormEntity(params, "UTF-8"));  
    try {  
        response = client.execute(httpPost);  
        if (response != null) {  
            log.debug("response 为空");  
            HttpEntity resEntity = response.getEntity();  
            if (resEntity != null) {  
                log.debug("resEntity 为空");  
                result = EntityUtils.toString(resEntity, "UTF-8");  
            }  
        }  
    } catch (ClientProtocolException e) {  
        throw new RuntimeException("创建连接失败" + e);  
    } catch (IOException e) {  
        throw new RuntimeException("创建连接失败" + e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            client.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    log.debug("接口返回值【{}】", result);  
    return result;  
}

public static String doPost(String url) {  
    return doPost(url, null);  
}

/\*\*  
 \* @return java.lang.String  
 \* @Description post json参数  
 \* @Date 2020/12/8 13:56  
 \* @Param \[url, param\]  
 \*\*/  
public static String doPostJson(String url, String json) {  
    // 创建Httpclient对象  
    CloseableHttpClient httpClient = HttpClients.createDefault();  
    CloseableHttpResponse response = null;  
    String resultString = "";  
    try {  
        // 创建Http Post请求  
        HttpPost httpPost = new HttpPost(url);  
        // 创建请求内容  
        StringEntity entity = new StringEntity(json, ContentType.APPLICATION\_JSON);  
        httpPost.setEntity(entity);  
        // 执行http请求  
        response = httpClient.execute(httpPost);  
        resultString = EntityUtils.toString(response.getEntity(), "utf-8");  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpClient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    return resultString;  
}

public static String doPostJson(String url, Map<String, String> headMap, String json) {  
    log.info("请求地址:{}",url);  
    log.info("请求头:{}",headMap);  
    log.info("请求参数:{}",json);  
    // 创建Httpclient对象  
    CloseableHttpClient httpClient = HttpClients.createDefault();  
    CloseableHttpResponse response = null;  
    String resultString = "";  
    try {  
        // 创建Http Post请求  
        HttpPost httpPost = new HttpPost(url);  
        // 添加head参数  
        if (headMap != null && !headMap.isEmpty()) {  
            for (String key : headMap.keySet()) {  
                httpPost.addHeader(key, headMap.get(key));  
            }  
        }  
        // 创建请求内容  
        StringEntity entity = new StringEntity(json, ContentType.APPLICATION\_JSON);  
        httpPost.setEntity(entity);  
        // 执行http请求  
        response = httpClient.execute(httpPost);  
        resultString = EntityUtils.toString(response.getEntity(), "utf-8");  
    } catch (Exception e) {  
        log.error(e.getMessage(), e);  
    } finally {  
        try {  
            if (response != null) {  
                response.close();  
            }  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
        try {  
            httpClient.close();  
        } catch (IOException e) {  
            log.error(e.getMessage(), e);  
        }  
    }  
    log.info("返回值:{}",resultString);  
    return resultString;  
}

public static String getNewPowerSysCookie() {  
    if (ACTIVE\_TAG.equals(active)) {  
        return "cookie";  
    } else {  
        try {  
            Header\[\] headers = HttpClientUtil.doPostForHeader(loginUrl, new HashMap<String, String>() {{  
                put("username", userName);  
                put("password", passWord);  
            }});  
            Map<Object, Object> objectMap = Arrays.stream(headers).collect(Collectors.toMap(NameValuePair::getName, NameValuePair::getValue, (e1, e2) -> e1));  
            String cookie = objectMap.get("Set-Cookie").toString();  
            log.debug(String.valueOf(objectMap));  
            log.debug("date:{}====================cookie:{}===========", LocalDateTime.now(), cookie);  
            return cookie;  
        }catch (Exception e){  
            e.printStackTrace();  
            log.error("新能源接口异常，请检查新能源系统是否正常！");  
            return "null";  
        }  
    }

}  
public static String getAuthorization() {  
    if (ACTIVE\_TAG.equals(active)) {  
        return "Authorization";  
    } else {  
        try {  
            log.info("userNameNew=" + userNameNew);  
            log.info("passWordNew=" + passWordNew);  
            log.info("loginUrlNew=" + loginUrlNew);  
            Header\[\] headers = HttpClientUtil.doPostForHeader(loginUrlNew, new HashMap<String, String>() {{  
                put("username", userNameNew);  
                put("password", passWordNew);  
                put("type", "0");  
            }});  
            log.info("headers=" + headers.toString());  
            String res = HttpClientUtil.doPost(loginUrlNew, new HashMap<String, String>() {{  
                put("username", userNameNew);  
                put("password", passWordNew);  
                put("type", "0");  
            }});  
            log.info("loginUrlNewRes=" + String.valueOf(res));  
            JSONObject jsonObject = JSONObject.parseObject(res);  
            String token = jsonObject.get("token").toString();  
            String Authorization = "Bearer " + token;  
            /\*Map<Object, Object> objectMap = Arrays.stream(headers).collect(Collectors.toMap(NameValuePair::getName, NameValuePair::getValue, (e1, e2) -> e1));  
            String cookie = objectMap.get("Set-Cookie").toString();\*/  
            log.info("AuthorizationSet=" + String.valueOf(Authorization));  
            log.info("date:{}====================cookie:{}===========", LocalDateTime.now(), Authorization);  
            return Authorization;  
        }catch (Exception e){  
            e.printStackTrace();  
            log.error("可开放容量监测接口异常，请检查新能源系统是否正常！");  
            return "null";  
        }  
    }  
}

public static String getNewEnergyPower(String scheduleId, String scheduleName) {  
    if (ACTIVE\_TAG.equals(active)) {  
        return "222.33";  
    } else {  
        // 德州所有用户在某刻的瞬时功率  
        String realTimePower = "";  
        // 获取token  
        String newPowerSysCookie = HttpClientUtil.getNewPowerSysCookie();  
        try {  
            Map<String, String> map = Maps.newHashMapWithExpectedSize(6);  
            Map<String, String> hMap = Maps.newHashMapWithExpectedSize(6);

            map.put("scheduleId", scheduleId);  
            map.put("scheduleName", scheduleName);  
            map.put("beginTime", com.integration.utils.DateUtils.parseDate(new Date(), "yyyy-MM-dd"));  
            map.put("endTime", com.integration.utils.DateUtils.parseDate(new Date(), "yyyy-MM-dd"));  
            map.put("distribsunStationId", "");  
            map.put("distribsunStationName", "");

            hMap.put("Cookie", newPowerSysCookie);  
            // 接口返回值  
            String postRes = HttpClientUtil.doPost(distributedPredictUrl, hMap, map);

            JSONObject objMap = (JSONObject) JSONObject.parseObject(postRes).get("obj");  
            JSONArray lineData = (JSONArray) objMap.get("linedata");  
            JSONArray tabledata = (JSONArray) objMap.get("tabledata");

            Double value = 0.0;  
            for (int i = 0; i < tabledata.size(); i++) {  
                JSONObject data = (JSONObject) tabledata.get(i);  
                String hours = data.get("time").toString();  
                // 当前是几点  
                String nowHours = DateUtils.parseDate(new Date(), "yyyy-MM-dd HH:mm:ss").split(" ")\[1\].split(":")\[0\];  
                if (hours.contains(nowHours + ":00:00")) {  
                    value = value + Double.parseDouble("-".equals(data.get("data").toString())?"0":data.get("data").toString());  
                    log.debug("德州所有用户的的瞬时功率值：{}", value);  
                    break;  
                }  
            }  
            if (value == 0.0) {  
                realTimePower = lineData.get(lineData.indexOf("-") - 1).toString();  
            } else {  
                DecimalFormat decimalFormat = new DecimalFormat("0.00");  
                realTimePower = decimalFormat.format(value);  
            }

        } catch (Exception e) {  
            log.error("新能源接口异常" + e.getMessage(), e);  
        }  
        return realTimePower;  
    }  
}

}