org.springframework.cloud.client.loadbalancer.LoadBalancerClient Java Examples

/**
 * ApiBoot Logging Admin Registry Center Discovery
 * setting basic auth username if not empty {@link LoggingRegistryCenterAdminDiscovery#setUsername(String)}
 * setting basic auth password if not empty {@link LoggingRegistryCenterAdminDiscovery#setPassword(String)}
 *
 * @param loadBalancerClient LoadBalance Client
 * @return LoggingRegistryCenterAdminDiscovery
 */
@Bean
@ConditionalOnMissingBean
public LoggingAdminDiscovery loggingRegistryCenterAdminDiscovery(LoadBalancerClient loadBalancerClient) {
    LoggingRegistryCenterAdminDiscovery registryCenterAdminDiscovery =
        new LoggingRegistryCenterAdminDiscovery(apiBootLoggingProperties.getDiscovery().getServiceId(), loadBalancerClient);
    String basicAuthUserName = apiBootLoggingProperties.getDiscovery().getUsername();
    if (!ObjectUtils.isEmpty(basicAuthUserName)) {
        registryCenterAdminDiscovery.setUsername(basicAuthUserName);
    }
    String basicAuthPassword = apiBootLoggingProperties.getDiscovery().getPassword();
    if (!ObjectUtils.isEmpty(basicAuthPassword)) {
        registryCenterAdminDiscovery.setPassword(basicAuthPassword);
    }
    return registryCenterAdminDiscovery;
}
 

@Test
public void testAutoConfiguration() {
    new ApplicationContextRunner()
        .withConfiguration(
            AutoConfigurations.of(
                CamelAutoConfiguration.class,
                CamelCloudAutoConfiguration.class,
                CamelSpringCloudServiceRegistryAutoConfiguration.class,
                CamelCloudNetflixServiceLoadBalancerAutoConfiguration.class,
                RibbonAutoConfiguration.class,
                RibbonClientConfiguration.class
            ))
        .withUserConfiguration(
            TestConfiguration.class)
        .withPropertyValues(
            "debug=true",
            "spring.main.banner-mode=off",
            "ribbon.client.name=test")
        .run(
            context -> {
                assertThat(context).hasSingleBean(LoadBalancerClient.class);
                assertThat(context).getBean(LoadBalancerClient.class).isInstanceOf(RibbonLoadBalancerClient.class);

                assertThat(context).hasSingleBean(CamelSpringCloudServiceLoadBalancer.LoadBalancerClientAdapter.class);

                LoadBalancerClient client = context.getBean(LoadBalancerClient.class);
                ServiceLoadBalancer balancer = context.getBean(CamelSpringCloudServiceLoadBalancer.LoadBalancerClientAdapter.class).adapt(client);

                assertThat(balancer).isInstanceOf(CamelCloudNetflixServiceLoadBalancer.class);
            }
        );
}
 

@Bean
@ConditionalOnBean(LoadBalancerClientFactory.class)
@ConditionalOnMissingBean
public LoadBalancerClient blockingLoadBalancerClient(
		LoadBalancerClientFactory loadBalancerClientFactory) {
	return new BlockingLoadBalancerClient(loadBalancerClientFactory);
}
 

@Autowired
public ServiceUtils(
    @Value("${server.port}") String port,
    LoadBalancerClient loadBalancer) {

    this.port = port;
    this.loadBalancer = loadBalancer;
}
 

@Bean(name = "load-balancer")
@ConditionalOnMissingBean
public ServiceLoadBalancer cloudLoadBalancer(
        LoadBalancerClient loadBalancerClient,
        Optional<CamelSpringCloudServiceLoadBalancer.LoadBalancerClientAdapter> clientAdapter) {

    return new CamelSpringCloudServiceLoadBalancer(loadBalancerClient, clientAdapter);
}
 

@Bean
@ConditionalOnMissingBean
public Client feignClient(LoadBalancerClient loadBalancerClient,
		HttpClient httpClient) {
	ApacheHttpClient delegate = new ApacheHttpClient(httpClient);
	return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
}
 

@Bean
@ConditionalOnMissingBean
public Client feignClient(okhttp3.OkHttpClient okHttpClient,
		LoadBalancerClient loadBalancerClient) {
	OkHttpClient delegate = new OkHttpClient(okHttpClient);
	return new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient);
}
 

@Test
public void should_wrap_subclass_of_feign_loadbalancer_client() {
	Client delegate = mock(Client.class);
	BlockingLoadBalancerClient loadBalancerClient = mock(
			BlockingLoadBalancerClient.class);
	when(beanFactory.getBean(LoadBalancerClient.class))
			.thenReturn(loadBalancerClient);

	Object wrapped = traceFeignObjectWrapper.wrap(
			new TestFeignBlockingLoadBalancerClient(delegate, loadBalancerClient));

	assertThat(wrapped).isInstanceOf(TraceFeignBlockingLoadBalancerClient.class);

}
 

@Test
public void should_wrap_feign_loadbalancer_client() {
	Client delegate = mock(Client.class);
	BlockingLoadBalancerClient loadBalancerClient = mock(
			BlockingLoadBalancerClient.class);
	when(beanFactory.getBean(LoadBalancerClient.class))
			.thenReturn(loadBalancerClient);

	Object wrapped = traceFeignObjectWrapper
			.wrap(new FeignBlockingLoadBalancerClient(delegate, loadBalancerClient));

	assertThat(wrapped).isInstanceOf(TraceFeignBlockingLoadBalancerClient.class);
}
 

@BeforeEach
public void setup() {
    client = spy(LoadBalancerClient.class);
    doReturn(null).when(client).choose(TOKEN_SERVICE_ID);
    doAnswer(new Answer<URI>() {

        @Override
        public URI answer(InvocationOnMock invocation) throws Throwable {
            return invocation.getArgument(1);
        }

    }).when(client).reconstructURI(any(), any());

    recorder = LogbackRecorder.forClass(LoadBalancedResourceDetails.class).reset().capture("ALL");
}
 

@Bean
public AsyncRestTemplate asyncRestTemplate(LoadBalancerInterceptor interceptor, LoadBalancerClient loadBalancer) {
	return asyncRest(interceptor, loadBalancer);
}
 

@Bean
public HasFeatures commonsFeatures() {
	return HasFeatures.abstractFeatures(DiscoveryClient.class,
			LoadBalancerClient.class);
}
 

@Bean
public TraversonFactory traversonFactory(LoadBalancerClient loadBalancerClient) {
	return new TraversonFactory(loadBalancerClient);
}
 

public OkHttpRibbonInterceptor(LoadBalancerClient client) {
	this.client = client;
}
 

@Bean
public Client client(LoadBalancerClient blockingLoadBalancerClient) {
	return new MyBlockingClient(new MyDelegateClient(), blockingLoadBalancerClient);
}
 

MyBlockingClient(Client delegate, LoadBalancerClient loadBalancerClient) {
	super(delegate, loadBalancerClient);
}
 

@Bean
public OkHttpRibbonInterceptor okHttpRibbonInterceptor(LoadBalancerClient loadBalancerClient) {
	return new OkHttpRibbonInterceptor(loadBalancerClient);
}
 

private Object loadBalancerClient() {
	if (loadBalancerClient == null) {
		loadBalancerClient = beanFactory.getBean(LoadBalancerClient.class);
	}
	return loadBalancerClient;
}
 

@Bean
public OkHttpRibbonInterceptor okHttpRibbonInterceptor(LoadBalancerClient client) {
	return new OkHttpRibbonInterceptor(client);
}
 

public void setLoadBalancerClient(LoadBalancerClient loadBalancerClient) {
    this.loadBalancerClient = loadBalancerClient;
}
 

@Bean
public RibbonAsyncClientHttpRequestFactory asyncRequestFactory(LoadBalancerClient loadBalancerClient) {
	RibbonAsyncClientHttpRequestFactory requestFactory = new RibbonAsyncClientHttpRequestFactory(loadBalancerClient);
	requestFactory.setTaskExecutor(new SimpleAsyncTaskExecutor());
	return requestFactory;
}
 

public RibbonAsyncClientHttpRequestFactory(LoadBalancerClient loadBalancer) {
	this.loadBalancer = loadBalancer;
}
 

public TraversonFactory(LoadBalancerClient loadBalancerClient) {
	this.loadBalancerClient = loadBalancerClient;
}
 

public TLoadBalancerClient(LoadBalancerClient loadBalancerClient, String serviceName, String path) throws TTransportException {
    this.loadBalancerClient = loadBalancerClient;
    this.serviceName = serviceName;
    this.path = path;
}
 

@Autowired(required = false)
public void setLoadBalancerClient(LoadBalancerClient loadBalancerClient) {
    this.loadBalancerClient = loadBalancerClient;
}
 

@Autowired(required = false)
public void setLoadBalancer(LoadBalancerClient loadBalancer) {
	this.loadBalancer = loadBalancer;
}
 

@Autowired(required = false)
public void setLoadBalancer(LoadBalancerClient loadBalancer) {
	this.loadBalancer = loadBalancer;
}
 

@Autowired(required = false)
public void setLoadBalancer(LoadBalancerClient loadBalancer) {
	this.loadBalancer = loadBalancer;
}
 

@Autowired(required = false)
public void setLoadBalancer(LoadBalancerClient loadBalancer) {
	this.loadBalancer = loadBalancer;
}
 

@Bean
public ProxyTargetResolver loadBalancedProxyTargetResolver(
        final ZuulProperties zuulProperties, final LoadBalancerClient loadBalancerClient) {
    return new LoadBalancedProxyTargetResolver(loadBalancerClient, zuulProperties);
}