import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
private JerseyInvocation.Builder buildAuthorisedClient(String url) {
  final JerseyClient client = createClient();
  return client.target(url)
      .request()
      .property(HTTP_AUTHENTICATION_BASIC_USERNAME, authService + "/service")
      .property(HTTP_AUTHENTICATION_BASIC_PASSWORD, basicPassword);
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
public <T> CheckedFuture<T, UserException> executeAsync(final ElasticAction2<T> action){
  final ContextListenerImpl listener = new ContextListenerImpl();
  // need to cast to jersey since the core javax.ws.rs Invocation doesn't support a typed submission.
  final JerseyInvocation invocation = (JerseyInvocation) action.buildRequest(target, listener);
  final SettableFuture<T> future = SettableFuture.create();
  invocation.submit(new GenericType<T>(action.getResponseClass()), new AsyncCallback<T>(future));
  return Futures.makeChecked(future, new Function<Exception, UserException>(){
    @Override
    public UserException apply(Exception input) {
      if(input instanceof ExecutionException){
        input = (Exception) input.getCause();
      }
      return handleException(input, action, listener);
    }});
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
@Override
public JerseyInvocation.Builder request() {
    checkNotClosed();
    //TODO
    //return new JerseyInvocation.Builder(getUri(), config.snapshot());
    throw new NotImplementedException();
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
private Response getThing(NewCookie sessionCookie) {
    JerseyInvocation.Builder request = getPath().request();
    if (sessionCookie != null) {
        request.cookie(sessionCookie);
    }
    return request.get();
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
private FeedClient mockFeedClientRequest(String json) throws URISyntaxException {
    FlexCredentials flexCredentials = new FlexCredentials("appId", "appKey");
    JerseyClient jerseyClient = Mockito.mock(JerseyClient.class);
    JerseyWebTarget jerseyWebTarget = Mockito.mock(JerseyWebTarget.class);
    JerseyInvocation.Builder builder = Mockito.mock(JerseyInvocation.Builder.class);

    Mockito.when(jerseyClient.target(Matchers.any(URI.class))).thenReturn(jerseyWebTarget);
    Mockito.when(jerseyWebTarget.request(Matchers.any(MediaType.class))).thenReturn(builder);
    Mockito.when(builder.get(String.class)).thenReturn(json);

    return new FeedClient(flexCredentials, uri, jerseyClient);
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
@Before
public void setUp() {
  configureBean();
  clientBuilder = spy(ClientBuilder.newBuilder());
  JerseyClient client = mock(JerseyClient.class);
  JerseyWebTarget listTarget = mock(JerseyWebTarget.class);
  JerseyInvocation.Builder builder = mock(JerseyInvocation.Builder.class);
  getInvocation = mock(JerseyInvocation.class);
  JerseyInvocation postInvocation = mock(JerseyInvocation.class);
  listResponse = mock(Response.class);
  runResponse = mock(Response.class);

  doReturn(listTarget).when(client).target(anyString());
  doReturn(listTarget).when(listTarget).queryParam("job_id", configBean.databricksConfigBean.jobId);
  doReturn(builder).when(listTarget).request(MediaType.APPLICATION_JSON_TYPE);
  doReturn(getInvocation).when(builder).buildGet();
  doReturn(listResponse).when(getInvocation).invoke();
  doReturn(postInvocation).when(builder).buildPost(any());
  doReturn(runResponse).when(postInvocation).invoke();

  doReturn(builder).when(listTarget).request();

  doReturn(postInvocation).when(builder)
      .buildPost(Entity.json((
          new RunJarJobJson(configBean.databricksConfigBean.jobId, configBean.databricksConfigBean.jarParams))));

  doReturn(client).when(clientBuilder).build();

}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
protected Response method(ApplicationFullName targetApplication, String name, Entity<?> entity) {
    int port = LoadBalancer.getInstance().getPort(targetApplication);
    if (LOGGER.isDebugEnabled()) {
        LOGGER.debug("method(" + targetApplication + ", " + name + "): port: " + port);
    }
    long startAt = -1;
    if (port > 0) {
        UriBuilder uriBuilder = targetUri
                .clone()
                .scheme("http")
                .host("localhost")
                .port(port);
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debug("method(" + targetApplication + ", " + name + "): URI: " + uriBuilder.build());
        }
        try {
            JerseyInvocation.Builder request = client.target(uriBuilder.build()).request();
            for (MediaType accept : acceptMediaTypes) {
                request = request.accept(accept);
            }
            JerseyInvocation invocation;
            if (entity == null) {
                invocation = request.build(name);
            } else {
                invocation = request.build(name, entity);
            }
            startAt = System.currentTimeMillis();
            Response response = invocation.invoke();
            if (isResponseCodeAcceptable(response.getStatus())) {
                return response;
            }
        } catch (WebApplicationException wExc) {
            if (isResponseCodeAcceptable(wExc.getResponse().getStatus())) {
                throw wExc;
            }
        } catch (Exception e) {
            //TODO: Provide support for balancing to another endpoint (another endpoint of the same cluster).
            LOGGER.warn("Cannot reach application " + targetApplication + " on port " + port, e);
        } finally {
            if (startAt > 0) {
                LoadBalancer.getInstance().updateStats(targetApplication, port, System.currentTimeMillis() - startAt);
            }
        }
    }
    return null;
}
 

import org.glassfish.jersey.client.JerseyInvocation; //导入依赖的package包/类
@Override
public JerseyInvocation.Builder invocation(Link link) {
    return client.invocation(link);
}