http连接池配置

其他 2020-03-11 10:53:55 阅读次数: 0 
package com.sdyy.common.httpcon;

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.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
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.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.net.ssl.SSLContext;
import java.security.NoSuchAlgorithmException;

/**
 *
 * 　  * @className: HttpConnectionManager
 *
 * @description TODO
 * 　　* @param
 * 　　* @return
 * 　　* @throws
 * 　　* @author lizz
 * 　　* @date 2020  02 17 21:57
 *
 */
@Component
public class HttpConnectionManager {
    PoolingHttpClientConnectionManager cm = null;

    @PostConstruct
    public void init() {
        LayeredConnectionSocketFactory sslsf = null;
        try {
            sslsf = new SSLConnectionSocketFactory(SSLContext.getDefault());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }


        Registry<ConnectionSocketFactory> socketFactoryRegistry = RegistryBuilder.<ConnectionSocketFactory> create()
                .register("https", sslsf)
                .register("http", new PlainConnectionSocketFactory())
                .build();
        cm =new PoolingHttpClientConnectionManager(socketFactoryRegistry);
        cm.setMaxTotal(200);
        cm.setDefaultMaxPerRoute(20);
    }

    public CloseableHttpClient getHttpClient() {
        CloseableHttpClient httpClient = HttpClients.custom()
                .setConnectionManager(cm)
                .build();

        /*CloseableHttpClient httpClient = HttpClients.createDefault();//如果不采用连接池就是这种方式获取连接*/
        return httpClient;
    }
}


package com.sdyy.common.httpcon;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.sdyy.common.utils.ByteUtils;
import com.sdyy.common.utils.StringUtils;
import lombok.extern.log4j.Log4j;
import org.apache.commons.collections.MapUtils;
import org.apache.commons.io.IOUtils;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
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.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Iterator;
import java.util.Map;

/**
 *
 * 　  * @className: httpClient
 *
 * @description TODO
 * 　　* @param
 * 　　* @return
 * 　　* @throws
 * 　　* @author lizz
 * 　　* @date 2020  02 17 22:09
 *
 */
@Log4j
@Component
public class httpClient {
    @Autowired
    HttpConnectionManager connManager;
    /**
     * @Description:post （json）
     * @Author: lizz
     * @Date: 2020/2/17 22:17


     **/
    public  String httpPost(String url, JSONObject jsonParam) {
        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        if (null != jsonParam) {
            // 解决中文乱码问题
            StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
            entity.setContentEncoding("UTF-8");
            entity.setContentType("application/json");
            httpPost.setEntity(entity);
        }
        String json=null;
        CloseableHttpResponse response=null;
        try {
            response = httpClient.execute(httpPost);
            InputStream in=response.getEntity().getContent();
            json= IOUtils.toString(in);
            in.close();
        } catch (UnsupportedOperationException e) {
            log.error("调用失败："+e);
        } catch (IOException e) {
            log.error("调用失败："+e);
        }finally {
            if(response!=null){
                try {
                    response.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return json;
    }
    /**
     * @Description:get
     * @Author: lizz
     * @Date: 2020/2/17 22:20


     **/
    public  String httpGet(String url) {
        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpGet httpget = new HttpGet(url);
        String json=null;
        CloseableHttpResponse response=null;
        try {
            response = httpClient.execute(httpget);
            InputStream in=response.getEntity().getContent();
            json= IOUtils.toString(in);
            in.close();
        } catch (UnsupportedOperationException e) {
            log.error("调用失败："+e);
        } catch (IOException e) {
            log.error("调用失败："+e);
        }finally {
            if(response!=null){
                try {
                    response.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return json;
    }


    public  String httpGet_s(String url, Map headerMap, HttpServletResponse response, String retContentType) {
        // get请求返回结果
        String stringResult = null;
        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpGet httpget = new HttpGet(url);
        CloseableHttpResponse httpResponse=null;
        try {
            httpClient = HttpClients.createDefault();
            setHeader_Get(httpget, headerMap);
            httpResponse = httpClient.execute(httpget);

            // 请求发送成功，并得到响应
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                // 读取服务器返回过来的json字符串数据
                HttpEntity entity = httpResponse.getEntity();
                /***
                 * 2018.11.29 add by yangyang get方法的返回类型可能为二进制流型，在这里进行判断
                 */
                if (StringUtils.isEmpty(retContentType)) {
                    stringResult = EntityUtils.toString(entity, "utf-8");
                } else {
                    try {
                        byte[] responseBytes = ByteUtils.getData(entity);
                        retContentType = retContentType.replace("#", "/");
                        // response.setContentType("image/jpg");
                        // response.setContentType("application/octet-stream");
                        // //设置返回的文件类型
                        // response.setContentType("multipart/form-data");
                        // response.setContentType("application/vnd.ms-excel");
                        // response.setContentType("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
                        response.setContentType(retContentType);
                        OutputStream os = response.getOutputStream();
                        os.write(responseBytes);
                        os.flush();
                        os.close();
                    } catch (Exception e) {
                        log.error("流类型接口返回错误: " + e.getMessage());
                    }
                }

            } else {
                log.error("get请求提交失败:" + url);
            }
        } catch (IOException e) {
            log.error("get请求提交失败:" + url, e);
        } finally {
            if(response!=null){
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return stringResult;
    }


    public  String httpPost_s(String url, JSONObject jsonParam, Map headerMap) {
        // post请求返回结果
        String stringResult = null;
        CloseableHttpResponse httpResponse = null;

        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpPost httpPost = new HttpPost(url);


        try {
/*            System.out.println("___jsonParam___" + jsonParam);
            System.out.println("___headerMap___" + headerMap);*/
            httpClient = HttpClients.createDefault();
            setHeader_Post(httpPost, headerMap);
            if (null != jsonParam) {
                // 解决中文乱码问题
                StringEntity entity = new StringEntity(jsonParam.toString(), "utf-8");
                entity.setContentEncoding("UTF-8");
                entity.setContentType("application/json");
                httpPost.setEntity(entity);
            }
            httpResponse = httpClient.execute(httpPost);
            // 请求发送成功，并得到响应
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                // 读取服务器返回过来的json字符串数据
                stringResult = EntityUtils.toString(httpResponse.getEntity(), "utf-8");

            }
        } catch (IOException e) {
            log.error("post请求提交失败:" + url, e);
        } finally {
            if(httpResponse!=null){
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return stringResult;
    }




    public  String httpPost_s(String url, String strParam, Map headerMap) {
        // post请求返回结果
        String stringResult = null;
        CloseableHttpResponse httpResponse = null;

        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        try {
            httpClient = HttpClients.createDefault();
            setHeader_Post(httpPost, headerMap);
            if (null != strParam) {
                // 解决中文乱码问题
                StringEntity entity = new StringEntity(strParam, "utf-8");
                entity.setContentEncoding("UTF-8");
                entity.setContentType("application/x-www-form-urlencoded");
                httpPost.setEntity(entity);
            }
            httpResponse = httpClient.execute(httpPost);
            // 请求发送成功，并得到响应
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                // 读取服务器返回过来的json字符串数据
                stringResult = EntityUtils.toString(httpResponse.getEntity(), "utf-8");
            }
        } catch (IOException e) {
            log.error("post请求提交失败:" + url, e);
        } finally {
            if(httpResponse!=null){
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return stringResult;
    }




    public  String httpPost_x_s(String url, String strParam, Map headerMap) {
        // post请求返回结果
        String stringResult = null;
        CloseableHttpResponse httpResponse = null;

        CloseableHttpClient httpClient=connManager.getHttpClient();
        HttpPost httpPost = new HttpPost(url);
        try {
            httpClient = HttpClients.createDefault();
            setHeader_Post(httpPost, headerMap);
            if (null != strParam) {
                // 解决中文乱码问题
                StringEntity entity = new StringEntity(strParam, "utf-8");
                entity.setContentEncoding("UTF-8");
                entity.setContentType("application/xml");
                httpPost.setEntity(entity);
            }
            httpResponse = httpClient.execute(httpPost);
            // 请求发送成功，并得到响应
            if (httpResponse.getStatusLine().getStatusCode() == HttpStatus.SC_OK) {
                // 读取服务器返回过来的json字符串数据
                stringResult = EntityUtils.toString(httpResponse.getEntity(), "utf-8");
            }
        } catch (IOException e) {
            log.error("post请求提交失败:" + url, e);
        } finally {
            if(httpResponse!=null){
                try {
                    httpResponse.close();
                } catch (IOException e) {
                    log.error("调用失败："+e);
                }
            }
        }
        return stringResult;
    }









    private static void setHeader_Get(HttpGet request, Map headerMap) {
        if (!MapUtils.isEmpty(headerMap)) {
            Iterator entries = headerMap.entrySet().iterator();
            while (entries.hasNext()) {
                Map.Entry entry = (Map.Entry) entries.next();
                String key = (String) entry.getKey();
                String value = (String) entry.getValue();
                request.setHeader(key, value);
            }
        }
    }


        private static void setHeader_Post(HttpPost request, Map headerMap) {
            if (!MapUtils.isEmpty(headerMap)) {
                Iterator entries = headerMap.entrySet().iterator();
                while (entries.hasNext()) {
                    Map.Entry entry = (Map.Entry) entries.next();
                    String key = (String) entry.getKey();
                    String value = (String) entry.getValue();
                    request.setHeader(key, value);
                }
            }
        }





}
方方园园
发布了163 篇原创文章 · 获赞 9 · 访问量 1万+
私信 关注

猜你喜欢

转载自blog.csdn.net/qq_22041375/article/details/104521289
今日推荐
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
周排行
返回指定时间格式
fopen函数中的mode参数
Java 单例模式探讨
Flex remoteobject工作原理探讨
寻找mplayer的便捷安装方法
30天了解30种技术系列---(26)MySQL自动化运维工具Inception
关于Jboss/Tomcat/Jetty的JNDI定义123
程序减肥，strip，eu-strip 及其符号表
AsyncTask、View.post(Runnable)、ViewTreeObserver三种方式总结frame animation自动启动
Json和Bean的互相转换
每日归档
更多
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022