Java 类org.springframework.util.concurrent.ListenableFutureAdapter 实例源码

/**
 * Make an HTTP request
 */
protected <T,U> ListenableFuture<T> request(HttpMethod method, String url, HttpHeaders httpHeaders, U body, Class<T> responseType) {
    if (httpHeaders == null) {
        httpHeaders = getRequestHeaders(url);
    }
    HttpEntity<U> requestEntity = new HttpEntity<>(body, httpHeaders);

    ListenableFuture<ResponseEntity<T>> future = asyncRestTemplate.exchange(url, method, requestEntity, responseType);

    return new ListenableFutureAdapter<T, ResponseEntity<T>>(future) {
        @Override
        protected T adapt(ResponseEntity<T> result) throws ExecutionException {
            return result.getBody();
        }
    };
}

/**
 * @return the list of supported operations under /v2
 */
public ListenableFuture<Map<String, String>> getV2() {
    ListenableFuture<ResponseEntity<JsonNode>> responseFuture = request(HttpMethod.GET, baseURL + "v2", null, JsonNode.class);
    return new ListenableFutureAdapter<Map<String, String>, ResponseEntity<JsonNode>>(responseFuture) {
        @Override
        protected Map<String, String> adapt(ResponseEntity<JsonNode> result) throws ExecutionException {
            Map<String, String> services = new HashMap<>();
            result.getBody().fields().forEachRemaining(entry -> services.put(entry.getKey(), entry.getValue().textValue()));
            return services;
        }
    };
}

/**
 * Retrieve the list of all Registrations
 * @return a list of registrations
 */
public ListenableFuture<List<Registration>> getRegistrations() {

    UriComponentsBuilder builder = UriComponentsBuilder.fromHttpUrl(baseURL);
    builder.path("v2/registrations");

    ListenableFuture<ResponseEntity<Registration[]>> e = request(HttpMethod.GET, builder.toUriString(), null, Registration[].class);
    return new ListenableFutureAdapter<List<Registration>, ResponseEntity<Registration[]>>(e) {
        @Override
        protected List<Registration> adapt(ResponseEntity<Registration[]> result) throws ExecutionException {
            return new ArrayList<>(Arrays.asList(result.getBody()));
        }
    };
}

/**
 * Create a new subscription
 * @param subscription the Subscription to add
 * @return subscription Id
 */
public ListenableFuture<String> addSubscription(Subscription subscription) {
    ListenableFuture<ResponseEntity<Void>> s = request(HttpMethod.POST, UriComponentsBuilder.fromHttpUrl(baseURL).path("v2/subscriptions").toUriString(), subscription, Void.class);
    return new ListenableFutureAdapter<String, ResponseEntity<Void>>(s) {
        @Override
        protected String adapt(ResponseEntity<Void> result) throws ExecutionException {
            return extractId(result);
        }
    };
}

private <T> ListenableFuture<T> adapt(ListenableFuture<ResponseEntity<T>> responseEntityListenableFuture) {
    return new ListenableFutureAdapter<T, ResponseEntity<T>>(responseEntityListenableFuture) {
        @Override
        protected T adapt(ResponseEntity<T> result) throws ExecutionException {
            return result.getBody();
        }
    };
}

private <T> ListenableFuture<Paginated<T>> adaptPaginated(ListenableFuture<ResponseEntity<T[]>> responseEntityListenableFuture, int offset, int limit) {
    return new ListenableFutureAdapter<Paginated<T>, ResponseEntity<T[]>>(responseEntityListenableFuture) {
        @Override
        protected Paginated<T> adapt(ResponseEntity<T[]> result) throws ExecutionException {
            return new Paginated<>(Arrays.asList(result.getBody()), offset, limit, extractTotalCount(result));
        }
    };
}

public <S, T> ListenableFuture<T> adaptFuture(ListenableFuture<S> futureToAdapt,
                                              FunctionalFutureAdapter<S, T> adapter) {
  return new ListenableFutureAdapter<T, S>(futureToAdapt) {
    @Override
    protected T adapt(S objectToAdapt) throws ExecutionException {
      return adapter.adapt(objectToAdapt);
    }
  };
}

protected <T> ListenableFutureAdapter<T, ResponseEntity<T>> adaptResponseEntityFuture(
    final ListenableFuture<ResponseEntity<T>> responseEntity) {
  ListenableFutureAdapter<T, ResponseEntity<T>> returnFuture;
  returnFuture = new ListenableFutureAdapter<T, ResponseEntity<T>>(responseEntity) {
    @Override
    protected T adapt(ResponseEntity<T> adapteeResult) throws ExecutionException {
      return adapteeResult.getBody();
    }
  };
  return returnFuture;
}

/**
 * Build an Http request
 *
 * @param method       Http method
 * @param url          Url
 * @param body         Request body
 * @param responseType Response type
 * @param <T>          Type to deserialize for the response
 * @param <U>          Type to serialize for the body
 * @return              Listenable for request
 */
private <T, U> ListenableFuture<T> request(HttpMethod method, String url, U body, Class<T> responseType) {
    HttpEntity<U> requestEntity = new HttpEntity<>(body, getHttpHeaders(body != null));
    ListenableFuture<ResponseEntity<T>> future = asyncRestTemplate.exchange(url, method, requestEntity, responseType);
    return new ListenableFutureAdapter<T, ResponseEntity<T>>(future) {
        @Override
        protected T adapt(ResponseEntity<T> result) throws ExecutionException {
            return result.getBody();
        }
    };
}