org.springframework.http.client.SimpleClientHttpRequestFactory

@Test
public void buildWithReadAndConnectTimeout() {
    ClientHttpRequestMessageSender messageSender = build(new HttpWebServiceMessageSenderBuilder().requestFactory(SimpleClientHttpRequestFactory::new).setConnectTimeout(Duration.ofSeconds(5)).setReadTimeout(Duration.ofSeconds(2)));
    SimpleClientHttpRequestFactory requestFactory = (SimpleClientHttpRequestFactory) messageSender.getRequestFactory();
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 5000);
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 2000);
}

private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    // TODO 3m5s, make configurable?
    requestFactory.setReadTimeout((60 * 1000 * 3) + 5000);
    RestTemplate template = new RestTemplate(requestFactory);
    String preplacedword = client.getPreplacedword();
    String authorization = client.getAuthorization();
    if (preplacedword != null && authorization != null) {
        throw new IllegalStateException("You must set either 'preplacedword' or 'authorization'");
    }
    if (preplacedword != null) {
        template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(new BasicAuthorizationInterceptor(client.getUsername(), preplacedword)));
    } else if (authorization != null) {
        template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(new GenericAuthorization(authorization)));
    }
    // 自定义 http header
    template.setInterceptors(Arrays.asList((ClientHttpRequestInterceptor) (httpRequest, bytes, clientHttpRequestExecution) -> {
        HttpHeaders headers = httpRequest.getHeaders();
        // TODO  通过netty交互，上报客户端 服务IP和端口号
        headers.add(LOCAL_PORT, client.getServerPort() + "");
        headers.add(LOCAL_HOST, RemotingUtil.getLocalHost());
        return clientHttpRequestExecution.execute(httpRequest, bytes);
    }));
    return template;
}

public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(10000);
    factory.setConnectTimeout(15000);
    return factory;
}

@Bean
@ConditionalOnMissingBean({ ClientHttpRequestFactory.clreplaced })
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    // ms
    factory.setReadTimeout(25000);
    // ms
    factory.setConnectTimeout(15000);
    return factory;
}

@Before
public void before() {
    log.info("=============================={}.{}==============================", this.getClreplaced().getSimpleName(), this.testName.getMethodName());
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    this.restTemplate = new RestTemplate(requestFactory);
}

@Before
public void before() {
    log.info("=============================={}.{}==============================", this.getClreplaced().getSimpleName(), this.testName.getMethodName());
    this.url = "http://localhost:" + this.listenPort + "/weevent-broker/admin/";
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    this.admin = new RestTemplate(requestFactory);
}

public static void main(String[] args) {
    System.out.println("This is WeEvent restful sample.");
    try {
        SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
        RestTemplate rest = new RestTemplate(requestFactory);
        // ensure topic exist "com.weevent.test"
        String topic = "com.weevent.test";
        ResponseEnreplacedy<BaseResponse<Boolean>> rsp = rest.exchange("http://localhost:7000/weevent-broker/rest/open?topic={topic}&groupId={groupId}", HttpMethod.GET, null, new ParameterizedTypeReference<BaseResponse<Boolean>>() {
        }, topic, WeEvent.DEFAULT_GROUP_ID);
        System.out.println(rsp.getBody().getData());
        // publish event to topic "com.weevent.test"
        SendResult sendResult = rest.getForEnreplacedy("http://localhost:7000/weevent-broker/rest/publish?topic={topic}&groupId={groupId}&content={content}", SendResult.clreplaced, topic, WeEvent.DEFAULT_GROUP_ID, "hello WeEvent".getBytes(StandardCharsets.UTF_8)).getBody();
        System.out.println(sendResult);
    } catch (RestClientException e) {
        e.printStackTrace();
    }
}

/**
 * factory for deploy.
 */
@Bean()
@Scope("prototype")
public SimpleClientHttpRequestFactory getHttpFactoryForDeploy() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    return factory;
}

/**
 * resttemplate for generic http request.
 */
@Bean(name = "genericRestTemplate")
public RestTemplate getRestTemplate() {
    SimpleClientHttpRequestFactory factory = getHttpFactoryForDeploy();
    // ms
    factory.setReadTimeout(constantProperties.getHttpTimeOut());
    // ms
    factory.setConnectTimeout(constantProperties.getHttpTimeOut());
    return new RestTemplate(factory);
}

/**
 * resttemplate for deploy contract.
 */
@Bean(name = "deployRestTemplate")
public RestTemplate getDeployRestTemplate() {
    SimpleClientHttpRequestFactory factory = getHttpFactoryForDeploy();
    // ms
    factory.setReadTimeout(constantProperties.getContractDeployTimeOut());
    // ms
    factory.setConnectTimeout(constantProperties.getContractDeployTimeOut());
    return new RestTemplate(factory);
}

/**
 * 自定义restTemplate ， 在发送的时候带上token
 * @return
 */
private RestTemplate customRestTemplate() {
    Map<String, String> headers = new HashMap<>();
    headers.put("token", "Bearer:" + jwtToken);
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    // TODO 3m5s make
    requestFactory.setReadTimeout((60 * 1000 * 3) + 5000);
    RestTemplate template = new RestTemplate(requestFactory);
    if (!headers.isEmpty()) {
        template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(new GenericRequestHeaderInterceptor(headers)));
    }
    return template;
}

@Bean
RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory clientHttpRequestFactory = new SimpleClientHttpRequestFactory();
    clientHttpRequestFactory.setConnectTimeout(2000);
    clientHttpRequestFactory.setReadTimeout(3000);
    RestTemplate restTemplate = new RestTemplate(clientHttpRequestFactory);
    restTemplate.setErrorHandler(new DefaultResponseErrorHandler() {

        @Override
        public boolean hasError(ClientHttpResponse response) throws IOException {
            try {
                return super.hasError(response);
            } catch (Exception e) {
                return true;
            }
        }

        @Override
        public void handleError(ClientHttpResponse response) throws IOException {
            try {
                super.handleError(response);
            } catch (Exception e) {
                log.error("Exception [" + e.getMessage() + "] occurred while trying to send the request", e);
                throw e;
            }
        }
    });
    return restTemplate;
}

// gh-50
@Test
void serverDoesNotBuffer() {
    ArtifactoryServer server = this.artifactory.server("https://example.com", null, null, null);
    RestTemplate restTemplate = (RestTemplate) ReflectionTestUtils.getField(server, "restTemplate");
    SimpleClientHttpRequestFactory requestFactory = (SimpleClientHttpRequestFactory) restTemplate.getRequestFactory();
    replacedertThat(ReflectionTestUtils.getField(requestFactory, "bufferRequestBody")).isEqualTo(Boolean.FALSE);
    replacedertThat(ReflectionTestUtils.getField(requestFactory, "outputStreaming")).isEqualTo(Boolean.TRUE);
}

private ClientHttpRequestFactory getRequestFactory(Proxy proxy) {
    SimpleClientHttpRequestFactory factory = (ConcourseSslContextFactory.isAvailable()) ? new SimpleSslClientHttpRequestFactory(new ConcourseSslContextFactory()) : new SimpleClientHttpRequestFactory();
    factory.setBufferRequestBody(false);
    factory.setProxy(proxy);
    return factory;
}

GoogleConfigEnvironment getRemoteEnvironment() throws IOException, HttpClientErrorException {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setReadTimeout(this.timeout);
    RestTemplate template = new RestTemplate(requestFactory);
    HttpEnreplacedy<Void> requestEnreplacedy = getAuthorizedRequest();
    ResponseEnreplacedy<GoogleConfigEnvironment> response = template.exchange(RUNTIMECONFIG_API_ROOT + ALL_VARIABLES_PATH, HttpMethod.GET, requestEnreplacedy, GoogleConfigEnvironment.clreplaced, this.projectId, this.name, this.profile);
    if (!response.getStatusCode().is2xxSuccessful()) {
        throw new HttpClientErrorException(response.getStatusCode(), "Invalid response from Runtime Configurator API");
    }
    return response.getBody();
}

/**
 * Restful 调用工具类
 *
 * @author wujing
 */
public final clreplaced HttpUtil {

    private HttpUtil() {
    }

    private static final Logger logger = LoggerFactory.getLogger(HttpUtil.clreplaced);

    private static SimpleClientHttpRequestFactory requestFactory = null;

    static {
        requestFactory = new SimpleClientHttpRequestFactory();
        // 连接超时时间，单位=毫秒
        requestFactory.setConnectTimeout(60000);
        // 读取超时时间，单位=毫秒
        requestFactory.setReadTimeout(60000);
    }

    private static RestTemplate restTemplate = new RestTemplate(requestFactory);

    public static JsonNode postForObject(String url, Map<String, Object> map) {
        logger.info("POST 请求， url={}，map={}", url, map.toString());
        return restTemplate.postForObject(url, map, JsonNode.clreplaced);
    }
}

/**
 * http调用工具类
 *
 * @author wujing
 */
public final clreplaced HttpUtil {

    private static final String APPLICATION_JSON = "application/json";

    private static final String CONTENT_TYPE_TEXT_JSON = "text/json";

    private static final String CHARSET_UTF_8 = "UTF-8";

    private static final int TIMEOUT = 10000;

    private HttpUtil() {
    }

    private static final Logger logger = LoggerFactory.getLogger(HttpUtil.clreplaced);

    private static SimpleClientHttpRequestFactory requestFactory = null;

    static {
        requestFactory = new SimpleClientHttpRequestFactory();
        // 连接超时时间，单位=毫秒
        requestFactory.setConnectTimeout(60000);
        // 读取超时时间，单位=毫秒
        requestFactory.setReadTimeout(60000);
    }

    private static RestTemplate restTemplate = new RestTemplate(requestFactory);

    public static JsonNode postForObject(String url, Map<String, Object> map) {
        logger.info("POST 请求， url={}，map={}", url, map.toString());
        return restTemplate.postForObject(url, map, JsonNode.clreplaced);
    }

    /**
     * @param url
     * @param param
     * @return
     */
    public static String postForPay(String url, Map<String, Object> param) {
        logger.info("POST 请求， url={}，map={}", url, param.toString());
        try {
            HttpPost httpPost = new HttpPost(url.trim());
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(TIMEOUT).setConnectionRequestTimeout(TIMEOUT).setSocketTimeout(TIMEOUT).build();
            httpPost.setConfig(requestConfig);
            List<NameValuePair> nvps = new ArrayList<NameValuePair>();
            for (Map.Entry<String, Object> entry : param.entrySet()) {
                nvps.add(new BasicNameValuePair(entry.getKey(), entry.getValue().toString()));
            }
            StringEnreplacedy se = new UrlEncodedFormEnreplacedy(nvps, CHARSET_UTF_8);
            httpPost.setEnreplacedy(se);
            HttpResponse httpResponse = HttpClientBuilder.create().build().execute(httpPost);
            return EnreplacedyUtils.toString(httpResponse.getEnreplacedy(), CHARSET_UTF_8);
        } catch (Exception e) {
            logger.info("HTTP请求出错", e);
            e.printStackTrace();
        }
        return "";
    }

    /**
     * @param url
     * @param param
     * @return
     */
    public static String post(String url, Map<String, Object> param) {
        logger.info("POST 请求， url={}，map={}", url, param.toString());
        try {
            HttpPost httpPost = new HttpPost(url.trim());
            RequestConfig requestConfig = RequestConfig.custom().setConnectTimeout(TIMEOUT).setConnectionRequestTimeout(TIMEOUT).setSocketTimeout(TIMEOUT).build();
            httpPost.setConfig(requestConfig);
            httpPost.addHeader(HTTP.CONTENT_TYPE, APPLICATION_JSON);
            StringEnreplacedy se = new StringEnreplacedy(param.toString(), CHARSET_UTF_8);
            se.setContentType(CONTENT_TYPE_TEXT_JSON);
            se.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, APPLICATION_JSON));
            httpPost.setEnreplacedy(se);
            HttpResponse httpResponse = HttpClientBuilder.create().build().execute(httpPost);
            return EnreplacedyUtils.toString(httpResponse.getEnreplacedy(), CHARSET_UTF_8);
        } catch (Exception e) {
            logger.info("HTTP请求出错", e);
            e.printStackTrace();
        }
        return "";
    }
}

/**
 * Restful 调用工具类
 *
 * @author wujing
 */
public clreplaced RestTemplateUtil {

    private static final Logger logger = LoggerFactory.getLogger(RestTemplateUtil.clreplaced);

    private static SimpleClientHttpRequestFactory requestFactory = null;

    static {
        requestFactory = new SimpleClientHttpRequestFactory();
        // 连接超时时间，单位=毫秒
        requestFactory.setConnectTimeout(60000);
        // 读取超时时间，单位=毫秒
        requestFactory.setReadTimeout(60000);
    }

    private static RestTemplate restTemplate = new RestTemplate(requestFactory);

    public static JsonNode postForObject(String url, Map<String, Object> map) {
        logger.info("POST 请求， url={}，map={}", url, map.toString());
        return restTemplate.postForObject(url, map, JsonNode.clreplaced);
    }
}

@Bean
@ConditionalOnMissingBean
@ConditionalOnBean(RestTemplate.clreplaced)
public AsyncRestTemplate asyncRestClientTemplate(RestTemplate restTemplate) {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setTaskExecutor(new SimpleAsyncTaskExecutor());
    return new AsyncRestTemplate(requestFactory, restTemplate);
}

@Bean
public RestTemplate buildRestTemplate() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(10000);
    factory.setConnectTimeout(15000);
    return new RestTemplate(factory);
}

@Bean
public RestTemplate restTemplate(TelegramProperties telegramProperties) {
    TelegramProxyProperties telegramPropertiesProxy = telegramProperties.getProxy();
    if (telegramPropertiesProxy.isEnable()) {
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        InetSocketAddress address = new InetSocketAddress(telegramPropertiesProxy.getHost(), telegramPropertiesProxy.getPort());
        Proxy proxy = new Proxy(Proxy.Type.HTTP, address);
        factory.setProxy(proxy);
        return new RestTemplate(factory);
    } else {
        return new RestTemplate();
    }
}

private SimpleClientHttpRequestFactory createStandardSpringRequestFactory(C config) {
    /* use standard Spring way, so uses configured trusted certificates etc. etc. */
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    if (config.isProxyDefined()) {
        Proxy proxy = new Proxy(Type.SOCKS, new InetSocketAddress(config.getProxyHostname(), config.getProxyPort()));
        requestFactory.setProxy(proxy);
    }
    return requestFactory;
}

@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    RestTemplate restTemplate = new RestTemplate();
    SimpleClientHttpRequestFactory factory = (SimpleClientHttpRequestFactory) restTemplate.getRequestFactory();
    // TODO there can do some for request
    return restTemplate;
}

private synchronized void initImpl() {
    if (!initialized) {
        initialized = true;
        if (impl == null) {
            impl = new RestTemplate();
        }
        if (networkTimeout != null) {
            ClientHttpRequestFactory requestFactory = impl.getRequestFactory();
            if (requestFactory instanceof SimpleClientHttpRequestFactory) {
                SimpleClientHttpRequestFactory simpleRequestFactory = (SimpleClientHttpRequestFactory) impl.getRequestFactory();
                simpleRequestFactory.setReadTimeout(networkTimeout.intValue());
            } else if (requestFactory instanceof HttpComponentsClientHttpRequestFactory) {
                HttpComponentsClientHttpRequestFactory apacheRequestFactory = (HttpComponentsClientHttpRequestFactory) impl.getRequestFactory();
                apacheRequestFactory.setReadTimeout(networkTimeout.intValue());
            } else if (requestFactory instanceof OkHttp3ClientHttpRequestFactory) {
                OkHttp3ClientHttpRequestFactory okhttpRequestFactory = (OkHttp3ClientHttpRequestFactory) impl.getRequestFactory();
                okhttpRequestFactory.setReadTimeout(networkTimeout.intValue());
            } else {
                throw new IllegalStateException("unknown type " + requestFactory);
            }
        }
        for (RestTemplateAdapterListener listener : nativeListeners) {
            listener.onBuild(impl);
        }
    }
}

public RestTemplate restTemplate(RegistryAuthAdapter registryAuthAdapter) {
    RestTemplate restTemplate = new RestTemplate();
    List<HttpMessageConverter<?>> converters = restTemplate.getMessageConverters();
    SimpleClientHttpRequestFactory rf = (SimpleClientHttpRequestFactory) restTemplate.getRequestFactory();
    rf.setReadTimeout(readTimeOut);
    rf.setConnectTimeout(connectTimeOut);
    restTemplate.setInterceptors(ImmutableList.of(new RegistryAuthInterceptor(registryAuthAdapter), HttpUserAgentInterceptor.getDefault()));
    for (HttpMessageConverter<?> converter : converters) {
        if (converter instanceof MappingJackson2HttpMessageConverter) {
            MappingJackson2HttpMessageConverter jsonConverter = (MappingJackson2HttpMessageConverter) converter;
            jsonConverter.setObjectMapper(objectMapper);
            // note that this content-type will be placed in Acceptable header
            jsonConverter.setSupportedMediaTypes(Arrays.asList(new MediaType("application", "json", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET), new MediaType("application", "*+json", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET), new MediaType("application", "*+prettyjws", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET), // it need for blobs (with json) from registry
            new MediaType("application", "octet-stream", MappingJackson2HttpMessageConverter.DEFAULT_CHARSET)));
        }
    }
    return restTemplate;
}

private static SimpleClientHttpRequestFactory createSimpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setTaskExecutor(new SimpleAsyncTaskExecutor());
    return requestFactory;
}

@Bean
@ConditionalOnMissingBean(RestTemplate.clreplaced)
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(5000);
    requestFactory.setReadTimeout(5000);
    return new RestTemplate(requestFactory);
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setConnectTimeout(15000);
    return factory;
}

@Bean
public ClientHttpRequestFactory clientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(20000);
    factory.setConnectTimeout(20000);
    return factory;
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    // ms
    factory.setReadTimeout(5000);
    // ms
    factory.setConnectTimeout(15000);
    return factory;
}

@Bean
public RestTemplate getRestTemplate() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(60 * 1000);
    requestFactory.setReadTimeout(2 * 60 * 1000);
    return new RestTemplate(requestFactory);
}

@Bean
public ClientHttpRequestFactory clientHttpRequestFactory() {
    List<ClientHttpRequestInterceptor> interceptors = Arrays.asList(getSecurityInterceptor());
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    Proxy proxy = this.properties.getRemote().getProxy();
    if (proxy.getHost() != null && proxy.getPort() != null) {
        requestFactory.setProxy(new java.net.Proxy(Type.HTTP, new InetSocketAddress(proxy.getHost(), proxy.getPort())));
    }
    return new InterceptingClientHttpRequestFactory(requestFactory, interceptors);
}

@Test
public void buildWithCustomTimeouts() {
    WebServiceMessageSender messageSender = this.builder.setConnectTimeout(Duration.ofSeconds(5)).setReadTimeout(Duration.ofSeconds(2)).build();
    SimpleClientHttpRequestFactory requestFactory = replacedertSimpleClientRequestFactory(messageSender);
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 5000);
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 2000);
}

private void doTest(AnnotationConfigServletWebServerApplicationContext context, String resourcePath) throws Exception {
    SimpleClientHttpRequestFactory clientHttpRequestFactory = new SimpleClientHttpRequestFactory();
    ClientHttpRequest request = clientHttpRequestFactory.createRequest(new URI("http://localhost:" + context.getWebServer().getPort() + resourcePath), HttpMethod.GET);
    try (ClientHttpResponse response = request.execute()) {
        String actual = StreamUtils.copyToString(response.getBody(), StandardCharsets.UTF_8);
        replacedertThat(actual).isEqualTo("Hello World");
    }
}

@Test
public void connectTimeoutCanBeConfiguredOnAWrappedRequestFactory() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    this.builder.requestFactory(() -> new BufferingClientHttpRequestFactory(requestFactory)).setConnectTimeout(Duration.ofMillis(1234)).build();
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 1234);
}

@Test
public void readTimeoutCanBeConfiguredOnAWrappedRequestFactory() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    this.builder.requestFactory(() -> new BufferingClientHttpRequestFactory(requestFactory)).setReadTimeout(Duration.ofMillis(1234)).build();
    replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 1234);
}

@Bean
SimpleClientHttpRequestFactory requestFactory() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(10000);
    requestFactory.setReadTimeout(120000);
    return requestFactory;
}

public static RestTemplate getTemplate(ClientHttpRequestInterceptor interceptor) {
    RestTemplate restTemplate = new RestTemplate();
    List<ClientHttpRequestInterceptor> ris = new ArrayList<>();
    ris.add(interceptor);
    restTemplate.setInterceptors(ris);
    SimpleClientHttpRequestFactory httpFactory = new SimpleClientHttpRequestFactory();
    httpFactory.setOutputStreaming(false);
    restTemplate.setRequestFactory(new BufferingClientHttpRequestFactory(httpFactory));
    restTemplate.getMessageConverters().add(0, new StringHttpMessageConverter(Charset.forName("UTF-8")));
    return restTemplate;
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    // 单位为ms
    factory.setReadTimeout(5000);
    // 单位为ms
    factory.setConnectTimeout(5000);
    return factory;
}

private ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(10000);
    factory.setConnectTimeout(15000);
    return factory;
}

/**
 * init httpRequestFactory.
 *
 * @return
 */
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(20000);
    factory.setConnectTimeout(5000);
    return factory;
}

@Bean
public RestTemplate getRestTemplate() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    // ms
    factory.setReadTimeout(10000);
    // ms
    factory.setConnectTimeout(10000);
    return new RestTemplate(factory);
}

// SPR-15291
@Test
public void redirect() throws Exception {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory() {

        @Override
        protected void prepareConnection(HttpURLConnection conn, String method) throws IOException {
            super.prepareConnection(conn, method);
            conn.setInstanceFollowRedirects(false);
        }
    };
    URI uri = new URI("http://localhost:" + this.port + "/redirect");
    RequestEnreplacedy<Void> request = RequestEnreplacedy.get(uri).accept(MediaType.ALL).build();
    ResponseEnreplacedy<Void> response = new RestTemplate(factory).exchange(request, Void.clreplaced);
    replacedertEquals(HttpStatus.SEE_OTHER, response.getStatusCode());
    replacedertEquals("/", response.getHeaders().getLocation().toString());
}

@Test
public void interceptShouldAddHeader() throws Exception {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    ClientHttpRequest request = requestFactory.createRequest(new URI("https://example.com"), HttpMethod.GET);
    ClientHttpRequestExecution execution = mock(ClientHttpRequestExecution.clreplaced);
    byte[] body = new byte[] {};
    new BasicAuthorizationInterceptor("spring", "boot").intercept(request, body, execution);
    verify(execution).execute(request, body);
    replacedertEquals("Basic c3ByaW5nOmJvb3Q=", request.getHeaders().getFirst("Authorization"));
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    factory.setReadTimeout(5000);
    factory.setConnectTimeout(5000);
    return factory;
}

@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
    SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
    /**
     * 读超时单位为ms
     */
    factory.setReadTimeout(10000);
    /**
     * 连接超时单位为ms
     */
    factory.setConnectTimeout(10000);
    return factory;
}

@Bean
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(60 * 1000);
    requestFactory.setReadTimeout(60 * 1000);
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    return restTemplate;
}

@Bean("restClient")
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(10 * 1000);
    requestFactory.setReadTimeout(10 * 1000);
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    return restTemplate;
}

@Bean
public RestTemplate restTemplate() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
    requestFactory.setConnectTimeout(10000);
    requestFactory.setReadTimeout(10000);
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    return restTemplate;
}

@Test
void connectWithCustomSslContextFactory() {
    SimpleClientHttpRequestFactory requestFactory = new SimpleSslClientHttpRequestFactory(new InsecureSslContextFactory());
    RestTemplate restTemplate = new RestTemplate(requestFactory);
    ResponseEnreplacedy<String> response = restTemplate.getForEnreplacedy("https://self-signed.badssl.com/", String.clreplaced);
    replacedertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
}

See More Examples