remote Request

import java.io.IOException;
import java.io.InputStream;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.security.GeneralSecurityException;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;

import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLException;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;

import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
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.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLContextBuilder;
import org.apache.http.conn.ssl.TrustStrategy;
import org.apache.http.conn.ssl.X509HostnameVerifier;
import org.apache.http.entity.StringEntity;
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 com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
 * 服务器端请求服务类
 *
 * @author Administrator
 * @date 2018年1月15日
 * @version 1.0
 */
@SuppressWarnings("deprecation")
public abstract class RequestService {
    /** jackJson 转化工具 **/
    private static final ObjectMapper mapper = new ObjectMapper();
    /** 连接池配置 **/
    private static PoolingHttpClientConnectionManager connMgr;
    /** requestConfig **/
    private static RequestConfig requestConfig;

    /** 日志 **/
    private static Logger logger = LoggerFactory.getLogger(RequestService.class);
    /** 服务器地址 **/
    private static final String HOST_PATH = H5FileUtils.getValueFromProperties("remote.server.host");
    /** 连接超时 **/
    private static final int CONNECTION_TIMEOUT = NumberUtils.toInt(H5FileUtils.getValueFromProperties("remote.conntection.timeout")) * 1000;

    static {
        // 设置连接池
        connMgr = new PoolingHttpClientConnectionManager();
        // 设置连接池大小
        connMgr.setMaxTotal(100);
        connMgr.setDefaultMaxPerRoute(connMgr.getMaxTotal());  

        RequestConfig.Builder configBuilder = RequestConfig.custom();
        // 设置连接超时
        configBuilder.setConnectTimeout(CONNECTION_TIMEOUT);
        // 设置读取超时
        configBuilder.setSocketTimeout(CONNECTION_TIMEOUT);
        // 设置从连接池获取连接实例的超时
        configBuilder.setConnectionRequestTimeout(CONNECTION_TIMEOUT);
        // 在提交请求之前 测试连接是否可用
        configBuilder.setStaleConnectionCheckEnabled(true);
        requestConfig = configBuilder.build();
    }

    /**
     * GET方式请求远端服务器数据
     * @param url
     * @return
     * @throws IOException
     * @throws ClientProtocolException
     */
    @SuppressWarnings("rawtypes")
    protected ResponseVO getRemoteReqData(String url){
        logger.debug(">>>getRemoteReqData(String url)");
        logger.debug("url:" + url);
        return this.getRemoteReqData(url, null);
    }

    /**默认采用不解码形式
     * GET方式请求远端服务器数据
     * @param url
     * @return
     * @throws IOException
     * @throws ClientProtocolException
     */
    @SuppressWarnings("rawtypes")
    protected ResponseVO getRemoteReqData(String url, String specifyUrl) {
        logger.debug(">>>getRemoteReqData(String url, String specifyUrl)");
        logger.debug("url:" + url);
        logger.debug("specifyUrl:" + specifyUrl);
        return this.getRemoteReqData(url, specifyUrl, CommonConstants.DECODE_N);
    }

    /**
     * GET方式请求远端服务器数据
     * @param url
     * @return ResponseVO
     * @throws IOException
     * @throws ClientProtocolException
     */
    @SuppressWarnings("rawtypes")
    protected ResponseVO getRemoteReqData(String url, String specifyUrl, String isDecode) {
        logger.debug(">>>getRemoteReqData(String url, String specifyUrl, String isDecode)");
        logger.debug("url:" + url);
        logger.debug("specifyUrl:" + specifyUrl);
        logger.debug("isDecode:" + isDecode);
        // 开启服务
        CloseableHttpClient client = getHttpClients(specifyUrl);

        // 主库判断
        if(StringUtils.isNotEmpty(specifyUrl)){
            url = specifyUrl + url;
        }else{
            url = getHostUrl() + url;
        }
        logger.debug("-> getUrl:" + url);
        HttpGet get = new HttpGet(url);
        ResponseVO respVO = null;
        try {
        HttpResponse response=client.execute(get);
        if(HttpStatus.SC_OK==response.getStatusLine().getStatusCode()){
            HttpEntity entity=response.getEntity();
            String returnValue = EntityUtils.toString(entity,CommonConstants.CHARSET_DEFAULT);
            // 解码判断
            if(StringUtils.equals(isDecode, CommonConstants.DECODE_Y)){
                returnValue = URLDecoder.decode(returnValue, CommonConstants.CHARSET_DEFAULT);
            }
            logger.debug("->getRequest:returnValue from remoteUrl: " + returnValue);
            respVO = mapper.readValue(returnValue, ResponseVO.class);
        }else if(HttpStatus.SC_NO_CONTENT==response.getStatusLine().getStatusCode()){
            respVO = new ResponseVO();
            respVO.setResponseCode("-1");
            respVO.setResponseMessage("远程连接未能接通！");
        }else if(HttpStatus.SC_NOT_FOUND==response.getStatusLine().getStatusCode()){
            respVO = new ResponseVO();
            respVO.setResponseCode("-1");
            respVO.setResponseMessage("远程连接地址未找到！");
        }else if(HttpStatus.SC_BAD_REQUEST ==response.getStatusLine().getStatusCode()) {
            respVO = new ResponseVO();
            respVO.setResponseCode("-1");
            respVO.setResponseMessage("远程接口需求数据与本地数据不匹配！");
        }
        } catch (ClientProtocolException e) {
            respVO = new ResponseVO();
            respVO.setResponseCode("-1");
            respVO.setResponseMessage("远程连接出现错误！");
            e.printStackTrace();
        } catch (IOException e) {
            respVO = new ResponseVO();
            respVO.setResponseCode("-1");
            respVO.setResponseMessage("远程端口出现错误！");
            e.printStackTrace();
        }
        logger.debug("<<<getRemoteReqData(String url, String specifyUrl, String isDecode)");
        return respVO;
    }

    /**
     * GET方式请求远端服务器流，
     * 因返回InputStream输入流，因此一定要try catch，关闭
     * @param url
     * @return InputStream
     * @throws IOException
     * @throws ClientProtocolException
     */
    protected InputStream getRemoteReqStream(String url) throws ClientProtocolException, IOException{
        logger.debug(">>>getRemoteReqStream(String url)");
        logger.debug("url:" + url);
        return getRemoteReqStream(url, null);
    }
    /**
     * GET方式请求远端服务器流，
     * 因返回InputStream输入流，因此一定要try catch，关闭
     * @param url
     * @return InputStream
     * @throws IOException
     * @throws ClientProtocolException
     */
    protected InputStream getRemoteReqStream(String url, String specifyUrl) throws ClientProtocolException, IOException{
        logger.debug(">>>getRemoteReqStream(String url, String specifyUrl)");
        logger.debug("url:" + url);
        logger.debug("specifyUrl:" + specifyUrl);
        // 主库判断
        if(StringUtils.isNotEmpty(specifyUrl)){
            url = specifyUrl + url;
        }else{
            url = getHostUrl() + url;
        }
        logger.debug("-> getStreamUrl:" + url);
        // 开启服务
        CloseableHttpClient client = getHttpClients(specifyUrl);
        HttpGet get=new HttpGet(url);
        InputStream is = null;
        HttpResponse response=client.execute(get);
        if(HttpStatus.SC_OK==response.getStatusLine().getStatusCode()){
            HttpEntity entity=response.getEntity();
            is = entity.getContent();
        }
        logger.debug("<<<getRemoteReqStream(String url, String specifyUrl)");
        return is;
    }

    /**
     * POST方式请求远端服务器数据
     * @param url
     * @return ResponseVO
     */
    @SuppressWarnings("rawtypes")
    protected ResponseVO postRemoteReqData(String url, HttpEntity entity){
        logger.debug(">>>postRemoteReqData(String url, HttpEntity entity)");
        logger.debug("url:" + url);
        logger.debug("entity:{}", entity);
        return postRemoteReqData(url, entity, null);
    }
    /**
     * 默认此方法不采用解码形式
     * POST方式请求远端服务器数据
     * @param url
     * @return ResponseVO
     */
    @SuppressWarnings("rawtypes")
    protected ResponseVO postRemoteReqData(String url, HttpEntity entity, String specifyUrl){
        logger.debug(">>>postRemoteReqData(String url, HttpEntity entity)");
        logger.debug("url:" + url);
        logger.debug("entity:{}", entity);
        logger.debug("specifyUrl：" + specifyUrl);
        return postRemoteReqData(url, entity, specifyUrl, CommonConstants.DECODE_N);
    }

    /**
     * post请求
     * @param rEMOTE_URL_GESTURE_SAVE
     * @param createParams
     * @param specifyUrl(指定url)
     * @return ResponseVO
     */
    @SuppressWarnings({"rawtypes"})
    public ResponseVO postRemoteReqData(String url, HttpEntity entity, String specifyUrl, String isDecode) {
        logger.debug(">>>postRemoteReqData(String url, HttpEntity entity, String specifyUrl, String isDecode)");
        logger.debug("url:" + url);
        logger.debug("entity:{}", entity);
        logger.debug("specifyUrl：" + specifyUrl);
        logger.debug("isDecode：" + isDecode);
        // 主库判断
        if(StringUtils.isNotEmpty(specifyUrl)){
            url = specifyUrl + url;
        }
        else{
            url = getHostUrl() + url;
        }
        logger.debug("-> postUrl:" + url);
        // 开启服务
        CloseableHttpClient client = getHttpClients(specifyUrl);
        //POST的URL
        HttpPost httpPost = new HttpPost(url);
        // 返回值
        ResponseVO respVO = null;
            //添加参数
            httpPost.setEntity(entity);
            HttpResponse response;
            try {
                response = client.execute(httpPost);

            if(HttpStatus.SC_OK==response.getStatusLine().getStatusCode()){
                String returnValue = EntityUtils.toString(response.getEntity(),CommonConstants.CHARSET_DEFAULT);
                // 解码判断
                if(StringUtils.equals(isDecode, CommonConstants.DECODE_Y)){
                    returnValue = URLDecoder.decode(returnValue, CommonConstants.CHARSET_DEFAULT);
                }
                logger.debug("->getRequest:returnValue from remoteUrl: " + returnValue);
                respVO = mapper.readValue(returnValue, ResponseVO.class);
            }else if(HttpStatus.SC_NO_CONTENT==response.getStatusLine().getStatusCode()){
                respVO = new ResponseVO();
                respVO.setResponseCode("-1");
                respVO.setResponseMessage("远程连接未能接通！");
            }else if(HttpStatus.SC_NOT_FOUND==response.getStatusLine().getStatusCode()){
                respVO = new ResponseVO();
                respVO.setResponseCode("-1");
                respVO.setResponseMessage("远程连接地址未找到！");
            }else if(HttpStatus.SC_BAD_REQUEST ==response.getStatusLine().getStatusCode()) {
                respVO = new ResponseVO();
                respVO.setResponseCode("-1");
                respVO.setResponseMessage("远程接口需求数据与本地数据不匹配！");
            }
            } catch (ClientProtocolException e) {
                respVO = new ResponseVO();
                respVO.setResponseCode("-1");
                respVO.setResponseMessage("远程连接出现错误！");
                e.printStackTrace();
            } catch (IOException e) {
                respVO = new ResponseVO();
                respVO.setResponseCode("-1");
                respVO.setResponseMessage("远程端口出现错误！");
                e.printStackTrace();
            }
            logger.debug("respVO：{}", respVO);
            logger.debug("<<<postRemoteReqData(String url, HttpEntity entity, String specifyUrl, String isDecode)");
        return respVO;
    }

    /**
     * 构建Request的Post String参数
     * @param names String[]
     * @param values String[]
     * @return HttpEntity
     * @throws UnsupportedEncodingException
     */
    protected HttpEntity createParams(String[] names, String[] values) {
        logger.debug(">>>createParams(String[] names, String[] values)");
        logger.debug("names:{}", names.toString());
        logger.debug("values:{}", values.toString());
        List<NameValuePair> paramsList = new ArrayList<NameValuePair>();
        HttpEntity entity = null;
        for(int i = 0; i < names.length; i++){
            paramsList.add(new BasicNameValuePair(names[i], values[i]));
        }
        try{
            entity = new UrlEncodedFormEntity(paramsList, CommonConstants.CHARSET_DEFAULT);
        }catch(UnsupportedEncodingException e){
            logger.debug("->UnsupportedEncodingException:", e);
        }
        logger.debug("paramsList:{}", paramsList);
        logger.debug("<<<createParams(String[] names, String[] values)");
        return entity;
    }

    /**
     * 构建Request的Post Json格式对象参数
     * @throws UnsupportedEncodingException
     */
    protected HttpEntity createJsonParams(Object jsonObject) {
        logger.debug(">>> createJsonParams(Object jsonObject)");
        logger.debug("jsonObject:{}", jsonObject);
        StringEntity entity = null;
        try{
            entity = new StringEntity(H5Utils.mapper.writeValueAsString(jsonObject), CommonConstants.CHARSET_DEFAULT);
            entity.setContentEncoding(CommonConstants.CHARSET_DEFAULT);
            entity.setContentType("application/json");
        } catch (JsonProcessingException e) {
            logger.debug("->JsonProcessingException:", e);
        }
        logger.debug("entity:{}", entity);
        logger.debug("<<<createJsonParams(Object jsonObject)");
        return entity;
    }

    /**
     * 获取服务地址
     * @return
     */
    private String getHostUrl(){
        logger.debug(">>>getHostUrl()");
        String url = HOST_PATH;
        logger.debug("url:" + url);
        logger.debug("<<<getHostUrl()");
        return url;
    }

    /**
     * 根据http请求或者https请求，获取httpClients
     * @return
     */
    private CloseableHttpClient getHttpClients(String specifyUrl) {
        logger.debug(">>>getHttpClients(String specifyUrl)");
        logger.debug("specifyUrl:" + specifyUrl);
        // https问题
        CloseableHttpClient httpClient = null;
        if(StringUtils.isNotEmpty(specifyUrl) && specifyUrl.indexOf("https:") > 0){
            httpClient = HttpClients.custom().setSSLSocketFactory(createSSLConnSocketFactory()).setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
        }else{
            httpClient = HttpClients.custom().setConnectionManager(connMgr).setDefaultRequestConfig(requestConfig).build();
            logger.debug("provIp: " + specifyUrl);
        }
        logger.debug("<<<getHttpClients(String specifyUrl)");
        return httpClient;
    }

    /**
     * 转化List为对象List
     * @param class1
     * @return
     */
    @SuppressWarnings("rawtypes")
    protected List<?> convertListToObject(List originalList,Class<?> class1) {
        logger.debug(">>>convertListToObject(List originalList,Class<?> class1)");
        logger.debug("originalList:{}", originalList);
        logger.debug("class1:{}", class1);
        List<Object> list = null;
        try{
            if(!CollectionUtils.isEmpty(originalList)){
                list = new ArrayList<Object>();
                for(Object obj : originalList){
                    Object target = class1.newInstance();
                    BeanUtils.copyProperties(target, obj);
                    list.add(target);
                }
            }
        } catch(Exception e){
            e.printStackTrace();
            list = null;
        }
        logger.debug("<<<convertListToObject(List originalList,Class<?> class1)");
        return list;
    }

    /**
     * 创建SSL安全连接
     *
     * @return
     */
    private static SSLConnectionSocketFactory createSSLConnSocketFactory() {
        logger.debug(">>>createSSLConnSocketFactory()");
        SSLConnectionSocketFactory sslsf = null;
        try {
            SSLContext sslContext = new SSLContextBuilder().loadTrustMaterial(null, new TrustStrategy() {  

                @Override
                public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                    return true;
                }
            }).build();
            sslsf = new SSLConnectionSocketFactory(sslContext, new X509HostnameVerifier() {  

                @Override
                public boolean verify(String arg0, SSLSession arg1) {
                    return true;
                }  

                @Override
                public void verify(String host, SSLSocket ssl) throws IOException {
                }  

                @Override
                public void verify(String host, X509Certificate cert) throws SSLException {
                }  

                @Override
                public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
                }
            });
        } catch (GeneralSecurityException e) {
            e.printStackTrace();
        }
        logger.debug("sslsf:{}", sslsf);
        logger.debug("<<<createSSLConnSocketFactory()");
        return sslsf;
    }

}

简单的remote Request：

        HttpClient client = new DefaultHttpClient();
        HttpPost post = new HttpPost(url);
         // 请求超时
        client.getParams().setParameter(CoreConnectionPNames.CONNECTION_TIMEOUT, 2000);
        post.addHeader("Content-type","application/x-www-form-urlencoded;charset=utf-8");
        post.setEntity(entity);
        try {
            client.execute(post);
        } catch (ClientProtocolException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }