org.springframework.web.client.AsyncRestTemplate Java Examples

@DataProvider(value = {
    "true",
    "false"
})
@Test
public void createTracingEnabledAsyncRestTemplate_with_tag_and_span_naming_args_returns_AsyncRestTemplate_with_wingtips_interceptor_added_with_expected_fields(
    boolean subspanOptionOn
) {
    // when
    AsyncRestTemplate result = WingtipsSpringUtil.createTracingEnabledAsyncRestTemplate(
        subspanOptionOn, tagStrategyMock, tagAdapterMock
    );

    // then
    assertThat(result.getInterceptors()).hasSize(1);
    assertThat(result.getInterceptors().get(0)).isInstanceOf(WingtipsAsyncClientHttpRequestInterceptor.class);
    verifyInterceptorFieldValues(
        result.getInterceptors().get(0),
        subspanOptionOn,
        tagStrategyMock,
        tagAdapterMock
    );
}
 

@Test
public void multipleRestTemplates() {
	ConfigurableApplicationContext context = init(TwoRestTemplates.class);
	final Map<String, AsyncRestTemplate> restTemplates = context
			.getBeansOfType(AsyncRestTemplate.class);

	then(restTemplates).isNotNull();
	Collection<AsyncRestTemplate> templates = restTemplates.values();
	then(templates).hasSize(2);

	TwoRestTemplates.Two two = context.getBean(TwoRestTemplates.Two.class);

	then(two.loadBalanced).isNotNull();
	assertLoadBalanced(two.loadBalanced);

	then(two.nonLoadBalanced).isNotNull();
	then(two.nonLoadBalanced.getInterceptors()).isEmpty();
}
 

@Override protected void get(AsyncClientHttpRequestFactory client, String path,
  BiConsumer<Integer, Throwable> callback) {
  AsyncRestTemplate restTemplate = new AsyncRestTemplate(client);
  restTemplate.setInterceptors(Collections.singletonList(interceptor));
  restTemplate.getForEntity(url(path), String.class)
    .addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
      @Override public void onFailure(Throwable throwable) {
        if (throwable instanceof HttpStatusCodeException) {
          callback.accept(((HttpStatusCodeException) throwable).getRawStatusCode(), null);
        } else {
          callback.accept(null, throwable);
        }
      }

      @Override public void onSuccess(ResponseEntity<String> entity) {
        callback.accept(entity.getStatusCodeValue(), null);
      }
    });
}
 

/**
 * @param tagAndNamingStrategy The span tag and naming strategy to use - cannot be null. If you really want no
 * tag and naming strategy, then pass in {@link NoOpHttpTagStrategy#getDefaultInstance()}.
 * @param tagAndNamingAdapter The tag and naming adapter to use - cannot be null. If you really want no tag and
 * naming adapter, then pass in {@link NoOpHttpTagAdapter#getDefaultInstance()}.
 * @return A new {@link AsyncRestTemplate} instance with a {@link WingtipsAsyncClientHttpRequestInterceptor}
 * already added, and with the subspan option and tag/naming strategy and adapter set to the given arguments.
 */
public static AsyncRestTemplate createTracingEnabledAsyncRestTemplate(
    boolean surroundCallsWithSubspan,
    HttpTagAndSpanNamingStrategy<HttpRequest, ClientHttpResponse> tagAndNamingStrategy,
    HttpTagAndSpanNamingAdapter<HttpRequest, ClientHttpResponse> tagAndNamingAdapter
) {
    AsyncRestTemplate asyncRestTemplate = new AsyncRestTemplate();
    asyncRestTemplate.getInterceptors().add(
        new WingtipsAsyncClientHttpRequestInterceptor(
            surroundCallsWithSubspan,
            tagAndNamingStrategy,
            tagAndNamingAdapter
        )
    );
    return asyncRestTemplate;
}
 

@DataProvider(value = {
    "true",
    "false"
})
@Test
public void createTracingEnabledAsyncRestTemplate_single_arg_returns_AsyncRestTemplate_with_wingtips_interceptor_added_with_expected_fields(
    boolean subspanOptionOn
) {
    // when
    AsyncRestTemplate result = WingtipsSpringUtil.createTracingEnabledAsyncRestTemplate(subspanOptionOn);

    // then
    assertThat(result.getInterceptors()).hasSize(1);
    assertThat(result.getInterceptors().get(0)).isInstanceOf(WingtipsAsyncClientHttpRequestInterceptor.class);
    verifyInterceptorFieldValues(
        result.getInterceptors().get(0),
        subspanOptionOn,
        ZipkinHttpTagStrategy.getDefaultInstance(),
        SpringHttpClientTagAdapter.getDefaultInstance()
    );
}
 

private AsyncRestTemplate createNewRestTemplate(String addr) {
    // we use async client because usual client does not allow to interruption in some cases
    NettyRequestFactory factory = new NettyRequestFactory();
    if(AddressUtils.isHttps(addr)) {
        try {
            initSsl(addr, factory);
        } catch (Exception e) {
            log.error("", e);
        }
    }
    final AsyncRestTemplate restTemplate = new AsyncRestTemplate(factory);
    List<AsyncClientHttpRequestInterceptor> interceptors = new ArrayList<>();
    interceptors.add(new HttpAuthInterceptor(registryRepository));
    if(!StringUtils.isEmpty(agentPassword)) {
        interceptors.add(new BasicAuthAsyncInterceptor("admin", agentPassword));
    }
    restTemplate.setInterceptors(interceptors);
    return restTemplate;
}
 

@Bean
public SmartInitializingSingleton loadBalancedAsyncRestTemplateInitializer2(
        final List<AsyncRestTemplateCustomizer> customizers) {
    return new SmartInitializingSingleton() {
        @Override
        public void afterSingletonsInstantiated() {
            logger.info("init AsyncRestTemplateCircuitBreaker start");
            for (AsyncRestTemplate restTemplate : AsyncRestTemplateCircuitBreakerAutoConfiguration.this
                    .restTemplates) {
                AsyncRestTemplateCircuitInterceptor interceptor =
                        new AsyncRestTemplateCircuitInterceptor(circuitBreakerCore);
                logger.info("add AsyncRestTemplateCircuitInterceptor first");
                List<AsyncClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
                interceptors.add(0, interceptor);
                restTemplate.setInterceptors(interceptors);
            }
            logger.info("init AsyncRestTemplateCircuitBreaker end");
        }
    };
}
 

public void testPostFromEntity() throws IOException, InterruptedException, ExecutionException {
    AsyncRestTemplate restTemplate = SofaTracerRestTemplateBuilder.buildAsyncRestTemplate();
    PostBody postBody = new PostBody();
    postBody.setName("weiheng");
    HttpEntity<PostBody> entity = new HttpEntity<PostBody>(postBody);
    ListenableFuture<ResponseEntity<PostBody>> responseEntityListenableFuture = restTemplate
        .postForEntity(urlHttpPrefix, entity, PostBody.class);
    ResponseEntity<PostBody> postBodyResponseEntity = responseEntityListenableFuture.get();
    Assert.assertTrue(postBodyResponseEntity.getBody().getName().equals("weiheng"));
    Thread.sleep(1000);
    //wait for async output
    List<String> contents = FileUtils.readLines(new File(
        logDirectoryPath + File.separator
                + RestTemplateLogEnum.REST_TEMPLATE_DIGEST.getDefaultLogName()));
    assertTrue(contents.size() == 2);
    //stat log
    List<String> statContents = FileUtils.readLines(new File(
        logDirectoryPath + File.separator
                + RestTemplateLogEnum.REST_TEMPLATE_STAT.getDefaultLogName()));
    assertTrue(statContents.size() == 2);
}
 

@SuppressWarnings("unchecked")
DockerServiceImpl dockerService() {
    ClusterConfig config = ClusterConfigImpl.builder().host("localhost:2375").build();
    AsyncRestTemplate restTemplate = new AsyncRestTemplate();
    restTemplate.setInterceptors(
            Collections.singletonList(
                    new HttpAuthInterceptor(null)));
    return DockerServiceImpl.builder()
      .config(config)
      .cluster("test")
      .restTemplate(restTemplate)
      .nodeInfoProvider(mock(NodeInfoProvider.class))
      .eventConsumer(mock(MessageBus.class))
      .objectMapper(new ObjectMapper())
      .build();
}
 

@SuppressWarnings("unchecked")
DockerServiceImpl dockerService() {
    ClusterConfig config = ClusterConfigImpl.builder()
            .host("172.31.0.12:2375").build();
    AsyncRestTemplate restTemplate = new AsyncRestTemplate();
    RegistryRepository registryRepository = mock(RegistryRepository.class);
    restTemplate.setInterceptors(
            Collections.singletonList(
                    new HttpAuthInterceptor(registryRepository)));
    return DockerServiceImpl.builder()
      .config(config)
      .cluster("test")
      .restTemplate(restTemplate)
      .nodeInfoProvider(mock(NodeInfoProvider.class))
      .eventConsumer(mock(MessageBus.class))
      .objectMapper(new ObjectMapper())
      .build();
}
 

@Test
@SuppressWarnings("unchecked")
@Ignore
public void testLaunchTask() throws Exception {
    ClusterConfig config = ClusterConfigImpl.builder().host("localhost:2375").build();
    DockerService dockerService = DockerServiceImpl.builder()
      .config(config)
      .restTemplate(new AsyncRestTemplate())
      .nodeInfoProvider(mock(NodeInfoProvider.class))
      .eventConsumer(mock(MessageBus.class))
      .objectMapper(new ObjectMapper())
      .cluster("test")
      .build();
    ClassLoader classLoader = getClass().getClassLoader();
    File file = new File(classLoader.getResource("docker-compose.yml").getFile());
    ComposeResult composeResult = composeExecutor.up(ComposeArg.builder().file(file).runUpdate(false).build(),
            dockerService);
    Assert.notNull(composeResult);

}
 

@Bean
public SmartInitializingSingleton loadBalancedAsyncRestTemplateInitializer2(
        final List<AsyncRestTemplateCustomizer> customizers) {
    return new SmartInitializingSingleton() {
        @Override
        public void afterSingletonsInstantiated() {
            logger.info("Init AsyncRestTemplateRateLimiterConfiguration");
            for (AsyncRestTemplate restTemplate : AsyncRestTemplateRateLimiterConfiguration.this.restTemplates) {
                List<AsyncClientHttpRequestInterceptor> interceptors = restTemplate.getInterceptors();
                logger.debug("AsyncRestTemplate init start, interceptor size:" + interceptors.size());
                AsyncClientHttpRequestInterceptor interceptor =
                        new AsyncRestTemplateRateLimiterInterceptor(serviceName);
                interceptors.add(0, interceptor);
                logger.debug("AsyncRestTemplate init end, Add AsyncRestTemplateRateLimiterInterceptor");
                restTemplate.setInterceptors(interceptors);
            }
        }
    };
}
 

@Bean
public SmartInitializingSingleton loadBalancedAsyncRestTemplateInitializer(
		final List<AsyncRestTemplateCustomizer> customizers) {
	return () -> {
		for (AsyncRestTemplate restTemplate : AsyncRestTemplateCustomizerConfig.this.restTemplates) {
			for (AsyncRestTemplateCustomizer customizer : customizers) {
				customizer.customize(restTemplate);
			}
		}
	};
}
 

private static boolean makeAsyncCall() throws Exception {
  final AsyncRestTemplate asyncRestTemplate = new AsyncRestTemplate();
  final int status = asyncRestTemplate.getForEntity("http://www.google.com", String.class).get(10, TimeUnit.SECONDS).getStatusCode().value();

  if (200 != status)
    throw new AssertionError("ERROR: response: " + status);

  final CountDownLatch latch = new CountDownLatch(1);
  final Span parent = GlobalTracer.get().buildSpan("parent").start();
  try(final Scope scope = GlobalTracer.get().activateSpan(parent)) {
    asyncRestTemplate.getForEntity("http://www.google.com", String.class)
        .addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
          @Override
          public void onSuccess(final ResponseEntity<String> result) {
            TestUtil.checkActiveSpan();
            latch.countDown();
          }

          @Override
          public void onFailure(final Throwable t) {
            TestUtil.checkActiveSpan();
            latch.countDown();
          }
        });
  } finally {
    parent.finish();
  }

  latch.await(15, TimeUnit.SECONDS);
  return true;
}
 

@Bean
public SmartInitializingSingleton metricsAsyncRestTemplateInitializer(
    final ObjectProvider<List<AsyncRestTemplate>> asyncRestTemplatesProvider,
    final RestTemplatePostProcessor customizer) {
    return () -> {
        final List<AsyncRestTemplate> asyncRestTemplates = asyncRestTemplatesProvider.getIfAvailable();
        if (!CollectionUtils.isEmpty(asyncRestTemplates)) {
            asyncRestTemplates.forEach(customizer::customize);
        }
    };
}
 

public void customize(final AsyncRestTemplate restTemplate) {
    if (restTemplate.getInterceptors().contains(this.metricsClientHttpRequestInterceptor)) {
        return;
    }
    UriTemplateHandler templateHandler = restTemplate.getUriTemplateHandler();
    templateHandler = this.metricsClientHttpRequestInterceptor.createUriTemplateHandler(templateHandler);
    restTemplate.setUriTemplateHandler(templateHandler);
    List<AsyncClientHttpRequestInterceptor> interceptors = new ArrayList<>();
    interceptors.add(this.metricsClientHttpRequestInterceptor);
    interceptors.addAll(restTemplate.getInterceptors());
    restTemplate.setInterceptors(interceptors);
}
 

@Deprecated
public static AsyncRestTemplate buildAsyncRestTemplate() {
    AsyncRestTemplate asyncRestTemplate = new AsyncRestTemplate();
    List<AsyncClientHttpRequestInterceptor> interceptors = new ArrayList<AsyncClientHttpRequestInterceptor>();
    AsyncRestTemplateRequestInterceptor asyncRestTemplateInterceptor = new AsyncRestTemplateRequestInterceptor(
        getRestTemplateTracer());
    interceptors.add(asyncRestTemplateInterceptor);
    asyncRestTemplate.setInterceptors(interceptors);
    return asyncRestTemplate;
}
 

@RequestMapping(produces = MediaType.TEXT_PLAIN_VALUE)
public ListenableFuture<?> requestData() {
	AsyncRestTemplate httpClient = new AsyncRestTemplate();
	AsyncDatabaseClient databaseClient = new FakeAsyncDatabaseClient();

	CompletionStage<String> completionStage = AsyncAdapters.toCompletion(httpClient.execute(
		"http://localhost:8080/hello",
		HttpMethod.GET,
		null,
		new HttpMessageConverterExtractor<>(String.class, messageConverters)
	));

	return AsyncAdapters.toListenable(databaseClient.store(completionStage));
}
 

public void testGetFromEntity() throws IOException, InterruptedException {
    AsyncRestTemplate restTemplate = SofaTracerRestTemplateBuilder.buildAsyncRestTemplate();
    ListenableFuture<ResponseEntity<Map>> forEntity = restTemplate.getForEntity(urlHttpPrefix,
        Map.class);
    forEntity.addCallback(new ListenableFutureCallback<ResponseEntity<Map>>() {
        @Override
        public void onFailure(Throwable ex) {
            Assert.assertTrue(false);
        }

        @Override
        public void onSuccess(ResponseEntity<Map> result) {
            Assert.assertTrue(result.getBody().containsKey("name"));
        }
    });

    Thread.sleep(1000);
    //wait for async output
    List<String> contents = FileUtils.readLines(new File(
        logDirectoryPath + File.separator
                + RestTemplateLogEnum.REST_TEMPLATE_DIGEST.getDefaultLogName()));
    assertTrue(contents.size() == 1);
    //stat log
    List<String> statContents = FileUtils.readLines(new File(
        logDirectoryPath + File.separator
                + RestTemplateLogEnum.REST_TEMPLATE_STAT.getDefaultLogName()));
    assertTrue(statContents.size() == 1);
}
 

@GetMapping
public Future<?> process() {
    AsyncRestTemplate template = new AsyncRestTemplate();
    SuccessCallback onSuccess = r -> System.out.println("Success");
    FailureCallback onFailure = e -> System.out.println("Failure");
    ListenableFuture<?> response = template.getForEntity(
            "http://localhost:" + PORT + "/api/v2/resource/b",
            ExamplesCollection.class
    );

    response.addCallback(onSuccess, onFailure);

    return response;
}
 

@Override protected AsyncRestTemplate newClient(HttpTracing httpTracing) {
  OkHttp3ClientHttpRequestFactory factory = new OkHttp3ClientHttpRequestFactory(ok);
  AsyncRestTemplate result = new AsyncRestTemplate(factory);
  result.setInterceptors(Collections.singletonList(
    TracingAsyncClientHttpRequestInterceptor.create(httpTracing
    )));
  return result;
}
 

/**
 * Create a {@code MockRestServiceServer} and set up the given
 * {@code AsyRestTemplate} with a mock {@link AsyncClientHttpRequestFactory}.
 * @param asyncRestTemplate the AsyncRestTemplate to set up for mock testing
 * @return the created mock server
 */
public static MockRestServiceServer createServer(AsyncRestTemplate asyncRestTemplate) {
	Assert.notNull(asyncRestTemplate, "'asyncRestTemplate' must not be null");
	MockRestServiceServer mockServer = new MockRestServiceServer();
	RequestMatcherClientHttpRequestFactory factory = mockServer.new RequestMatcherClientHttpRequestFactory();
	asyncRestTemplate.setAsyncRequestFactory(factory);
	return mockServer;
}
 

private void assertLoadBalanced(AsyncRestTemplate restTemplate) {
	List<AsyncClientHttpRequestInterceptor> interceptors = restTemplate
			.getInterceptors();
	then(interceptors).hasSize(1);
	AsyncClientHttpRequestInterceptor interceptor = interceptors.get(0);
	then(interceptor).isInstanceOf(AsyncLoadBalancerInterceptor.class);
}
 

@Test
public void restTemplateGetsLoadBalancerInterceptor() {
	ConfigurableApplicationContext context = init(OneRestTemplate.class);
	final Map<String, AsyncRestTemplate> restTemplates = context
			.getBeansOfType(AsyncRestTemplate.class);

	then(restTemplates).isNotNull();
	then(restTemplates.values()).hasSize(1);
	AsyncRestTemplate restTemplate = restTemplates.values().iterator().next();
	then(restTemplate).isNotNull();

	assertLoadBalanced(restTemplate);
}
 

@PostConstruct
public void init() {
	if (this.restTemplates != null) {
		for (AsyncRestTemplate restTemplate : this.restTemplates) {
			List<AsyncClientHttpRequestInterceptor> interceptors = new ArrayList<>(
					restTemplate.getInterceptors());
			interceptors.add(this.clientInterceptor);
			restTemplate.setInterceptors(interceptors);
		}
	}
}
 

@Test
public void createTracingEnabledAsyncRestTemplate_no_args_returns_AsyncRestTemplate_with_wingtips_interceptor_added_with_expected_fields() {
    // when
    AsyncRestTemplate result = WingtipsSpringUtil.createTracingEnabledAsyncRestTemplate();

    // then
    assertThat(result.getInterceptors()).hasSize(1);
    assertThat(result.getInterceptors().get(0)).isInstanceOf(WingtipsAsyncClientHttpRequestInterceptor.class);
    verifyInterceptorFieldValues(
        result.getInterceptors().get(0),
        true,
        ZipkinHttpTagStrategy.getDefaultInstance(),
        SpringHttpClientTagAdapter.getDefaultInstance()
    );
}
 

public NIORestClient(AsyncRestTemplate template) {
	super();

	this.template = template;
	MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter();
	converter.setObjectMapper(JacksonUtil.getMapper());
	template.getMessageConverters().add(converter);
}
 

@Bean
public NIORestClient restClient(){
	HttpComponentsAsyncClientHttpRequestFactory rest = new HttpComponentsAsyncClientHttpRequestFactory();
	rest.setConnectionRequestTimeout(connectionRequestTimeout);
	rest.setReadTimeout(readTimeout);
	rest.setConnectTimeout(connectTimeout);
	return new NIORestClient(new AsyncRestTemplate(rest));
}
 

@Override protected void close(AsyncRestTemplate client) {
  ok.dispatcher().executorService().shutdownNow();
}
 

@Bean
public AsyncRestTemplate asyncRestTemplate() {
    return new AsyncRestTemplate();
}