下面列出了怎么用org.springframework.http.client.SimpleClientHttpRequestFactory的API类实例代码及写法，或者点击链接到github查看源代码。
@Test // SPR-15291
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");
RequestEntity<Void> request = RequestEntity.get(uri).accept(MediaType.ALL).build();
ResponseEntity<Void> response = new RestTemplate(factory).exchange(request, Void.class);
assertEquals(HttpStatus.SEE_OTHER, response.getStatusCode());
assertEquals("/", response.getHeaders().getLocation().toString());
}
@Before
public void before() {
log.info("=============================={}.{}==============================",
this.getClass().getSimpleName(),
this.testName.getMethodName());
this.url = "http://localhost:" + this.listenPort + "/weevent-broker/rest/";
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
this.rest = new RestTemplate(requestFactory);
this.rest.exchange(url + "open?topic={topic}&groupId={groupId}", HttpMethod.GET, null, new ParameterizedTypeReference<BaseResponse<Boolean>>() {
}, this.topicName, WeEvent.DEFAULT_GROUP_ID);
SendResult sendResult = rest.getForEntity(url + "publish?topic={topic}&content={content}", SendResult.class, this.topicName,
this.content).getBody();
Assert.assertNotNull(sendResult);
this.eventId = sendResult.getEventId();
}
public RestTemplate get() {
final RestTemplate restTemplate = new RestTemplate(new SimpleClientHttpRequestFactory());
//remove the existing MappingJacksonHttpMessageConverter - we're going to be using our own
final Iterator<HttpMessageConverter<?>> iterator = restTemplate.getMessageConverters().iterator();
while(iterator.hasNext()){
final HttpMessageConverter<?> converter = iterator.next();
if(converter instanceof MappingJackson2HttpMessageConverter){
iterator.remove();
}
}
//handle json data
final MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
jsonConverter.setObjectMapper(jsonObjectMapper);
restTemplate.getMessageConverters().add(0,jsonConverter);
return restTemplate;
}
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";
ResponseEntity<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.getForEntity("http://localhost:7000/weevent-broker/rest/publish?topic={topic}&groupId={groupId}&content={content}",
SendResult.class,
topic,
WeEvent.DEFAULT_GROUP_ID,
"hello WeEvent".getBytes(StandardCharsets.UTF_8)).getBody();
System.out.println(sendResult);
} catch (RestClientException e) {
e.printStackTrace();
}
}
private RestTemplate getSecureRestTemplate(ConfigClientProperties properties) {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
if (properties.getRequestReadTimeout() < 0) {
throw new IllegalStateException("Invalid Value for Real Timeout set.");
}
requestFactory.setReadTimeout(properties.getRequestReadTimeout());
RestTemplate template = new RestTemplate(requestFactory);
Map<String, String> headers = new HashMap<>(properties.getHeaders());
headers.remove(AUTHORIZATION); // To avoid redundant addition of header
if (!headers.isEmpty()) {
template.setInterceptors(Collections.singletonList(new GenericRequestHeaderInterceptor(headers)));
}
return template;
}
@PostConstruct
public void init() {
if (host.isEmpty() || port.isEmpty()) {
return;
}
int portNr = -1;
try {
portNr = Integer.parseInt(port);
} catch (NumberFormatException e) {
logger.error("Unable to parse the proxy port number");
}
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
InetSocketAddress address = new InetSocketAddress(host, portNr);
Proxy proxy = new Proxy(Proxy.Type.HTTP, address);
factory.setProxy(proxy);
restTemplate.setRequestFactory(factory);
}
private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
if (client.getRequestReadTimeout() < 0) {
throw new IllegalStateException("Invalid Value for Read Timeout set.");
}
requestFactory.setReadTimeout(client.getRequestReadTimeout());
RestTemplate template = new RestTemplate(requestFactory);
Map<String, String> headers = new HashMap<>(client.getHeaders());
if (headers.containsKey(AUTHORIZATION)) {
// To avoid redundant addition of header
headers.remove(AUTHORIZATION);
}
if (!headers.isEmpty()) {
template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(
new GenericRequestHeaderInterceptor(headers)));
}
return template;
}
public ViewEntity testRestTemplate(){
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setConnectTimeout(60000);
requestFactory.setReadTimeout(60000);
String url = "http://127.0.0.1:8868/xxx/test/rest";
HttpHeaders httpHeaders = new HttpHeaders();
httpHeaders.add("TX_XID", "eg564ssasdd");
CatTest cat = new CatTest();
cat.setType("TEST_CAT");
HttpEntity<CatTest> requestEntity = new HttpEntity<CatTest>(cat,httpHeaders);
RestTemplate restTemplate = new RestTemplate(requestFactory);
ResponseEntity<String> result = restTemplate.postForEntity(url, requestEntity,String.class);
return ViewEntity.ok(result);
}
protected final AllureResults execute() {
final RestTemplate restTemplate = new RestTemplate(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
restTemplate.setInterceptors(Collections.singletonList(new AllureRestTemplate()));
final WireMockServer server = new WireMockServer(WireMockConfiguration.options().dynamicPort());
return runWithinTestContext(() -> {
server.start();
WireMock.configureFor(server.port());
WireMock.stubFor(WireMock.get(WireMock.urlEqualTo("/hello")).willReturn(WireMock.aResponse().withBody("some body")));
try {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_JSON);
HttpEntity<JsonNode> entity = new HttpEntity<>(headers);
ResponseEntity<String> result = restTemplate.exchange(server.url("/hello"), HttpMethod.GET, entity, String.class);
Assertions.assertEquals(result.getStatusCode(), HttpStatus.OK);
} finally {
server.stop();
}
});
}
static ClientHttpRequestFactory usingJdk(ClientOptions options) {
if (usingCustomCerts(options)) {
logger.warn("Trust material will not be configured when using "
+ "java.net.HttpUrlConnection. Use an alternate HTTP Client "
+ "(Apache HttpComponents HttpClient, OkHttp3, or Netty) when "
+ "configuring CA certificates.");
}
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
if (options.getConnectionTimeout() != null) {
factory.setConnectTimeout(options.getConnectionTimeoutMillis());
}
if (options.getReadTimeout() != null) {
factory.setReadTimeout(options.getReadTimeoutMillis());
}
return factory;
}
private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
if (client.getRequestReadTimeout() < 0) {
throw new IllegalStateException("Invalid Value for Read Timeout set.");
}
if (client.getRequestConnectTimeout() < 0) {
throw new IllegalStateException("Invalid Value for Connect Timeout set.");
}
requestFactory.setReadTimeout(client.getRequestReadTimeout());
requestFactory.setConnectTimeout(client.getRequestConnectTimeout());
RestTemplate template = new RestTemplate(requestFactory);
Map<String, String> headers = new HashMap<>(client.getHeaders());
if (headers.containsKey(AUTHORIZATION)) {
headers.remove(AUTHORIZATION); // To avoid redundant addition of header
}
if (!headers.isEmpty()) {
template.setInterceptors(Arrays.<ClientHttpRequestInterceptor>asList(
new GenericRequestHeaderInterceptor(headers)));
}
return template;
}
@Test
void shouldPassEmptyEntity() {
driver.addExpectation(onRequestTo("/").withHeader("Passed", "true"),
giveEmptyResponse());
final Http http = Http.builder()
.executor(executor)
.requestFactory(new SimpleClientHttpRequestFactory())
.baseUrl(driver.getBaseUrl())
.plugin(new Plugin() {
@Override
public RequestExecution aroundNetwork(final RequestExecution execution) {
return arguments -> {
assertTrue(arguments.getEntity().isEmpty());
return execution.execute(arguments.withHeader("Passed", "true"));
};
}
})
.build();
http.get("/")
.call(pass())
.join();
driver.verify();
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setConnectTimeout(15000);
factory.setReadTimeout(5000);
return factory;
}
/**
* resttemplate for generic http request.
*/
@Bean(name = "genericRestTemplate")
public RestTemplate getRestTemplate() {
SimpleClientHttpRequestFactory factory = getHttpFactoryForDeploy();
factory.setReadTimeout(constantProperties.getHttpTimeOut());// ms
factory.setConnectTimeout(constantProperties.getHttpTimeOut());// ms
return new RestTemplate(factory);
}
/**
* resttemplate for deploy contract.
*/
@Bean(name = "deployRestTemplate")
public RestTemplate getDeployRestTemplate() {
SimpleClientHttpRequestFactory factory = getHttpFactoryForDeploy();
factory.setReadTimeout(constantProperties.getContractDeployTimeOut());// ms
factory.setConnectTimeout(constantProperties.getContractDeployTimeOut());// ms
return new RestTemplate(factory);
}
/**
* factory for deploy.
*/
@Bean()
@Scope("prototype")
public SimpleClientHttpRequestFactory getHttpFactoryForDeploy() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
return factory;
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
/**读超时单位为ms*/
factory.setReadTimeout(10000);
/**连接超时单位为ms*/
factory.setConnectTimeout(10000);
return factory;
}
@Test
void shouldFailOnProvisioningOfNonAbsoluteBaseUri() {
final Http unit = Http.builder()
.requestFactory(new SimpleClientHttpRequestFactory())
.baseUrl(() -> URI.create(""))
.build();
final IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, unit::get);
assertThat(exception.getMessage(), containsString("Base URL is not absolute"));
}
public static <T> T readUrl(String url, Class<T> clazz) {
try {
RestTemplate restTemplate = new RestTemplate();
SimpleClientHttpRequestFactory rf =
(SimpleClientHttpRequestFactory) restTemplate.getRequestFactory();
rf.setReadTimeout(2 * Constants.ONE_MILLI_INT);
rf.setConnectTimeout(2 * Constants.ONE_MILLI_INT);
return restTemplate.getForObject(url, clazz);
} catch (Exception e) {
log.error("GET call failed for {}", url, e);
return null;
}
}
@Test
public void testInterceptPropagatesContextToRequest() throws Exception {
final HttpRequest request = new SimpleClientHttpRequestFactory().createRequest(URI.create("http://foo.bar"), HttpMethod.GET);
backend.put("inClientBeforeRequest", "true");
unit.intercept(request, payload, clientHttpRequestExecutionMock);
verify(clientHttpRequestExecutionMock).execute(argThat(headers(hasEntry(TraceeConstants.TPIC_HEADER, "inClientBeforeRequest=true"))), any(byte[].class));
}
@SuppressWarnings("deprecation")
@Parameters
public static Iterable<? extends ClientHttpRequestFactory> data() {
return Arrays.asList(
new SimpleClientHttpRequestFactory(),
new HttpComponentsClientHttpRequestFactory(),
new org.springframework.http.client.Netty4ClientHttpRequestFactory(),
new OkHttp3ClientHttpRequestFactory()
);
}
@Test
public void patchForObject() throws URISyntaxException {
// JDK client does not support the PATCH method
assumeFalse(this.clientHttpRequestFactory instanceof SimpleClientHttpRequestFactory);
String s = template.patchForObject(baseUrl + "/{method}", helloWorld, String.class, "patch");
assertEquals("Invalid content", helloWorld, s);
}
@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.class);
byte[] body = new byte[] {};
new BasicAuthorizationInterceptor("spring", "boot").intercept(request, body,
execution);
verify(execution).execute(request, body);
assertEquals("Basic c3ByaW5nOmJvb3Q=", request.getHeaders().getFirst("Authorization"));
}
/**
* init httpRequestFactory.
*
* @return
*/
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setReadTimeout(20000);
factory.setConnectTimeout(5000);
return factory;
}
@Bean
RestTemplate restTemplateTimeoutConfigWithRequestFactory() {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setConnectTimeout(TIMEOUT);
requestFactory.setReadTimeout(TIMEOUT);
return new RestTemplate(requestFactory);
}
@Before
public void before() {
log.info("=============================={}.{}==============================",
this.getClass().getSimpleName(),
this.testName.getMethodName());
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
this.restTemplate = new RestTemplate(requestFactory);
}
@RequestMapping(path = "/listSubscription")
public BaseResponse<Map<String, List<SubscriptionInfo>>> listSubscription(@RequestParam(name = "nodeInstances") String nodeInstances,
@RequestParam(name = "groupId", required = false) String groupId) {
log.info("groupId:{}, nodeInstances:{}", groupId, nodeInstances);
if (StringUtils.isBlank(nodeInstances)) {
log.error("nodeInstances is empty.");
return BaseResponse.buildFail(ErrorCode.CGI_INVALID_INPUT);
}
List<ServiceInstance> instances = this.discoveryClient.getInstances(this.appName);
Map<String, List<SubscriptionInfo>> subscriptions = new HashMap<>();
String[] instanceList = nodeInstances.split(",");
for (String instanceId : instanceList) {
Optional<ServiceInstance> instance = instances.stream().filter(item -> item.getInstanceId().equals(instanceId)).findFirst();
if (instance.isPresent()) {
String url = String.format("%s/%s/admin/innerListSubscription", instance.get().getUri(), this.appName);
if (!StringUtils.isBlank(groupId)) {
url += "?groupId=" + groupId;
}
log.info("url: {}", url);
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
RestTemplate rest = new RestTemplate(requestFactory);
ResponseEntity<BaseResponse<Map<String, SubscriptionInfo>>> rsp = rest.exchange(url,
HttpMethod.GET,
null,
new ParameterizedTypeReference<BaseResponse<Map<String, SubscriptionInfo>>>() {
});
if (rsp.getStatusCode() == HttpStatus.OK && rsp.getBody() != null) {
log.debug("innerListSubscription: {}", rsp);
subscriptions.put(instanceId, new ArrayList<>(rsp.getBody().getData().values()));
continue;
}
}
subscriptions.put(instanceId, Collections.emptyList());
}
return BaseResponse.buildSuccess(subscriptions);
}
/**
* The connection timeout for making a connection to Twitter.
*/
public void setConnectTimeout(int millis) {
ClientHttpRequestFactory f = getRequestFactory();
if (f instanceof SimpleClientHttpRequestFactory) {
((SimpleClientHttpRequestFactory) f).setConnectTimeout(millis);
}
else {
((HttpComponentsClientHttpRequestFactory) f).setConnectTimeout(millis);
}
}
/****
* copy form ConfigServicePropertySourceLocator#getSecureRestTemplate
* @author weishao zeng
* @param client
* @return
*/
private RestTemplate getSecureRestTemplate(ConfigClientProperties client) {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setReadTimeout((60 * 1000 * 3) + 5000); //TODO 3m5s, make configurable?
RestTemplate template = new RestTemplate(requestFactory);
String username = client.getUsername();
String password = client.getPassword();
String authorization = client.getAuthorization();
Map<String, String> headers = new HashMap<>(client.getHeaders());
if (password != null && authorization != null) {
throw new IllegalStateException(
"You must set either 'password' or 'authorization'");
}
if (password != null) {
byte[] token = Base64Utils.encode((username + ":" + password).getBytes());
headers.put("Authorization", "Basic " + new String(token));
}
else if (authorization != null) {
headers.put("Authorization", authorization);
}
if (!headers.isEmpty()) {
template.setInterceptors(Arrays.<ClientHttpRequestInterceptor> asList(
new GenericRequestHeaderInterceptor(headers)));
}
return template;
}
@Bean
public ClientHttpRequestFactory simpleClientHttpRequestFactory() {
SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
factory.setReadTimeout(5000);
factory.setConnectTimeout(15000);
return factory;
}