Java ClientFilter类代码示例

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public static TransportClientFactory newTransportClientFactory(final EurekaClientConfig clientConfig,
															   final Collection<ClientFilter> additionalFilters
															   ) {
	final TransportClientFactory jerseyFactory = JerseyEurekaHttpClientFactory.create(
			clientConfig, additionalFilters, null, null);
	final TransportClientFactory metricsFactory = MetricsCollectingEurekaHttpClient.createFactory(jerseyFactory);

	return new TransportClientFactory() {
		@Override
		public EurekaHttpClient newClient(EurekaEndpoint serviceUrl) {
			return metricsFactory.newClient(serviceUrl);
		}

		@Override
		public void shutdown() {
			metricsFactory.shutdown();
			jerseyFactory.shutdown();
		}
	};
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
private static Client buildClient() {
  ClientConfig config = new DefaultClientConfig();
  config.getClasses().add(ByteStringMessageBodyWriter.class);
  Client client = Client.create(config);
  client.setFollowRedirects(true);
  client.addFilter(new ClientFilter() {

    @Override
    public ClientResponse handle(ClientRequest cr) throws ClientHandlerException {
      log.debug("Making request {} {}", cr.getMethod(), cr.getURI());

      ClientResponse response = getNext().handle(cr);

      return response;
    }

  });
  return client;
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
@Before
public void init() throws Exception {
  Properties properties = new Properties();
  wsBaseUrl = new URIBuilder(getBaseURI()).setPath(contextPath).toString();
  properties.put("occurrence.ws.url", wsBaseUrl);
  properties.put("httpTimeout", HTTP_TO);
  Injector clientInjector =
    Guice.createInjector(new OccurrenceWsClientModule(properties), new AbstractModule() {
      @Override
      protected void configure() {
        //ClientFilter is required by the OccurrenceDownloadClient for authentication
        bind(ClientFilter.class).toInstance(Mockito.mock(ClientFilter.class));
      }
    });
  client = clientInjector.getInstance(OccurrenceService.class);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
/**
 * 
 * @param config config REST Client configuration
 * @param handler handler Jersey client handler.  Useful when plugging in various http client interaction modules (e.g. ribbon)
 * @param filters Chain of client side filters to be applied per request
 */
public TaskClient(ClientConfig config, ClientHandler handler, ClientFilter...filters) {
	super(config, handler);
	for(ClientFilter filter : filters) {
		super.client.addFilter(filter);
	}
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
/**
 * 
 * @param config config REST Client configuration
 * @param handler handler Jersey client handler.  Useful when plugging in various http client interaction modules (e.g. ribbon)
 * @param filters Chain of client side filters to be applied per request
 */
public WorkflowClient(ClientConfig config, ClientHandler handler, ClientFilter...filters) {
	super(config, handler);
	for(ClientFilter filter : filters) {
		super.client.addFilter(filter);
	}
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public RemoteInstanceRequestClientImpl(RemoteConnectionConfiguration configuration)
{
    client = Client.create();
    client.setConnectTimeout(configuration.getConnectionTimeoutMs());
    client.setReadTimeout(configuration.getReadTimeoutMs());
    for ( ClientFilter filter : configuration.getFilters() )
    {
        client.addFilter(filter);
    }
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public EurekaTransport createTransport() {
	TransportClientFactory transportClientFactory = newTransportClientFactory(clientConfig, Collections.<ClientFilter>emptyList());
	EurekaTransportConfig transportConfig = clientConfig.getTransportConfig();

	ClosableResolver<AwsEndpoint> bootstrapResolver = EurekaHttpClients.newBootstrapResolver(
			clientConfig,
			transportConfig,
			transportClientFactory,
			null,
			(stalenessThreshold, timeUnit) -> {
				long thresholdInMs = TimeUnit.MILLISECONDS.convert(stalenessThreshold, timeUnit);
				long delay = eurekaClient.getLastSuccessfulRegistryFetchTimePeriod();
				if (delay > thresholdInMs) {
					log.info("Local registry is too stale for local lookup. Threshold:{}, actual:{}",
							thresholdInMs, delay);
					return null;
				} else {
					return eurekaClient.getApplications();
				}
			}
	);

	EurekaHttpClientFactory httpClientFactory;
	try {
		httpClientFactory = EurekaHttpClients.registrationClientFactory(
				bootstrapResolver,
				transportClientFactory,
				transportConfig
		);
	} catch (Exception e) {
		log.warn("Experimental transport initialization failure", e);
		throw new RuntimeException(e);
	}

	return new EurekaTransport(httpClientFactory, httpClientFactory.newClient(), transportClientFactory, bootstrapResolver);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
/**
 * Goes over all GitHub pages and return all pages union.
 *
 * @param webResource of first page
 * @param entityType type of entities
 * @return union
 */
protected <T> List<T> getAll(WebResource webResource, Class<T[]> entityType, ClientFilter filter)
{
    List<T> result = new LinkedList<T>();

    WebResource cursor = webResource;
    do
    {
        if (filter != null)
        {
            cursor.addFilter(filter);
        }
        WebResource.Builder builder = cursor.accept(MediaType.APPLICATION_JSON_TYPE);

        ClientResponse clientResponse = builder.get(ClientResponse.class);

        if (clientResponse.getStatus() < 300)
        {
            result.addAll(Arrays.asList(clientResponse.getEntity(entityType)));

            LinkHeaders linkHeaders = getLinks(clientResponse);
            LinkHeader nextLink = linkHeaders.getLink("next");
            URI nextPage = nextLink != null ? nextLink.getUri() : null;
            cursor = nextPage != null ? client.resource(nextPage) : null;
        }
        else
        {
            throw new UniformInterfaceException(clientResponse);
        }
    }
    while (cursor != null);
    return result;
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
protected JerseyClient(Client client, String baseUrl, List<ClientFilter> filters, int connectTimeout, int readTimeout) {
    this.baseUrl = baseUrl;
    this.filters = filters;
    this.connectTimeout = connectTimeout;
    this.readTimeout = readTimeout;
    if (client != null) {
        this.client = client;
    } else {
        this.client = createClient();
        initializeClient();
    }
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
@Test
public void client_applies_filter_and_base_url_to_resource() {
    Client client = mock(Client.class);
    WebResource resource = mock(WebResource.class);
    when(client.resource("base")).thenReturn(resource);
    HeaderProcessor processor = mock(HeaderProcessor.class);
    JerseyClient c = new JerseyClient(client, "base", new ArrayList<ClientFilter>(), 10, 10).filtered(processor);
    
    WebResource r = c.resource();
    assertSame(resource, r);
    ArgumentCaptor<HeaderProcessorClientFilter> filterArg = ArgumentCaptor.forClass(HeaderProcessorClientFilter.class);
    verify(resource).addFilter(filterArg.capture());
    assertSame(processor, filterArg.getValue().processor);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
@Test
public void creating_client_applies_connection_and_read_timeout() {
    final Client client = mock(Client.class);
    new JerseyClient(null, "base", new ArrayList<ClientFilter>(), 1, 2) {
        protected Client createClient() {
            return client;
        };
    };
    verify(client).setConnectTimeout(1);
    verify(client).setReadTimeout(2);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public RemoteConnectionConfiguration()
{
    this(Lists.<ClientFilter>newArrayList(), DEFAULT_CONNECTION_TIMEOUT_MS, DEFAULT_READ_TIMEOUT_MS);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public Collection<ClientFilter> getFilters()
{
    return filters;
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public boolean isFilterPresent(ClientFilter clientFilter)
{
  return clientFilters.contains(clientFilter);
}
 

import com.sun.jersey.api.client.filter.ClientFilter; //导入依赖的package包/类
public void addFilter(ClientFilter clientFilter)
{
  client.addFilter(clientFilter);
  clientFilters.add(clientFilter);
}