在SpringBoot中使用RestTemplate详解

# 最大连接数
http.maxtotal=100

# 并发数
http.defaultmaxperroute=20

# 客户端创建连接超时时间
http.connecttimeout=10000

# 从连接池中获取到连接的最长时间
http.connectionrequesttimeout=500

# 服务端响应超时时间
http.sockettimeout=30000

# 提交请求前测试连接是否可用
http.staleconnectioncheckenabled=true

# 可用空闲连接过期时间,重用空闲连接时会先检查是否空闲时间超过这个时间，如果超过，释放socket重新建立
http.validateafterinactivity=3000000

import org.apache.http.header;
import org.apache.http.client.httpclient;
import org.apache.http.client.config.requestconfig;
import org.apache.http.config.registry;
import org.apache.http.config.registrybuilder;
import org.apache.http.conn.httpclientconnectionmanager;
import org.apache.http.conn.socket.connectionsocketfactory;
import org.apache.http.conn.socket.plainconnectionsocketfactory;
import org.apache.http.conn.ssl.sslconnectionsocketfactory;
import org.apache.http.impl.client.defaultconnectionkeepalivestrategy;
import org.apache.http.impl.client.defaulthttprequestretryhandler;
import org.apache.http.impl.client.httpclientbuilder;
import org.apache.http.impl.conn.poolinghttpclientconnectionmanager;
import org.apache.http.message.basicheader;
import org.springframework.beans.factory.annotation.value;
import org.springframework.context.annotation.bean;
import org.springframework.context.annotation.componentscan;
import org.springframework.context.annotation.configuration;
import org.springframework.context.annotation.propertysource;
import org.springframework.http.client.clienthttprequestfactory;
import org.springframework.http.client.httpcomponentsclienthttprequestfactory;
import org.springframework.web.client.resttemplate;

import java.util.arraylist;
import java.util.list;


@configuration
@componentscan("com.xxx")
@propertysource(value = {"classpath:/xxx.properties", "classpath:/yyy.properties"}, encoding = "utf-8")
public class xxxconfiguration {
    @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;

    @value("${http.validateafterinactivity}")
    private integer validateafterinactivity;

    /**
     * @description: rest模板
     * @return: org.springframework.web.client.resttemplate
     * @author: wsdhla
     * @date: 2022/06/27 16:34
     */
    @bean
    public resttemplate resttemplate() {
        return new resttemplate(httprequestfactory());
    }

    /**
     * @description: 请求连接池配置
     * @return: org.springframework.http.client.clienthttprequestfactory
     * @author: wsdhla
     * @date: 2022/06/27 16:35
     */
    @bean
    public clienthttprequestfactory httprequestfactory() {
        return new httpcomponentsclienthttprequestfactory(httpclient());
    }

    /**
     * @description: httpclient
     * @return: org.apache.http.client.httpclient
     * @author: wsdhla
     * @date: 2022/06/27 16:42
     */
    @bean
    public httpclient httpclient() {
        requestconfig requestconfig = requestconfig.custom()
                .setsockettimeout(sockettimeout)
                .setconnecttimeout(connecttimeout)
                .setstaleconnectioncheckenabled(staleconnectioncheckenabled)
                .setconnectionrequesttimeout(connectionrequesttimeout)
                .build();


        list<header> headers = new arraylist<>();
        headers.add(new basicheader("user-agent", "mozilla/5.0 (windows nt 6.1) applewebkit/537.36 (khtml, like gecko) chrome/31.0.1650.16 safari/537.36"));
        headers.add(new basicheader("accept-encoding", "gzip,deflate"));
        headers.add(new basicheader("accept-language", "zh-cn"));
        headers.add(new basicheader("connection", "keep-alive"));
        headers.add(new basicheader("content-type", "application/json;charset=utf-8"));

        return httpclientbuilder.create()
                .setdefaultrequestconfig(requestconfig)
                .setconnectionmanager(poolinghttpclientconnectionmanager())
                .setdefaultheaders(headers)
                .setkeepalivestrategy(new defaultconnectionkeepalivestrategy())
                .setretryhandler(new defaulthttprequestretryhandler(2, true))
                .build();
    }

    /**
     * @description: http连接管理器
     * @return: org.apache.http.conn.httpclientconnectionmanager
     * @author: wsdhla
     * @date: 2022/06/27 16:41
     */
    @bean
    public httpclientconnectionmanager poolinghttpclientconnectionmanager() {
        registry<connectionsocketfactory> registry = registrybuilder.<connectionsocketfactory>create()
                .register("http", plainconnectionsocketfactory.getsocketfactory())
                .register("https", sslconnectionsocketfactory.getsocketfactory())
                .build();

        poolinghttpclientconnectionmanager connectionmanager = new poolinghttpclientconnectionmanager(registry);
        connectionmanager.setmaxtotal(maxtotal);
        connectionmanager.setdefaultmaxperroute(defaultmaxperroute);
        connectionmanager.setvalidateafterinactivity(validateafterinactivity);

        return connectionmanager;
    }
}

import org.springframework.http.httpentity;
import org.springframework.http.httpheaders;
import org.springframework.http.httpmethod;
import org.springframework.http.responseentity;
import org.springframework.stereotype.component;
import org.springframework.web.client.restclientexception;
import org.springframework.web.client.resttemplate;

import javax.annotation.resource;
import java.util.map;


@component
public class resttemplateutils {

    private static resttemplate resttemplate;

    /**
     * post请求调用方式
     * @param url          请求url
     * @param requestbody  请求参数体
     * @param responsetype 返回对象类型
     * @return responseentity 响应对象封装类
     */
    public static <t> responseentity<t> post(string url, object requestbody, class<t> responsetype)
            throws restclientexception {
        return resttemplate.postforentity(url, requestbody, responsetype);
    }

    @resource
    public void setresttemplate(resttemplate resttemplate) {
        resttemplateutils.resttemplate = resttemplate;
    }
}

httpheaders headers = new httpheaders();
headers.setcontenttype(mediatype.application_json);
headers.add("acc-key", acc-key);

jsonobject requestparam = new jsonobject();
requestparam.put("code", code);
requestparam.put("message", message);

httpentity<string> requestbody = new httpentity<string>(json.tojsonstring(requestparam), headers);

responseentity<实体类> resp = resttemplateutils.post(url, requestbody, 实体类.class);

@configuration
public class httpclientextconfig {

    @conditionalonmissingbean(resttemplate.class)
    @bean
    public resttemplate resttemplate() {
        closeablehttpclient httpclient = httpclients.custom()
                .setconnectionmanager(new poolinghttpclientconnectionmanager())
                .build();

        httpcomponentsclienthttprequestfactory requestfactory = new httpcomponentsclienthttprequestfactory();
        requestfactory.sethttpclient(httpclient);

        return new resttemplate();
    }
}

<dependency>
    <groupid>org.apache.httpcomponents</groupid>
    <artifactid>httpclient</artifactid>
    <version>4.5.13</version>
</dependency>