Spring Boot 整合httpClient

老套路 ，引入maven 依赖

<!-- httpclient -->
		<dependency>
			<groupId>org.apache.httpcomponents</groupId>
			<artifactId>httpclient</artifactId>
			<version>4.3.1</version>
		</dependency>

		<!-- 获取配置文件 -->
		<dependency>
			<groupId>commons-configuration</groupId>
			<artifactId>commons-configuration</artifactId>
			<version>1.10</version>
		</dependency>

准备好配置文件：httpclient.properties

# 最大的连接数
httpclient.max.total=5
# 并发数
httpclient.max.route=2
# 数据传输的最长时间
httpclient.socket.timeout=50000
# 创建连接最长时间
httpclient.connect.timeout=50000
# 请求超时最长时间
httpclient.connection.request.timeout=50000
# 重试的次数
httpclient.retry.count=3
# 是否需要重试
httpclient.isretry=true
#提交请求前测试连接是否可用
httpclient.staleConnectionCheckEnabled=true


login.header_content=Content-Type
login.getHeader_content=application/x-www-form-urlencoded
login.user_name=root
login.pwd=123456
login.url=http://z15.51jiaofuv.com/Api/Account/Authenticate

将读取配置文件的对象配置注入到容器中：

package com.lxq.httpclient.config;

import org.apache.commons.configuration.ConfigurationException;
import org.apache.commons.configuration.PropertiesConfiguration;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Lxq
 * @Date 2020/3/21 11:59
 * @Version 1.0
 */
@Configuration
public class ConfigurationProperties {

    @Bean
    public PropertiesConfiguration getConfig() {
        try {
            return new PropertiesConfiguration("httpclient.properties");
        } catch (ConfigurationException e) {
            throw new RuntimeException("获取文件失败", e);
        }
    }

}

配置httpClient 连接池信息：

package com.lxq.httpclient.config;

import org.apache.http.client.config.RequestConfig;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpRequestRetryHandler;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author Lxq
 * @Date 2020/3/21 12:09
 * @Version 1.0
 */
@Configuration
public class HttpClientPool {

    @Autowired
    private org.apache.commons.configuration.Configuration configuration;


    /**
     * 实例化一个连接池管理器
     *
     * @return
     */
    @Bean(name = "httpClientConnectionManager")
    public PoolingHttpClientConnectionManager getHttpClientConnectionManager() {
        PoolingHttpClientConnectionManager manager = new PoolingHttpClientConnectionManager();
        // 设置最大连接数
        int maxTotal = configuration.getInt("httpclient.max.total");
        manager.setMaxTotal(maxTotal);
        // 设置并发数
        int defaultMaxPerRoute = configuration.getInt("httpclient.max.route");
        manager.setDefaultMaxPerRoute(defaultMaxPerRoute);
        return manager;
    }

    /**
     * 实例化连接池，设置管理器
     *
     * @param httpClientConnectionManager 连接池管理器
     * @return 连接池
     */
    @Bean(name = "httpClientBuilder")
    public HttpClientBuilder getHttpClientBuilder(@Qualifier("httpClientConnectionManager") PoolingHttpClientConnectionManager httpClientConnectionManager) {
        HttpClientBuilder httpClientBuilder = HttpClientBuilder.create();
        httpClientBuilder.setConnectionManager(httpClientConnectionManager);
        //设置重试的次数
        httpClientBuilder.setRetryHandler(new DefaultHttpRequestRetryHandler(
                configuration.getInt("httpclient.retry.count"), configuration.getBoolean("httpclient.isretry")));
        return httpClientBuilder;
    }

    /**
     * 注入连接池 获取httpclient
     *
     * @param httpClientBuilder httpClientBuilder 连接池
     * @return 获取httpclient
     */
    @Bean
    public CloseableHttpClient closeableHttpClient(@Qualifier("httpClientBuilder") HttpClientBuilder httpClientBuilder) {
        return httpClientBuilder.build();
    }

    /**
     * Builder是RequestConfig的一个内部类
     * 通过RequestConfig的custom方法来获取到一个Builder对象
     * 设置builder的连接信息
     *
     * @return
     */
    @Bean(name = "builder")
    public RequestConfig.Builder getBuilder() {
        RequestConfig.Builder builder = RequestConfig.custom();
        return builder.setConnectTimeout(configuration.getInt("httpclient.connect.timeout"))
                .setConnectionRequestTimeout(configuration.getInt("httpclient.connection.request.timeout"))
                .setSocketTimeout(configuration.getInt("httpclient.socket.timeout"))
                .setStaleConnectionCheckEnabled(configuration.getBoolean("httpclient.staleConnectionCheckEnabled"));
    }

    /**
     * 使用builder构建一个RequestConfig对象
     *
     * @param builder
     * @return
     */
    @Bean
    public RequestConfig getRequestConfig(@Qualifier("builder") RequestConfig.Builder builder) {
        return builder.build();
    }

}

配置关闭配置类：

package com.lxq.httpclient.config;

import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.pool.PoolStats;
import org.springframework.beans.factory.annotation.Autowired;

import javax.annotation.PreDestroy;

/**
 * @Author Lxq
 * @Date 2020/3/21 12:59
 * @Version 1.0
 * httpclient 关闭配置类
 */
public class HttpClientClose extends Thread{

    @Autowired
    private PoolingHttpClientConnectionManager manager;
    // 开关
    private volatile Boolean shutdown;

    public HttpClientClose() {
        // 线程开启启动
       this.start();
    }

    @Override
    public void run() {
        try {
            //如果服务没有关闭,执行线程
            while(!shutdown) {
                synchronized (this) {
                    wait(5000);            //等待5秒
                    //System.out.println("线程开始执行,关闭超时链接");
                    //关闭超时的链接
                    PoolStats stats = manager.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);
                    manager.closeExpiredConnections();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new RuntimeException();
        }

        super.run();
    }

    //关闭清理无效连接的线程
    @PreDestroy    //容器关闭时执行该方法.
    public void shutdown() {
        shutdown = true;
        synchronized (this) {
            //System.out.println("关闭全部链接!!");
            notifyAll(); //全部从等待中唤醒.执行关闭操作;
        }
    }
}

写个测试类测试一下（这一步可以提取为工具类）

package com.lxq.httpclient.service;

import com.lxq.httpclient.config.JsonResult;
import org.apache.commons.configuration.Configuration;
import org.apache.http.Consts;
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.impl.client.CloseableHttpClient;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.util.EntityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @Author Lxq
 * @Date 2020/3/21 13:04
 * @Version 1.0
 */
@Service
public class HttpClientService {

    @Autowired
    private CloseableHttpClient httpClient;

    @Autowired
    private RequestConfig requestConfig;

    @Autowired
    private Configuration configuration;


    public JsonResult doPost(String url, Map<String, Object> map) throws IOException {
        //声明httpPost请求
        HttpPost httpPost = new HttpPost(url);
        httpPost.setConfig(requestConfig);
        httpPost.setHeader(configuration.getString("login.header_content"),
                configuration.getString("login.getHeader_content"));
        // 封装表单对象
        if (map != null) {
            List<NameValuePair> params = new ArrayList<>();
            map.forEach((k, v) -> {
                params.add(new BasicNameValuePair(k, (String) v));
            });
            httpPost.setEntity(new UrlEncodedFormEntity(params, Consts.UTF_8));
        }
        // 发送请求
        CloseableHttpResponse response = httpClient.execute(httpPost);
        return new JsonResult<>(response.getStatusLine().getStatusCode(), "发送请求", EntityUtils.toString(response.getEntity(), "UTF-8"));

    }

    public String doGet(String url) throws Exception {
        // 声明 http get请求
        HttpGet httpGet = new HttpGet(url);
        System.out.println(url);
        // 装载配置信息
        httpGet.setConfig(requestConfig);
        //发起请求
        CloseableHttpResponse response = this.httpClient.execute(httpGet);
        //判断状态码是否为200
        if (response.getStatusLine().getStatusCode() == 200) {
            //返回响应体内容
            return EntityUtils.toString(response.getEntity(), "UTF-8");
        }
        return null;
    }

}

控制层调用一下，看一下效果：

package com.lxq.httpclient.controller;

import com.lxq.httpclient.config.JsonResult;
import com.lxq.httpclient.service.HttpClientService;
import org.apache.commons.configuration.Configuration;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author Lxq
 * @Date 2020/3/21 12:02
 * @Version 1.0
 */
@RestController
public class TestController {

    @Autowired
    private Configuration configuration;

    @Autowired
    private HttpClientService httpClientService;

    @GetMapping("/config")
    public String getHttpClientConfig() throws Exception {
        String s = httpClientService.doGet("http://www.baidu.com");
        System.out.println(s);
        return s;
    }

    @GetMapping("/login")
    public JsonResult loginFKWebByFKUserAndFKPWD() throws IOException {
        String login_url = configuration.getString("login.url");
        String login_user_name = configuration.getString("login.user_name");
        String login_pwd = configuration.getString("login.pwd");
        Map<String,Object> loginForm = new HashMap<>();
        loginForm.put("usernameOrEmailAddress",login_user_name);
        loginForm.put("password",login_pwd);
        JsonResult jsonResult = httpClientService.doPost(login_url, loginForm);
        return jsonResult;
    }

}