调用不需要证书认证的HTTPS接口，兼容http接口

不使用证书调用HTTPS接口，支持HTTP接口

package com.xysd.oauthSSO.service;

import java.io.IOException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;

import org.apache.http.Consts;
import org.apache.http.HttpEntity;
import org.apache.http.NameValuePair;
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.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.NoopHostnameVerifier;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;

public class CloseableHttpClientUtils {
	private static Logger logger = LoggerFactory.getLogger(CloseableHttpClientUtils.class);


    public static void main(String[] args) {
    	Map<String,Object> headers = new HashMap<String,Object>();
    	headers.put("Accept", "application/json");
    	Map<String,Object> param = new HashMap<String,Object>();
    	param.put("tel", "18611256473");
        sendRequest("POST","https://tcc.taobao.com/cc/json/mobile_tel_segment.htm",headers,param);
    }

    /**
     * @param type	请求方式
     * @param url	请求路径
     * @param headers	请求头
     * @param param	请求参
     */
	public static String sendRequest(String type,String url,Map<String,Object> headers,Map<String,Object> param) {
		HttpPost httpPost = null;
		HttpGet  httpGet  = null;
		HttpEntity entity = null;
	
	 try { 
		//设置请求方式，添加请求参 
		if("POST".equals(type)){
			url =  appendParam(url,param);
			httpPost = new HttpPost(url);
			/*  entity=new UrlEncodedFormEntity(createParam(param), Consts.UTF_8);
	        httpPost.setEntity(entity);	*/
	       
		}else if("GET".equals(type)){
			 URIBuilder uriBuilder = new URIBuilder(url);
			 uriBuilder.setParameters(createParam(param));
			 httpGet = new HttpGet(uriBuilder.build());
		}
			
		//设置请求头
		 Set<String> keys = headers.keySet();
	     for (String key : keys) {
	    	 if(httpPost !=null){
	    		 httpPost.setHeader(key, headers.get(key).toString());
	    	 }else if(httpGet !=null){
	    		 httpGet.setHeader(key, headers.get(key).toString());
	    	 }
	     }
       
        RequestConfig config = RequestConfig.custom()
        		.setConnectTimeout(60000).setSocketTimeout(10000).build();

        //在调用SSL之前需要重写验证方法，取消检测SSL
        X509TrustManager trustManager = new X509TrustManager() {
            @Override public X509Certificate[] getAcceptedIssuers() {
                return null;
            }
            @Override public void checkClientTrusted(X509Certificate[] xcs, String str) {}
            @Override public void checkServerTrusted(X509Certificate[] xcs, String str) {}
        };
        
        SSLContext ctx = SSLContext.getInstance(SSLConnectionSocketFactory.TLS);
        ctx.init(null, new TrustManager[] { trustManager }, null);
        SSLConnectionSocketFactory socketFactory = new SSLConnectionSocketFactory(ctx, NoopHostnameVerifier.INSTANCE);

        
        Registry<ConnectionSocketFactory> socketFactoryRegistry =
                RegistryBuilder.<ConnectionSocketFactory>create()
                        .register("http", PlainConnectionSocketFactory.INSTANCE)
                        .register("https", socketFactory).build();
        PoolingHttpClientConnectionManager mananger = new PoolingHttpClientConnectionManager(socketFactoryRegistry);

        CloseableHttpClient client = HttpClients.custom()
                .setDefaultRequestConfig(config).setConnectionManager(mananger).build();
       
        	
        //发送请求
        	CloseableHttpResponse response  =  client.execute(httpPost == null?httpGet:httpPost);
        	entity =  response.getEntity();
        	String result= EntityUtils.toString(entity, "UTF-8");
        	if(response.getStatusLine().getStatusCode()==200){
        		if(httpGet!=null){
        			logger.info(httpGet.getURI()+"\n 访问成功  \n "+result);
        		}else{
        			logger.info(url+" 访问成功  \n"+result);
        		}
                return result;
            }else{
            	logger.info(url+" 访问失败 \n"+response.getStatusLine().getStatusCode());
                return result;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }finally{
        	try {
				EntityUtils.consume(entity);
			} catch (IOException e) {
				e.printStackTrace();
			}
        }
	  return null;
	}
    
	
	  private static SSLContext getSSLContext() {
	        try {
	            // 这里可以填两种值 TLS和LLS , 具体差别可以自行搜索
	            SSLContext sc = SSLContext.getInstance("TLS");
	            // 构建新对象
	            X509TrustManager manager = new X509TrustManager() {
	                @Override
	                public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
	                }

	                @Override
	                public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
	                }

	                // 这里返回Null
	                @Override
	                public X509Certificate[] getAcceptedIssuers() {
	                    return null;
	                }
	            };
	            sc.init(null, new TrustManager[]{manager}, null);
	            return sc;
	        } catch (Exception e) {
	            e.printStackTrace();
	        }
	        return null;
	    }
	  
	  private static String appendParam(String url,Map<String, Object> param){
		  StringBuffer sb = new StringBuffer(url);
		  int i=0;
		  for(String k : param.keySet()) {
//			  logger.info("参数："+k+" 值: "+param.get(k).toString());
			  if(i==0){
				  sb.append("?"+k+"="+param.get(k).toString());
			  }else{
				  sb.append("&"+k+"="+param.get(k).toString());
			  }
			  i++;
		  }
		  return sb.toString();
	  }
	  
	  private static List<NameValuePair> createParam(Map<String, Object> param) {
	        //建立一个NameValuePair数组，用于存储欲传送的参数
	        List<NameValuePair> nvps = new ArrayList <NameValuePair>();
	        if(param != null) {
	            for(String k : param.keySet()) {
//	            	logger.info("参数："+k+" 值: "+param.get(k).toString());
	                nvps.add(new BasicNameValuePair(k, param.get(k).toString()));
	            }
	        }
	        return nvps;
	    }  
}