调用接口的两种方法

public class HttpClientPost{
    @Test
    public void form() throws Exception{
        String url="http://localhost:7900/cart/save";
        Map<String,String> paraMap = new HashMap<String,String>();
        paraMap.put("userId","7");

        String result = httpPostWithForm(rl,paraMap);
        System.out.println(result);
    }
    
    public static String httpPostWithForm(String url,Map<String,String> paraMap) throws Exception{
    HttpPost httpPost = new HttpPost(url);
    CloseableHttpClient client = HttpClients.createDefault();
    String respContent = null;

    //遍历参数map，设置表单参数
    List<BasicNameValuePair> pairList = new ArrayList<BasicNameValuePair>();
    for(Map.Entry<String,String>entry : paraMap.entrySet()){
        pairList.add(new BasicNameValuePair(entry.getKeyy(),entry.getValue()));
        }
        httpPost.setEntity(new UrlEncodedFormEntity(pairList,"utf-8"));
        HttpResponse resp = client.execute(httpPost);
        if(resp.getStatusLine().getStatusCode() == 200){
            HttpEntity he = resp.getEntity();
            respContent = EntityUtils.toString(he,"utf-8");
        }
        return respContent;
    }

    @Test
    public void json() throws Rxception{
        String url = "http://localhost:8070/cart";
        String result = httpPostWithJSON(url);
        System.out.println(result);
    }

    public static String httpPostWithJSON(String url) throws Exception{
        HttpPost httpPost == new HttpPost(url);
        CloseableHttpClient client = HttpClients.createDefault();
        String respContent = null;

        //json方式
        JSONObject jsonParam = new JSONObject();
        jsonParam.put("name","admin");
        StringEntity entity = new StringEntity(jsonParam.toString(),"utf-8");//解决中文乱码
        entity.setContentEncoding("UTF-8");
        entity.setContenType("application/json");
        httpPost.setEntitty(entity);
        HttpResponse resp = client.execute(httpPost);
        if(resp.getStatusLine().getStatusCode() == 200){
            HttpEntity he = resp.getEnttity();
            respContent = EntityUtils.toString(he,"UTF-8");
        }
        return respContent;
    }
}

第二种

package workshop.Common.httpApi;


import org.apache.commons.lang.StringUtils;
import org.apache.http.HttpHost;
import org.apache.http.client.methods.HttpGet;
import org.springframework.http.*;
import org.springframework.http.HttpHeaders;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.util.CollectionUtils;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.Map;
import java.util.Set;

public class HttpUtil {

    private HttpUtil(){

    }

    /**
     * 连接超时时间
     */
    private static final int CONN_TIMEOUT = 30000;
    /**
     * 请求超时时间
     */
    private static final int READ_TIMEOUT = 30000;

    private static RestTemplate restTemplate = null;

    static{
        //设置超时时间
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        requestFactory.setConnectTimeout(CONN_TIMEOUT);
        requestFactory.setReadTimeout(READ_TIMEOUT);
        restTemplate =  new RestTemplate(requestFactory);
    }

    /**
     * 设置header公共参数
     */
    private static HttpHeaders initHeader(){
        HttpHeaders headers = new HttpHeaders();
        headers.add("Accept", "application/json");
        headers.add("Accpet-Encoding", "gzip");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/json; charset=UTF-8");
        return headers;
    }

    /**
     * 设置header公共参数
     */
    private static HttpHeaders initHeaderX(){
        HttpHeaders headers = new HttpHeaders();
        headers.add("Accept", "application/x-www-form-urlencoded");
        headers.add("Accpet-Encoding", "gzip");
        headers.add("Content-Encoding", "UTF-8");
        headers.add("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8");
        return headers;
    }

    /**
     * 设置header参数
     * @param httpHeaders
     * @param headers
     */
    private static void setHeaderParam(HttpHeaders httpHeaders,Map<String,Object> headers){
        if(!CollectionUtils.isEmpty(headers)){
            Set<String> keys = headers.keySet();
            for(String key:keys){
                httpHeaders.add(key,headers.get(key).toString());
            }
        }

    }

    /**
     * 设置参数
     * @param param
     * @return
     */
    private static MultiValueMap<String,Object> setParam(Map<String,Object> param){
        MultiValueMap<String,Object> valueMap = new LinkedMultiValueMap<>();
        if(CollectionUtils.isEmpty(param)){
            return valueMap;
        }
        Set<String> paramKeys = param.keySet();
        for(String key:paramKeys){
            valueMap.add(key,param.get(key).toString());
        }
        return valueMap;
    }

    /**
     * 发送Get请求
     * @param url 请求地址
     * @param headers 请求头参数
     * @return
     */
    public static String httpGet(String url,Map<String,Object> headers){

        //初始化header公共参数
        HttpHeaders httpHeaders = initHeader();
        //设置header参数
        setHeaderParam(httpHeaders,headers);
        //发送请求
        HttpEntity httpEntity = new HttpEntity(null,httpHeaders);
        HttpGet get = new HttpGet(url);
        ResponseEntity<String> responseEntity = restTemplate.exchange(get.toString(), HttpMethod.GET,httpEntity,String.class);
        return responseEntity.getBody();

    }


    /**
     * 发送Get请求
     * @param url 请求地址
     * @param headers 请求头参数
     * @param param 查询参数
     * @return
     */
    public static String httpGet(String url, Map<String,Object> headers,Map<String,Object> param){

        //如果查询参数为空，则调用不带参数的Get请求
        if(CollectionUtils.isEmpty(param)){
            return httpGet(url,headers);
        }

        //组装查询参数
        Set<String> keys = param.keySet();
        StringBuilder builder = new StringBuilder();
        builder.append("?");
        for(String key:keys){
            builder.append(key).append("=").append(param.get(key)).append("&");
        }
        builder.deleteCharAt(builder.lastIndexOf("&"));
        url = url+builder.toString();
        //发送请求
        return httpGet(url,headers);

    }


    /**
     * 发送Post请求
     * @param url 请求地址
     * @param param 请求参数
     * @return
     */
    public static String httpPost(String url,Map<String,Object> param){

        //初始化header公共参数
        HttpHeaders httpHeaders = initHeader();
        //设置参数
        MultiValueMap<String,Object> valueMap = setParam(param);
        //发送请求
        return toPost(url,httpHeaders,valueMap);
    }

    /**
     * 发送Post请求
     * @param url 请求地址
     * @param json json格式参数参数
     * @return
     */
    public static ResponseEntity<String> httpPost(String url,String json){

        //初始化header公共参数
        HttpHeaders httpHeaders = initHeader();
        //发送请求
        return toPost(url,httpHeaders,json);
    }

    /**
     * 发送Post请求
     * @param url 请求地址
     * @param json json格式参数参数
     * @return
     */
    public static String httpPost(String url,Map<String,Object> header,String json){

        //初始化header公共参数
        HttpHeaders httpHeaders = initHeader();
        setHeaderParam(httpHeaders,header);
        //发送请求
        return toPost(url,httpHeaders,json).getBody();
    }


    /**
     * 发送POST请求
     * @param url 请求地址
     * @param headers 请求头参数
     * @param param 查询参数
     * @return
     */
    public static String httpPost(String url, Map<String,Object> headers,Map<String,Object> param){
        HttpHeaders httpHeaders;
        if (headers != null){
            //初始化header公共参数
             httpHeaders = initHeader();
        }else {
             httpHeaders = initHeaderX();
        }

        //设置header参数
        setHeaderParam(httpHeaders,headers);
        //设置参数
        MultiValueMap<String,Object> valueMap = setParam(param);
        return toPost(url,httpHeaders,valueMap);

    }

    /**
     * 发送请求
     * @param valueMap
     * @param httpHeaders
     * @param url
     * @return
     */
    private static String toPost(String url,HttpHeaders httpHeaders,MultiValueMap<String,Object> valueMap){
        HttpEntity<MultiValueMap<String,Object>> httpEntity = new HttpEntity<>(valueMap,httpHeaders);
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST,httpEntity,String.class);
        return responseEntity.getBody();
    }

    /**
     * 发送请求
     * @param json
     * @param httpHeaders
     * @param url
     * @return
     */
    private static ResponseEntity<String> toPost(String url,HttpHeaders httpHeaders,String json){
        HttpEntity<String> httpEntity = new HttpEntity<>(json,httpHeaders);
        ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST,httpEntity,String.class);
        return responseEntity;
    }




}

//将参数封装成JSON字符串，看实际情况
public static String k3cPushOPTRPT(String token,Long id,Long sbid,int seq){
        Map<String,Object> param = new HashMap<>(4);
        param.put("id",id);
        param.put("Token",token);
        param.put("sbid",sbid);
        param.put("Seq",seq);
        return JSON.toJSONString(param);
    }

//调用
public Result pushOPTRPT(String token,Long id,Long sbid,int seq){


        String cod = BaseUtil.k3cPushOPTRPT(token,id,sbid,seq);

        Map<String,Object> map = new HashMap<>();
        map.put("param",cod);

        String url = k3cloundconfig.K3CURL+k3cloundconfig.K3CPUSHOPTRPT;
        String stateTransfer = HttpUtil.httpPost(url,null,map);
       // return stateTransfer;
        JSONObject json=JSONObject.parseObject(stateTransfer);

        Result res = new Result();
        res.setCode(json.get("Code"));
        res.setMessage(json.get("Message"));
        JSONArray array = (JSONArray) json.get("ActualNews");
        if(array != null){
            res.setActualNews(JSONObject.parseArray(array.toJSONString(), Actual.class));
        }
        return res;
    }