Java IClientConfig类代码示例

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
/**
 * Zone affinity rule.
 *
 * @param clientConfig the ribbon client config.
 * @param rule         the predicate rule support
 * @return the zone affinity rule.
 */
@Bean
public CompositePredicate zoneAffinity(IClientConfig clientConfig, PredicateBasedRuleSupport rule) {
    AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(rule, clientConfig);
    ZoneAvoidancePredicate zoneAvoidancePredicate = new ZoneAvoidancePredicate(rule, clientConfig);
    ZoneAffinityMatcher zoneAffinityMatcher = new ZoneAffinityMatcher(getEurekaInstanceProperties().getZone());
    CompositePredicate predicate = withPredicates(zoneAffinityMatcher)
            .addFallbackPredicate(withPredicates(zoneAvoidancePredicate, availabilityPredicate).build())
            .addFallbackPredicate(availabilityPredicate)
            .addFallbackPredicate(alwaysTrue())
            .build();
    rule.setPredicate(predicate);
    rule.setDescription(from(zoneAffinityMatcher)
            .fallback(from("ZoneAvoidance").and(from("Availability")))
            .fallback(from("Availability"))
            .fallback(from("Any()")));
    log.info("Zone affinity enabled for client [{}].", clientConfig.getClientName());
    return predicate;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
/**
 * Favorite zone rule bean.
 *
 * @param clientConfig the ribbon client config
 * @param rule         the predicate rule support
 * @return the favorite zone rule
 */
@Bean
public CompositePredicate favoriteZone(IClientConfig clientConfig, PredicateBasedRuleSupport rule) {
    AvailabilityPredicate availabilityPredicate = new AvailabilityPredicate(rule, clientConfig);
    ZoneAvoidancePredicate zoneAvoidancePredicate = new ZoneAvoidancePredicate(rule, clientConfig);
    ZoneAffinityMatcher zoneAffinityMatcher = new ZoneAffinityMatcher(getEurekaInstanceProperties().getZone());
    DynamicZoneMatcher dynamicZoneMatcher = new DynamicZoneMatcher(favoriteZoneKey);
    DynamicZoneMatcher upstreamZoneMatcher = new DynamicZoneMatcher(upstreamZoneKey);
    CompositePredicate predicate = withPredicates(dynamicZoneMatcher)
            .addFallbackPredicate(zoneAffinityMatcher)
            .addFallbackPredicate(upstreamZoneMatcher)
            .addFallbackPredicate(withPredicates(zoneAvoidancePredicate, availabilityPredicate).build())
            .addFallbackPredicate(availabilityPredicate)
            .addFallbackPredicate(alwaysTrue())
            .build();
    rule.setPredicate(predicate);
    rule.setDescription(from(dynamicZoneMatcher)
            .fallback(from(zoneAffinityMatcher))
            .fallback(from(upstreamZoneMatcher))
            .fallback(from("ZoneAvoidance").and(from("Availability")))
            .fallback(from("Availability"))
            .fallback(from("any()")));
    log.info("Favorite zone enabled for client [{}] using context key [{}].", clientConfig.getClientName(), favoriteZoneKey);
    return predicate;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Override
public RequestSpecificRetryHandler getRequestSpecificRetryHandler(
    RibbonRequest request, IClientConfig requestConfig) {
  if (clientConfig.get(CommonClientConfigKey.OkToRetryOnAllOperations, false)) {
    return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig);
  }
  if (!request.toRequest().method().equals("GET")) {
    return new RequestSpecificRetryHandler(true, false, this.getRetryHandler(), requestConfig);
  } else {
    return new RequestSpecificRetryHandler(true, true, this.getRetryHandler(), requestConfig);
  }
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Override
public RibbonResponse execute(RibbonRequest request, IClientConfig requestConfig) throws Exception {
	try {
		HttpClientRequest ribbonHttpRequestMessage = httpClientRequestFactory.createOf(request.replaceUri());

		request.writeTo(ribbonHttpRequestMessage);

		HttpResponseMessage httpResponse = ribbonHttpRequestMessage.execute();

		return new RibbonResponse(httpResponse);

	} catch (Exception e) {
		ribbonExceptionHandler.onException(request, e);
		throw e;
	}
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Before
public void setup() {
	ILoadBalancer loadBalancer = new BaseLoadBalancer();
	loadBalancer.addServers(Arrays.asList(new Server("localhost", 7080)));
	loadBalancer.addServers(Arrays.asList(new Server("localhost", 7081)));
	loadBalancer.addServers(Arrays.asList(new Server("localhost", 7082)));

	IClientConfig clientConfig = new DefaultClientConfigImpl();

	RibbonHttpClientRequestFactory ribbonHttpClientRequestFactory = new RibbonHttpClientRequestFactory(loadBalancer, clientConfig);

	myApi = new RestifyProxyBuilder()
			.client(ribbonHttpClientRequestFactory)
			.target(MyApi.class, "http://myApi")
			.build();
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Override
public HttpClient<ByteBuf, ByteBuf> newHttpClient(final IClientConfig config) {
    final List<ExecutionListener<HttpClientRequest<ByteBuf>, HttpClientResponse<ByteBuf>>> listeners = new ArrayList<>();
    listeners.add(createBearerHeaderAdder());
    final PipelineConfiguratorComposite<HttpClientResponse<ByteBuf>, HttpClientRequest<ByteBuf>> pipelineConfigurator = new PipelineConfiguratorComposite<HttpClientResponse<ByteBuf>,
            HttpClientRequest<ByteBuf>>(new HttpClientPipelineConfigurator<ByteBuf, ByteBuf>(),
                                        new HttpObjectAggregationConfigurator(maxChunkSize));
    final LoadBalancingHttpClient<ByteBuf, ByteBuf> client = LoadBalancingHttpClient.<ByteBuf, ByteBuf>builder()
            .withClientConfig(config)
            .withExecutorListeners(listeners)
            .withRetryHandler(getDefaultHttpRetryHandlerWithConfig(config))
            .withPipelineConfigurator(pipelineConfigurator)
            .withPoolCleanerScheduler(RibbonTransport.poolCleanerScheduler)
            .build();

    return client;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Override
public HttpClient<ByteBuf, ByteBuf> newHttpClient(final IClientConfig config) {
    final List<ExecutionListener<HttpClientRequest<ByteBuf>, HttpClientResponse<ByteBuf>>> listeners = new ArrayList<>();
    listeners.add(createBearerHeaderAdder());
    final PipelineConfiguratorComposite<HttpClientResponse<ByteBuf>, HttpClientRequest<ByteBuf>> pipelineConfigurator = new PipelineConfiguratorComposite<HttpClientResponse<ByteBuf>, 
            HttpClientRequest<ByteBuf>>(new HttpClientPipelineConfigurator<ByteBuf, ByteBuf>(),
            new HttpObjectAggregationConfigurator(maxChunkSize));
    final LoadBalancingHttpClient<ByteBuf, ByteBuf> client = LoadBalancingHttpClient.<ByteBuf, ByteBuf>builder()
            .withClientConfig(config)
            .withExecutorListeners(listeners)
            .withRetryHandler(getDefaultHttpRetryHandlerWithConfig(config))
            .withPipelineConfigurator(pipelineConfigurator)
            .withPoolCleanerScheduler(RibbonTransport.poolCleanerScheduler)
            .build();

    return client;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Override
@SuppressWarnings("deprecation")
public ClientHttpRequest createRequest(URI originalUri, HttpMethod httpMethod) throws IOException {
    String serviceId = originalUri.getHost();
    ServiceInstance instance = loadBalancer.choose(serviceId);
    if (instance == null) {
        throw new IllegalStateException("No instances available for " + serviceId);
    }
    URI uri = loadBalancer.reconstructURI(instance, originalUri);

    IClientConfig clientConfig = clientFactory.getClientConfig(instance.getServiceId());
    RestClient client = clientFactory.getClient(instance.getServiceId(), RestClient.class);
    HttpRequest request = HttpRequest.newBuilder()
            .uri(uri)
            .verb(HttpRequest.Verb.valueOf(httpMethod.name()))
            .build();

    return new RibbonHttpRequest(request, client, clientConfig);
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
private LoadBalancingHttpClient<ByteBuf, ByteBuf> getClient(String vip) {
    LoadBalancingHttpClient<ByteBuf, ByteBuf> client = httpClients.get(vip);
    if (client == null) {
        IClientConfig config = IClientConfig.Builder.newBuilder("prana_backend").
                withDefaultValues().
                withDeploymentContextBasedVipAddresses(vip).
                build().
                set(IClientConfigKey.Keys.MaxTotalConnections, 2000).
                set(IClientConfigKey.Keys.MaxConnectionsPerHost, 2000).
                set(IClientConfigKey.Keys.OkToRetryOnAllOperations, false).
                set(IClientConfigKey.Keys.NIWSServerListClassName, DiscoveryEnabledNIWSServerList.class.getName());

        client = RibbonTransport.newHttpClient(new HttpClientPipelineConfigurator<ByteBuf, ByteBuf>(), config);
        httpClients.putIfAbsent(vip, client);

    }
    return client;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public RetryableOkHttpLoadBalancingClient okHttpLoadBalancingClient(
	IClientConfig config,
	ServerIntrospector serverIntrospector,
	ILoadBalancer loadBalancer,
	RetryHandler retryHandler,
	LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory,
	OkHttpClient delegate,
	LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
	LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
	RetryableOkHttpLoadBalancingClient client = new RetryableOkHttpLoadBalancingClient(delegate, config,
			serverIntrospector, loadBalancedRetryPolicyFactory, loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
public RibbonLoadBalancedRetryPolicy(String serviceId, RibbonLoadBalancerContext context, ServiceInstanceChooser loadBalanceChooser,
									 IClientConfig clientConfig) {
	this.serviceId = serviceId;
	this.lbContext = context;
	this.loadBalanceChooser = loadBalanceChooser;
	String retryableStatusCodesProp = clientConfig.getPropertyAsString(RETRYABLE_STATUS_CODES, "");
	String[] retryableStatusCodesArray = retryableStatusCodesProp.split(",");
	for(String code : retryableStatusCodesArray) {
		if(!StringUtils.isEmpty(code)) {
			try {
				retryableStatusCodes.add(Integer.valueOf(code.trim()));
			} catch (NumberFormatException e) {
				log.warn("We cant add the status code because the code [ " + code + " ] could not be converted to an integer. ", e);
			}
		}
	}
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(HttpClientConnectionManager.class)
public HttpClientConnectionManager httpClientConnectionManager(
		IClientConfig config,
		ApacheHttpClientConnectionManagerFactory connectionManagerFactory) {
	RibbonProperties ribbon = RibbonProperties.from(config);
	int maxTotalConnections = ribbon.maxTotalConnections();
	int maxConnectionsPerHost = ribbon.maxConnectionsPerHost();
	int timerRepeat = ribbon.connectionCleanerRepeatInterval();
	long timeToLive = ribbon.poolKeepAliveTime();
	TimeUnit ttlUnit = ribbon.getPoolKeepAliveTimeUnits();
	final HttpClientConnectionManager connectionManager = connectionManagerFactory
			.newConnectionManager(false, maxTotalConnections,
					maxConnectionsPerHost, timeToLive, ttlUnit, registryBuilder);
	this.connectionManagerTimer.schedule(new TimerTask() {
		@Override
		public void run() {
			connectionManager.closeExpiredConnections();
		}
	}, 30000, timerRepeat);
	return connectionManager;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(AbstractLoadBalancerAwareClient.class)
@ConditionalOnClass(name = "org.springframework.retry.support.RetryTemplate")
public RetryableRibbonLoadBalancingHttpClient retryableRibbonLoadBalancingHttpClient(
	IClientConfig config, ServerIntrospector serverIntrospector,
	ILoadBalancer loadBalancer, RetryHandler retryHandler,
	LoadBalancedRetryPolicyFactory loadBalancedRetryPolicyFactory, CloseableHttpClient httpClient,
	LoadBalancedBackOffPolicyFactory loadBalancedBackOffPolicyFactory,
	LoadBalancedRetryListenerFactory loadBalancedRetryListenerFactory) {
	RetryableRibbonLoadBalancingHttpClient client = new RetryableRibbonLoadBalancingHttpClient(
		httpClient, config, serverIntrospector, loadBalancedRetryPolicyFactory,
		loadBalancedBackOffPolicyFactory, loadBalancedRetryListenerFactory);
	client.setLoadBalancer(loadBalancer);
	client.setRetryHandler(retryHandler);
	Monitors.registerObject("Client_" + this.name, client);
	return client;
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
@Test
public void testRetryableStatusCodes() throws Exception {
	int sameServer = 3;
	int nextServer = 3;
	RibbonServer server = getRibbonServer();
	IClientConfig config = mock(IClientConfig.class);
	doReturn(sameServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetries), anyInt());
	doReturn(nextServer).when(config).get(eq(CommonClientConfigKey.MaxAutoRetriesNextServer), anyInt());
	doReturn(false).when(config).get(eq(CommonClientConfigKey.OkToRetryOnAllOperations), eq(false));
	doReturn(config).when(clientFactory).getClientConfig(eq(server.getServiceId()));
	doReturn("404, 418,502,foo, ,").when(config).getPropertyAsString(eq(RibbonLoadBalancedRetryPolicy.RETRYABLE_STATUS_CODES),eq(""));
	clientFactory.getLoadBalancerContext(server.getServiceId()).setRetryHandler(new DefaultLoadBalancerRetryHandler(config));
	RibbonLoadBalancerClient client = getRibbonLoadBalancerClient(server);
	RibbonLoadBalancedRetryPolicyFactory factory = new RibbonLoadBalancedRetryPolicyFactory(clientFactory);
	LoadBalancedRetryPolicy policy = factory.create(server.getServiceId(), client);
	HttpRequest request = mock(HttpRequest.class);
	doReturn(HttpMethod.GET).when(request).getMethod();
	assertThat(policy.retryableStatusCode(400), is(false));
	assertThat(policy.retryableStatusCode(404), is(true));
	assertThat(policy.retryableStatusCode(418), is(true));
	assertThat(policy.retryableStatusCode(502), is(true));
}
 

import com.netflix.client.config.IClientConfig; //导入依赖的package包/类
protected static Setter getSetter(final String commandKey,
		ZuulProperties zuulProperties, IClientConfig config) {

	// @formatter:off
	Setter commandSetter = Setter.withGroupKey(HystrixCommandGroupKey.Factory.asKey("RibbonCommand"))
							.andCommandKey(HystrixCommandKey.Factory.asKey(commandKey));
	final HystrixCommandProperties.Setter setter = createSetter(config, commandKey, zuulProperties);
	if (zuulProperties.getRibbonIsolationStrategy() == ExecutionIsolationStrategy.SEMAPHORE){
		final String name = ZuulConstants.ZUUL_EUREKA + commandKey + ".semaphore.maxSemaphores";
		// we want to default to semaphore-isolation since this wraps
		// 2 others commands that are already thread isolated
		final DynamicIntProperty value = DynamicPropertyFactory.getInstance()
				.getIntProperty(name, zuulProperties.getSemaphore().getMaxSemaphores());
		setter.withExecutionIsolationSemaphoreMaxConcurrentRequests(value.get());
	} else if (zuulProperties.getThreadPool().isUseSeparateThreadPools()) {
		final String threadPoolKey = zuulProperties.getThreadPool().getThreadPoolKeyPrefix() + commandKey;
		commandSetter.andThreadPoolKey(HystrixThreadPoolKey.Factory.asKey(threadPoolKey));
	}
	
	return commandSetter.andCommandPropertiesDefaults(setter);
	// @formatter:on
}