Java Response类代码示例

import com.amazonaws.Response; //导入依赖的package包/类
private void populateAndEndSubsegment(Subsegment currentSubsegment, Request<?> request, Response<?> response) {
    if (null != response) {
        String requestId = null;
        if (response.getAwsResponse() instanceof AmazonWebServiceResult<?>) { // Not all services return responses extending AmazonWebServiceResult (e.g. S3)
            ResponseMetadata metadata = ((AmazonWebServiceResult<?>) response.getAwsResponse()).getSdkResponseMetadata();
            if (null != metadata) {
                requestId = metadata.getRequestId();
                if (null != requestId) {
                    currentSubsegment.putAws(REQUEST_ID_SUBSEGMENT_KEY, requestId);
                }
            }
        } else if (null != response.getHttpResponse()) { // S3 does not follow request id header convention
            if (null != response.getHttpResponse().getHeader(S3_REQUEST_ID_HEADER_KEY)) {
                currentSubsegment.putAws(REQUEST_ID_SUBSEGMENT_KEY, response.getHttpResponse().getHeader(S3_REQUEST_ID_HEADER_KEY));
            }
            if (null != response.getHttpResponse().getHeader(S3_EXTENDED_REQUEST_ID_HEADER_KEY)) {
                currentSubsegment.putAws(EXTENDED_REQUEST_ID_SUBSEGMENT_KEY, response.getHttpResponse().getHeader(S3_EXTENDED_REQUEST_ID_HEADER_KEY));
            }
        }
        currentSubsegment.putAllAws(extractResponseParameters(request, response.getAwsResponse()));
        currentSubsegment.putAllHttp(extractHttpResponseInformation(response.getHttpResponse()));
    }

    finalizeSubsegment(request);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Executes the request and returns the result.
 *
 * @param request              The AmazonWebServices request to send to the remote server
 * @param responseHandler      A response handler to accept a successful response from the
 *                             remote server
 * @param errorResponseHandler A response handler to accept an unsuccessful response from the
 *                             remote server
 * @param executionContext     Additional information about the context of this web service
 *                             call
 * @deprecated Use {@link #requestExecutionBuilder()} to configure and execute a HTTP request.
 */
@Deprecated
public <T> Response<T> execute(Request<?> request,
                               HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler,
                               HttpResponseHandler<AmazonServiceException> errorResponseHandler,
                               ExecutionContext executionContext) {
    HttpResponseHandler<T> adaptedRespHandler = new AwsResponseHandlerAdapter<T>(
            getNonNullResponseHandler(responseHandler),
            request,
            executionContext.getAwsRequestMetrics(),
            responseMetadataCache);
    return requestExecutionBuilder()
            .request(request)
            .requestConfig(new AmazonWebServiceRequestAdapter(request.getOriginalRequest()))
            .errorResponseHandler(new AwsErrorResponseHandler(errorResponseHandler, executionContext.getAwsRequestMetrics()))
            .executionContext(executionContext)
            .execute(adaptedRespHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private void execRequest(String endpoint, int status) {
  AWSRequestMetrics metrics = new AWSRequestMetricsFullSupport();
  metrics.addProperty(AWSRequestMetrics.Field.ServiceName, "AmazonCloudWatch");
  metrics.addProperty(AWSRequestMetrics.Field.ServiceEndpoint, endpoint);
  metrics.addProperty(AWSRequestMetrics.Field.StatusCode, "" + status);
  if (status == 503) {
    metrics.addProperty(AWSRequestMetrics.Field.AWSErrorCode, "Throttled");
  }
  String counterName = "BytesProcessed";
  String timerName = "ClientExecuteTime";
  metrics.setCounter(counterName, 12345);
  metrics.getTimingInfo().addSubMeasurement(timerName, TimingInfo.unmodifiableTimingInfo(100000L, 200000L));

  Request<?> req = new DefaultRequest(new ListMetricsRequest(), "AmazonCloudWatch");
  req.setAWSRequestMetrics(metrics);
  req.setEndpoint(URI.create(endpoint));

  HttpResponse hr = new HttpResponse(req, new HttpPost(endpoint));
  hr.setStatusCode(status);
  Response<?> resp = new Response<>(null, new HttpResponse(req, new HttpPost(endpoint)));

  collector.collectMetrics(req, resp);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private <T> T invoke(HttpMethodName httpMethodName, String resourcePath, Object representation,
                     HttpResponseHandler<AmazonWebServiceResponse<T>> responseHandler)
        throws AmazonClientException {
    ExecutionContext executionContext = createExecutionContext();
    AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.RequestMarshallTime.name());
    Request request = buildRequest(httpMethodName, resourcePath, representation);
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.RequestMarshallTime.name());

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.CredentialsRequestTime.name());
    AWSCredentials credentials = awsCredentialsProvider.getCredentials();
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.CredentialsRequestTime.name());

    executionContext.setCredentials(credentials);

    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.ClientExecuteTime.name());
    Response<T> response = client.execute(request, responseHandler, errorResponseHandler, executionContext);
    awsRequestMetrics.endEvent(AWSRequestMetrics.Field.ClientExecuteTime.name());

    awsRequestMetrics.log();

    return response.getAwsResponse();
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public void afterResponse(Request<?> request, Response<?> response) {
    if (isSubsegmentDuplicate(recorder.getCurrentSubsegmentOptional(), request)) {
        Optional<Subsegment> currentSubsegmentOptional = recorder.getCurrentSubsegmentOptional();
        if (!currentSubsegmentOptional.isPresent()) {
            return;
        }
        Subsegment currentSubsegment = currentSubsegmentOptional.get();
        populateAndEndSubsegment(currentSubsegment, request, response, null);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Start and end client execution timer around the execution of the request. It's important
 * that the client execution task is canceled before the InterruptedExecption is handled by
 * {@link #execute()} so * the interrupt status doesn't leak out to the callers code
 */
private Response<Output> executeWithTimer() throws InterruptedException {
    try {
        executionContext.setClientExecutionTrackerTask(
                clientExecutionTimer.startTimer(getClientExecutionTimeout(requestConfig)));
        return doExecute();
    } finally {
        executionContext.getClientExecutionTrackerTask().cancelTask();
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private Response<Output> doExecute() throws InterruptedException {
    runBeforeRequestHandlers();
    setSdkTransactionId(request);
    setUserAgent(request);

    ProgressListener listener = requestConfig.getProgressListener();
    // add custom headers
    request.getHeaders().putAll(config.getHeaders());
    request.getHeaders().putAll(requestConfig.getCustomRequestHeaders());
    // add custom query parameters
    mergeQueryParameters(requestConfig.getCustomQueryParameters());
    Response<Output> response = null;
    final InputStream origContent = request.getContent();
    final InputStream toBeClosed = beforeRequest(); // for progress tracking
    // make "notCloseable", so reset would work with retries
    final InputStream notCloseable = (toBeClosed == null) ? null
            : ReleasableInputStream.wrap(toBeClosed).disableClose();
    request.setContent(notCloseable);
    try {
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_STARTED_EVENT);
        response = executeHelper();
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_SUCCESS_EVENT);
        awsRequestMetrics.getTimingInfo().endTiming();
        afterResponse(response);
        return response;
    } catch (AmazonClientException e) {
        publishProgress(listener, ProgressEventType.CLIENT_REQUEST_FAILED_EVENT);
        afterError(response, e);
        throw e;
    } finally {
        // Always close so any progress tracking would get the final events propagated.
        closeQuietly(toBeClosed, log);
        request.setContent(origContent); // restore the original content
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
private void afterError(Response<?> response,
                        AmazonClientException e) throws InterruptedException {
    for (RequestHandler2 handler2 : requestHandler2s) {
        handler2.afterError(request, response, e);
        checkInterrupted(response);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Override
public <Input, Output> Output execute(
        ClientExecutionParams<Input, Output> executionParams) {
    final Input input = executionParams.getInput();
    ExecutionContext executionContext = createExecutionContext(
            executionParams.getRequestConfig());
    AWSRequestMetrics awsRequestMetrics = executionContext.getAwsRequestMetrics();
    awsRequestMetrics.startEvent(AWSRequestMetrics.Field.ClientExecuteTime);
    Request<Input> request = null;
    Response<Output> response = null;

    try {
        awsRequestMetrics.startEvent(AWSRequestMetrics.Field.RequestMarshallTime);
        try {
            request = executionParams.getMarshaller().marshall(input);
            request.setAWSRequestMetrics(awsRequestMetrics);
        } finally {
            awsRequestMetrics.endEvent(AWSRequestMetrics.Field.RequestMarshallTime);
        }

        response = invoke(request,
                          executionParams.getRequestConfig(),
                          executionContext,
                          executionParams.getResponseHandler(),
                          executionParams.getErrorResponseHandler());

        return response.getAwsResponse();

    } finally {

        endClientExecution(awsRequestMetrics,
                           executionParams.getRequestConfig(),
                           request,
                           response);
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Normal invoke with authentication. Credentials are required and may be overriden at the
 * request level.
 **/
private <Output, Input> Response<Output> invoke(Request<Input> request,
                                                RequestConfig requestConfig,
                                                ExecutionContext executionContext,
                                                HttpResponseHandler<Output> responseHandler,
                                                HttpResponseHandler<? extends SdkBaseException> errorResponseHandler) {

    executionContext.setCredentialsProvider(CredentialUtils.getCredentialsProvider(
            requestConfig, awsCredentialsProvider));

    return doInvoke(request, requestConfig, executionContext, responseHandler,
                    errorResponseHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Invoke the request using the http client. Assumes credentials (or lack thereof) have been
 * configured in the ExecutionContext beforehand.
 **/
private <Output, Input> Response<Output> doInvoke(Request<Input> request,
                                                  RequestConfig requestConfig,
                                                  ExecutionContext executionContext,
                                                  HttpResponseHandler<Output> responseHandler,
                                                  HttpResponseHandler<? extends SdkBaseException> errorResponseHandler) {
    request.setEndpoint(endpoint);
    return client.requestExecutionBuilder()
            .request(request)
            .requestConfig(requestConfig)
            .executionContext(executionContext)
            .errorResponseHandler(errorResponseHandler)
            .execute(responseHandler);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Convenient method to end the client execution without logging the awsRequestMetrics.
 */
private void endClientExecution(AWSRequestMetrics awsRequestMetrics,
                                      RequestConfig requestConfig,
                                      Request<?> request,
                                      Response<?> response) {
    if (request != null) {
        awsRequestMetrics.endEvent(AWSRequestMetrics.Field.ClientExecuteTime);
        awsRequestMetrics.getTimingInfo().endTiming();
        RequestMetricCollector metricCollector = findRequestMetricCollector(requestConfig);
        metricCollector.collectMetrics(request, response);
        awsRequestMetrics.log();
    }
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@SuppressWarnings("deprecation")
@Override
public void afterResponse(Request<?> request, Response<?> response) {
    AWSRequestMetrics awsRequestMetrics = request == null ? null : request
            .getAWSRequestMetrics();
    Object awsResponse = response == null ? null : response
            .getAwsResponse();
    TimingInfo timingInfo = awsRequestMetrics == null ? null
            : awsRequestMetrics.getTimingInfo();
    old.afterResponse(request, awsResponse, timingInfo);
}
 

import com.amazonaws.Response; //导入依赖的package包/类
@Before
public void setup() {
    MockitoAnnotations.initMocks(this);
    stackedRequestHandler = new StackedRequestHandler(new ArrayList<RequestHandler2>());

    response = new Response<String>("Dummy response", new HttpResponse(request, new HttpGet()));
}
 

import com.amazonaws.Response; //导入依赖的package包/类
/**
 * Perform this request.	
 */
@Override
public T perform() {
    final Response<T> rsp = new AmazonHttpClient(new ClientConfiguration())
        .requestExecutionBuilder()
        .executionContext(new ExecutionContext(true))
        .request(this.request)
        .errorResponseHandler(this.errHandler)
        .execute(this.respHandler);
    return rsp.getAwsResponse();
}