HttpClient介绍及入门

HttpClient介绍
HTTP 协议可能是现在 Internet 上使用得最多、最重要的协议了，越来越多的 Java 应用程序需要直接通过 HTTP 协议来访问网络资源。用来提供高效的、最新的、功能丰富的支HTTP 协议的客户端编程工具包。

jar包

<!--添加httpClient jar包 -->
        <dependency>
            <groupId>org.apache.httpcomponents</groupId>
            <artifactId>httpclient</artifactId>
        </dependency>

入门案例

//开发springCloud远程调用的源码 /是开发银行SDK的中组件/访问其他服务器数据的万能用法
public class TestHttpClient {  
    /**
     * 步骤:
     *  1.确定目标服务器的网址
     *  2.定义请求类型    get/post/put/delete
     *  3.创建httpClient工具API对象
     *  4.发起http请求,获取服务器响应数据.
     *  5.获取服务器响应之后开始解析数据. 判断状态码信息 200/404/406/500/504
     *  6.获取数据执行业务调用.
     *  
     *  httpClient可以当做简单的爬虫使用 JSOUP/PYTHON
     * @throws IOException 
     * @throws ClientProtocolException 
     */
    @Test
    public void testGet() throws ClientProtocolException, IOException {
        String url = "https://www.baidu.com";
        HttpGet httpGet = new HttpGet(url);
        HttpClient httpClient = HttpClients.createDefault();
        HttpResponse httpResponse = httpClient.execute(httpGet);
        int status = httpResponse.getStatusLine().getStatusCode();
        if(status == 200) {
            //表示请求正确
            HttpEntity httpEntity = httpResponse.getEntity();   //获取响应数据
            String data = EntityUtils.toString(httpEntity, "UTF-8");
            System.out.println(data);
        }else {
            System.out.println("请求有误!!!!!!!!!"+status);
        }
    }
}       

整合HttpClient

#最大连接数
http.maxTotal = 1000
#并发数
http.defaultMaxPerRoute = 20
#创建连接的最长时间
http.connectTimeout=5000
#从连接池中获取到连接的最长时间
http.connectionRequestTimeout=500
#数据传输的最长时间
http.socketTimeout=5000
#提交请求前测试连接是否可用
http.staleConnectionCheckEnabled=true

编辑HttpClientConfig配置类

@Configuration
@PropertySource(value="classpath:/properties/httpClient.properties")
public class HttpClientConfig {
    @Value("${http.maxTotal}")
    private Integer maxTotal;                       //最大连接数
?
    @Value("${http.defaultMaxPerRoute}")
    private Integer defaultMaxPerRoute;             //最大并发链接数
?
    @Value("${http.connectTimeout}")
    private Integer connectTimeout;                 //创建链接的最大时间
?
    @Value("${http.connectionRequestTimeout}") 
    private Integer connectionRequestTimeout;       //链接获取超时时间
?
    @Value("${http.socketTimeout}")
    private Integer socketTimeout;                  //数据传输最长时间
?
    @Value("${http.staleConnectionCheckEnabled}")
    private boolean staleConnectionCheckEnabled;    //提交时检查链接是否可用
?
    //定义httpClient链接池
    @Bean(name="httpClientConnectionManager")
    public PoolingHttpClientConnectionManager getPoolingHttpClientConnectionManager() {
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        manager.setMaxTotal(maxTotal);  //设定最大链接数
        manager.setDefaultMaxPerRoute(defaultMaxPerRoute);  //设定并发链接数
        return manager;
    }
?
    //定义HttpClient
    /**
     * 实例化连接池，设置连接池管理器。
     * 这里需要以参数形式注入上面实例化的连接池管理器
       @Qualifier 指定bean的ID为参数赋值
     */
    @Bean(name = "httpClientBuilder")
    public HttpClientBuilder getHttpClientBuilder(@Qualifier("httpClientConnectionManager")PoolingHttpClientConnectionManager httpClientConnectionManager){
?
        //HttpClientBuilder中的构造方法被protected修饰，所以这里不能直接使用new来实例化一个HttpClientBuilder,可以使用HttpClientBuilder提供的静态方法create()来获取HttpClientBuilder对象
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        httpClientBuilder.setConnectionManager(httpClientConnectionManager);
        return httpClientBuilder;
    }
?
    /**
     *  注入连接池，用于获取httpClient
     * @param httpClientBuilder
     * @return
     */
    @Bean
    public CloseableHttpClient getCloseableHttpClient(@Qualifier("httpClientBuilder") HttpClientBuilder httpClientBuilder){
?
        return httpClientBuilder.build();
    }
    
    /**
     * Builder是RequestConfig的一个内部类
      * 通过RequestConfig的custom方法来获取到一个Builder对象
      * 为请求设定超时时间
     * @return
     */
    @Bean(name = "builder")
    public RequestConfig.Builder getBuilder(){
        RequestConfig.Builder builder = RequestConfig.custom();
        return builder.setConnectTimeout(connectTimeout)
                .setConnectionRequestTimeout(connectionRequestTimeout)
                .setSocketTimeout(socketTimeout)
                .setStaleConnectionCheckEnabled(staleConnectionCheckEnabled);
    }
?
    /**
     * 使用builder构建一个RequestConfig对象
     * @param builder
     * @return
     */
    @Bean
    public RequestConfig getRequestConfig(@Qualifier("builder") RequestConfig.Builder builder){
        return builder.build();
    }
}

关闭超时连接

//该类的作用  定期将超时的链接自动关闭.
@Component  //交给spring容器管理
public class HttpClientClose extends Thread{
    @Autowired
    private PoolingHttpClientConnectionManager manage;
    private volatile boolean shutdown;  
    //开关 volatitle表示多线程可变数据,一个线程修改,其他线程立即修改
    
    public HttpClientClose() {
        ///System.out.println("执行构造方法,实例化对象");
        //线程开启启动
        this.start();
    }
    
    
    @Override
    public void run() {
        try {
            //如果服务没有关闭,执行线程
            while(!shutdown) {
                synchronized (this) {
                    wait(5000);         //等待5秒
                    //System.out.println("线程开始执行,关闭超时链接");
                    //关闭超时的链接
                    PoolStats stats = manage.getTotalStats();
                    int av = stats.getAvailable();  //获取可用的线程数量
                    int pend = stats.getPending();  //获取阻塞的线程数量
                    int lea = stats.getLeased();    //获取当前正在使用的链接数量
                    int max = stats.getMax();
                    //System.out.println("max/"+max+":  av/"+av+":  pend/"+pend+":   lea/"+lea);
                    manage.closeExpiredConnections();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }
?
        super.run();
    }
?
    //关闭清理无效连接的线程
    @PreDestroy //容器关闭时执行该方法.
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            //System.out.println("关闭全部链接!!");
            notifyAll(); //全部从等待中唤醒.执行关闭操作;
        }
    }
}

volatile
多线程内数据的共享变量,如果有一个线程将数据修改,则其他线程也会同步修改数据.