用http协议调用接口

悠悠 2022-03-30 02:20 350阅读 0赞

public class HttpUtil \{

private static Log log = LogFactory.getLog(HttpUtil.class);  
      
    /** 
     * 定义编码格式 UTF-8 
     */  
    public static final String URL_PARAM_DECODECHARSET_UTF8 = "UTF-8";  
      
    /** 
     * 定义编码格式 GBK 
     */  
    public static final String URL_PARAM_DECODECHARSET_GBK = "GBK";  
    
    private static int connectionRequestTimeout = 120000;
    private static int connectionTimeOut = 120000;  
    private static int socketTimeOut = 120000;  
    
    private static CloseableHttpClient getHttpClient() {
    	RequestConfig requestConfig = RequestConfig.custom()
    			.setConnectionRequestTimeout(connectionRequestTimeout)
    			.setConnectTimeout(connectionTimeOut)
    			.setSocketTimeout(socketTimeOut).build();
    	return HttpClients.custom().setDefaultRequestConfig(requestConfig).build();
    }
    	 
    private static CloseableHttpClient getSSLHttpClient() {
    	try {
        	SSLContext context = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {
        	 
    	    	@Override
    	    	public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
    	    		return true;
    	    	}
        	}).build();
        	SSLConnectionSocketFactory sslsf = new SSLConnectionSocketFactory(context);
        	RequestConfig requestConfig = RequestConfig.custom()
        			.setConnectionRequestTimeout(connectionRequestTimeout)
        			.setConnectTimeout(connectionTimeOut)
        			.setSocketTimeout(socketTimeOut).build();
        	return HttpClients.custom().setSSLSocketFactory(sslsf).setDefaultRequestConfig(requestConfig).build();
    	} catch (KeyManagementException e) {
    		log.error("ssl context key management Exception {}", e);
        	throw new BaseException("ssl context key management Exception", e);
    	} catch (NoSuchAlgorithmException e) {
    		log.error("ssl context get instance faild, no such method {}", e);
        	throw new BaseException("ssl context get instance faild", e);
    	} catch (KeyStoreException e) {
    		log.error("ssl context key store Exception {}", e);
        	throw new BaseException("ssl context key store Exception", e);
    	}
    }
      
    /** 
     * POST方式提交数据 
     * @param url 
     *          待请求的URL 
     * @param params 
     *          要提交的数据 
     * @param enc 
     *          编码 
     * @return 
     *          响应结果 
     * @throws ClientProtocolException 
     * @throws IOException 
     *          IO异常 
     */  
    public static String URLPost(String url, Map<String, String> headers, Map<String, Object> params) throws ClientProtocolException, IOException{  
    	CloseableHttpClient client = getSSLHttpClient();
    	HttpPost post = new HttpPost(url);
    	for (Map.Entry<String, String> header : headers.entrySet()) {
    		post.setHeader(header.getKey(), header.getValue());
    	}
    	UrlEncodedFormEntity entity = new UrlEncodedFormEntity(buildPairList(params), getDefaultCharset(null));
    	post.setEntity(entity);

// HttpHost host = new HttpHost(“[ali.ugamenow.com][]”, 443, “https”);  
// HttpContext context = createBasicAuthContext(“alibaba”, “JhtF5d53Fdgl9d”, host);  
CloseableHttpResponse response = null;  
try \{  
response = client.execute(post);  
if (response == null || response.getStatusLine() == null || response.getStatusLine().getStatusCode() != HttpStatus.SC\_OK) \{  
log.error(“HttpUtil do http get request failed”);  
throw new BaseException(“HttpUtil do http get request failed”);  
\}  
HttpEntity httpEntity = response.getEntity();  
if (httpEntity == null) \{  
return StringUtils.EMPTY;  
\}  
String result = EntityUtils.toString(httpEntity, getDefaultCharset(httpEntity));  
EntityUtils.consume(httpEntity);  
return result;  
\} finally \{  
try \{  
if(response != null)\{  
response.close();  
\}  
client.close();  
\} catch (IOException e) \{  
log.error(“warning : httpRequestc close fail”, e);  
\}  
\}  
\}

/** 
     * GET方式提交数据 
     * @param url 
     *          待请求的URL 
     * @param params 
     *          要提交的数据 
     * @param enc 
     *          编码 
     * @return 
     *          响应结果 
     * @throws ClientProtocolException 
     * @throws IOException 
     *          IO异常 
     */  
    public static String doHttpGet(String url, Map<String, Object> params, Map<String, String> headers) throws ClientProtocolException, IOException {
    	CloseableHttpClient httpClient = null;
    	if (StringUtils.startsWith(url, "https")) {
    		httpClient = getSSLHttpClient();
    	} else {
    		httpClient = getHttpClient();
    	}
    	String queryUri = URLEncodedUtils.format(buildPairList(params), getDefaultCharset(null));
    	HttpGet httpGet = new HttpGet(url + "?" + queryUri);
    	RequestConfig requestConfig = RequestConfig.custom()
    			.setConnectionRequestTimeout(connectionRequestTimeout)
    			.setConnectTimeout(connectionTimeOut)
    			.setSocketTimeout(socketTimeOut).build();
    	httpGet.setConfig(requestConfig);
    	for (Map.Entry<String, String> header : headers.entrySet()) {
        	httpGet.addHeader(header.getKey(), header.getValue());
    	}
    	CloseableHttpResponse response = null;
    	try {
    		response = httpClient.execute(httpGet);
        	if (response == null || response.getStatusLine() == null || response.getStatusLine().getStatusCode() != HttpStatus.SC_OK) {
    	    	log.error("HttpUtil do http get request failed");
    	    	throw new BaseException("HttpUtil do http get request failed");
        	}
        	HttpEntity httpEntity = response.getEntity();
        	if (httpEntity == null) {
        		return StringUtils.EMPTY;
        	}
        	String result = EntityUtils.toString(httpEntity, getDefaultCharset(httpEntity));
        	EntityUtils.consume(httpEntity);
        	return result;
    	} finally {
        	try {
        	    if(response != null){
                    response.close();
        	    }
                httpClient.close();
        	} catch (IOException e) {
    	    	log.error("HttpUtil close httpClient occurs IOException {}", e);
        	}
    	}
    }
    
    private static List<BasicNameValuePair> buildPairList(Map<String, Object> params) {
    	if (params == null || params.isEmpty()) {
    		return new ArrayList<BasicNameValuePair>();
    	}
    	List<BasicNameValuePair> pairList = new ArrayList<BasicNameValuePair>();
    	for (Map.Entry<String, Object> entry : params.entrySet()) {
        	if (entry == null)
    	    	continue;
    	    pairList.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
        }
    	log.info("HttpUtil's name value pair size {}" + pairList.size());
        return pairList;
    }
    	 
    private static Charset getDefaultCharset(HttpEntity entity) {
    	if (entity == null){
        	return Charset.forName(CharEncoding.UTF_8);
    	}
    	ContentType contentType = ContentType.getOrDefault(entity);
    	return contentType.getCharset();
    }

//add by 15042020 start 20161012  
public static String getHttpCode(String url, String requestContent) \{

String result =null;
    	HttpClient httpClient = getHttpClient();
    	try {
    		// 创建Get方法实例
    		HttpPut httpPut = new HttpPut(url);
    		// 添加Content
    		if (!StringUtil.isEmpty(requestContent)) {
    			  StringEntity entity = new StringEntity(requestContent,"UTF-8");
    			  entity.setContentType("application/json;charset=UTF-8");
    			  entity.setContentEncoding("UTF-8");
    			  httpPut.setEntity(entity);
    		}
    
    		HttpResponse httpResponse = httpClient.execute(httpPut);
    
    		int httpCode = httpResponse.getStatusLine().getStatusCode();
    		
    		result=String.valueOf(httpCode);

/\* if (httpCode == HttpURLConnection.HTTP\_OK || httpCode == HttpURLConnection.HTTP\_NO\_CONTENT) \{  
String responseContent = EntityUtils.toString(httpResponse.getEntity());  
result = responseContent;  
\}\*/

} catch (Exception ex) {
    		log.error("", ex);
    	} finally {
    		httpClient.getConnectionManager().shutdown();
    	}
    	return result;
    }
    
    public static String getMethod(String url, String contentType) {
    	String result = null;
    	HttpClient httpClient = getHttpClient();
    	try {
    		// 创建Get方法实例
    		HttpGet httpGet = new HttpGet(url);
    		httpGet.setHeader("Content-Type", contentType);
    		HttpResponse response = httpClient.execute(httpGet);
    		HttpEntity entity = response.getEntity();
    		if (entity != null) {
    			//InputStream instreams = entity.getContent();
    			//result = StringUtil.convertStreamToString(instreams);
    			result = EntityUtils.toString(entity, "UTF-8");
    		}
    	} catch (ClientProtocolException cpe) {
    		// TODO For ClientProtocolException
    		log.error("", cpe);
    	} catch (IOException ioe) {
    		// TODO For IOException
    		log.error("", ioe);
    	} finally {
    		httpClient.getConnectionManager().shutdown();
    	}
    
    	return result;
    }
    //add by 15042020 end 20161012
    
    public static String doPostWithJsonInString(String url, String json){
        HttpClient client = getHttpClient();
        HttpPost post = new HttpPost(url);
        String response = null;
        try {
            StringEntity s = new StringEntity(json);
            s.setContentEncoding("UTF-8");
            s.setContentType("application/json");    // 发送json数据需要设置contentType
            post.setEntity(s);
            HttpResponse res = client.execute(post);
            if(res.getStatusLine().getStatusCode() == HttpStatus.SC_OK){
                HttpEntity entity = res.getEntity();
                response = EntityUtils.toString(entity);    // 返回json格式
            }
        } catch (Exception e) {
            throw new BaseException(e);
        }
        return response;
    }
    
    public static String doPostWithFormData(String url, Map<String, String> parameters) throws ClientProtocolException, IOException {
    	/*HttpUtil2 httpUtil = new HttpUtil2();
    	HttpResponseModel response = httpUtil.sendRequest(url, "post", parameters,
    			"application/x-www-form-urlencoded");
    	if (response==null) {
    		return null;
    	}
    	
    	return response.getContent();*/
    	
    	Map<String, String> headers = new HashMap<>();
    	headers.put("Content-Type", "application/x-www-form-urlencoded");
    	
    	Map<String, Object> params = new HashMap<>();
    	if (parameters!=null && !parameters.isEmpty()) {
    		Iterator<String> keys = parameters.keySet().iterator();
    		while(keys.hasNext()) {
    			String key = keys.next();
    			String value = parameters.get(key);
    			params.put(key, value);
    		}
    	}
    	
    	return URLPost(url, headers, params);
    }

[ali.ugamenow.com]: http://ali.ugamenow.com