后端请求http协议的接口方法已经封装

 首先设置一下http的请求内容

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory){
        return new RestTemplate(factory);
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        //设置超时时间
        factory.setConnectTimeout(15000);
        factory.setReadTimeout(5000);
        return factory;
    }
}

 http的请求工具类

public class HttpUtil<T> {

    @Autowired
    private RestTemplate restTemplate;

    /**
     * get请求，单一访问，不带参数
     *
     * @param url   访问地址
     * @param clazz 得到的结果的返回类型
     * @return 返回的是最终的返回结果
     */
    public T getMethodBody(String url, Class<T> clazz) {
        ResponseEntity<String> exchange = restTemplate.getForEntity(url, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * get请求，带上请求头，不带参数
     *
     * @param url     访问地址
     * @param clazz   最终返回的接口的类型类的反射
     * @param headers 请求头内容，使用Map<String,String>，更容易辨认
     * @return
     */
    public T getMethodBody(String url, Class<T> clazz, Map<String, String> headers) {
        HttpHeaders requestHeaders = new HttpHeaders();
        headers.forEach((key, value) -> {
            requestHeaders.set(key, value);
        });
        HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * get请求，带上请求头，带参数
     *
     * @param url     访问地址
     * @param clazz   最终返回的接口的类型类的反射
     * @param headers 请求头内容，使用Map<String,String>，更容易辨认
     * @param params  参数，使用Map<String,String>
     * @return
     */
    public T getMethodBody(String url, Map<String, String> params, Class<T> clazz, Map<String, String> headers) {
        if (params == null && headers == null) {
            return this.getMethodBody(url, clazz);
        }
        if (headers == null) {
            return this.getMethodBody(url, clazz);
        }
        if (params == null) {
            return this.getMethodBody(url, clazz);
        }
        HttpHeaders requestHeaders = new HttpHeaders();
        headers.forEach((key, value) -> {
            requestHeaders.set(key, value);
        });
        String paramStr = "?";
        int i = 0;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (i != 0) {
                paramStr = paramStr + entry.getKey() + "=" + entry.getValue();
            } else {
                paramStr = "&" + paramStr + entry.getKey() + "=" + entry.getValue();
            }
            i++;
        }
        url += paramStr;
        HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * get请求，不带上请求头，带参数
     *
     * @param url    访问地址
     * @param params 参数，使用Map<String,String>
     * @param clazz  最终返回的接口的类型类的反射
     * @return
     */
    public T getMethodBody(String url, Map<String, String> params, Class<T> clazz) {
        String paramStr = "?";
        int i = 0;
        for (Map.Entry<String, String> entry : params.entrySet()) {
            if (i != 0) {
                paramStr = paramStr + entry.getKey() + "=" + entry.getValue();
            } else {
                paramStr = "&" + paramStr + entry.getKey() + "=" + entry.getValue();
            }
            i++;
        }
        url += paramStr;
        ResponseEntity<String> exchange = restTemplate.getForEntity(url, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * post请求，不带任何参数和请求头
     * @param url 请求地址
     * @param clazz 最终返回结果封装的类型
     * @return 放回封装后的放回结果
     */
    public T postMethodBody(String url, Class<T> clazz) {
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, null, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * post请求，带请求头，不带参数
     * @param url 请求地址
     * @param clazz 最终返回结果封装的类型
     * @param headers 请求头 ，用Map<String ,String>
     * @return 放回封装后的放回结果
     */
    public T postMethodBody(String url, Class<T> clazz, Map<String, String> headers) {
        HttpHeaders requestHeaders = new HttpHeaders();
        headers.forEach((key, value) -> {
            requestHeaders.set(key, value);
        });
        HttpEntity<String> requestEntity = new HttpEntity<String>(null, requestHeaders);
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * post请求，带请求头，带参数
     * @param url 请求地址
     * @param clazz 最终返回结果封装的类型
     * @param params 参数 ，用Map<String ,String>
     * @param headers  请求头 ，用Map<String ,String>
     * @return 放回封装后的放回结果
     */
    public T postMethodBody(String url, Map<String, String> params,Class<T> clazz, Map<String, String> headers) {
        HttpHeaders requestHeaders = new HttpHeaders();
        headers.forEach((key, value) -> {
            requestHeaders.set(key, value);
        });
        JSONObject msg = new JSONObject();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            msg.put(entry.getKey(),entry.getValue());
        }
        HttpEntity<String> requestEntity = new HttpEntity<String>(msg.toJSONString(), requestHeaders);
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }

    /**
     * post请求，不带请求头，带参数
     * @param url 请求地址
     * @param clazz 最终返回结果封装的类型
     * @param params 参数 ，用Map<String ,String>
     * @return 放回封装后的放回结果
     */
    public T postMethodBody(String url,  Map<String, String> params,Class<T> clazz) {
        JSONObject msg = new JSONObject();
        for (Map.Entry<String, String> entry : params.entrySet()) {
            msg.put(entry.getKey(),entry.getValue());
        }
        HttpEntity<String> requestEntity = new HttpEntity<String>(msg.toJSONString(), null);
        ResponseEntity<String> exchange = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
        return JSONObject.parseObject(exchange.getBody(), clazz);
    }


}