Java HttpClientResponse.bodyHandler方法代码示例

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
private Handler<RestResponse> syncHandlerEx(CountDownLatch countDownLatch, Holder<ResponseWrapper> holder) {
  return restResponse -> {
    RequestContext requestContext = restResponse.getRequestContext();
    HttpClientResponse response = restResponse.getResponse();
    if (response == null) {
      // 请求失败，触发请求SC的其他实例
      if (!requestContext.isRetry()) {
        retry(requestContext, syncHandlerEx(countDownLatch, holder));
      } else {
        countDownLatch.countDown();
      }

      return;
    }

    response.bodyHandler(bodyBuffer -> {
      ResponseWrapper responseWrapper = new ResponseWrapper();
      responseWrapper.response = response;
      responseWrapper.bodyBuffer = bodyBuffer;
      holder.value = responseWrapper;
      countDownLatch.countDown();
    });
  };
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
void handleResponse(Invocation invocation, HttpClientResponse clientResponse,
    AsyncResponse asyncResp) {
  clientResponse.bodyHandler(responseBuf -> {
    // 此时是在网络线程中，不应该就地处理，通过dispatcher转移线程
    invocation.getResponseExecutor().execute(() -> {
      try {
        HttpServletResponseEx responseEx =
            new VertxClientResponseToHttpServletResponse(clientResponse, responseBuf);
        for (HttpClientFilter filter : httpClientFilters) {
          Response response = filter.afterReceiveResponse(invocation, responseEx);
          if (response != null) {
            asyncResp.complete(response);
            return;
          }
        }
      } catch (Throwable e) {
        asyncResp.fail(invocation.getInvocationType(), e);
      }
    });
  });
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
default void handleError(HttpClientResponse response) {
	response.bodyHandler(bh -> {
		String body = bh.toString();
		if (log.isDebugEnabled()) {
			log.debug(body);
		}

		log.error("Request failed with statusCode {" + response.statusCode() + "} statusMessage {" + response.statusMessage() + "} {" + body
				+ "} for method {" + getMethod() + "} and uri {" + getUri() + "}");

		// Try to parse the body data and fail using the extracted exception.
		try {
			JsonObject responseObj = new JsonObject(body);
			getFuture().fail(new MeshRestClientJsonObjectException(response.statusCode(), response.statusMessage(), responseObj));
			return;
		} catch (Exception e) {
			if (log.isDebugEnabled()) {
				log.debug("Could not deserialize response {" + body + "}.", e);
			}
		}

		getFuture().fail(new MeshRestClientMessageException(response.statusCode(), response.statusMessage()));
		return;
	});

}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
/**
 * Handler method which should be invoked for HTTP responses other than 2xx, 3xx status code.
 * 
 * @param response
 */
default void handleError(HttpClientResponse response) {
	response.bodyHandler(bh -> {
		String body = bh.toString();
		if (log.isDebugEnabled()) {
			log.debug(body);
		}

		log.error("Request failed with statusCode {" + response.statusCode() + "} statusMessage {" + response.statusMessage() + "} {" + body
				+ "} for method {" + getMethod() + "} and uri {" + getUri() + "}");

		// Try to parse the body data and fail using the extracted exception.
		try {
			GenericMessageResponse responseMessage = JsonUtil.readValue(body, GenericMessageResponse.class);
			getFuture().fail(new MeshRestClientMessageException(response.statusCode(), response.statusMessage(), responseMessage));
			return;
		} catch (Exception e) {
			if (log.isDebugEnabled()) {
				log.debug("Could not deserialize response {" + body + "}.", e);
			}
		}

		getFuture().fail(new MeshRestClientMessageException(response.statusCode(), response.statusMessage()));
		return;
	});
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private <T> Handler<RestResponse> syncHandler(CountDownLatch countDownLatch, Class<T> cls,
    Holder<T> holder) {
  return restResponse -> {
    RequestContext requestContext = restResponse.getRequestContext();
    HttpClientResponse response = restResponse.getResponse();
    if (response == null) {
      // 请求失败，触发请求SC的其他实例
      if (!requestContext.isRetry()) {
        retry(requestContext, syncHandler(countDownLatch, cls, holder));
      } else {
        countDownLatch.countDown();
      }
      return;
    }
    response.bodyHandler(
        bodyBuffer -> {
          if (cls.getName().equals(HttpClientResponse.class.getName())) {
            holder.value = (T) response;
            countDownLatch.countDown();
            return;
          }
          try {
            holder.value =
                JsonUtils.readValue(bodyBuffer.getBytes(), cls);
          } catch (Exception e) {
            LOGGER.warn("read value failed and response message is {}",
                bodyBuffer.toString());
          }
          countDownLatch.countDown();
        });
  };
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
private <T> Handler<RestResponse> syncHandlerForInstances(CountDownLatch countDownLatch,
    MicroserviceInstances mInstances) {
  return restResponse -> {
    RequestContext requestContext = restResponse.getRequestContext();
    HttpClientResponse response = restResponse.getResponse();
    if (response == null) {
      // 请求失败，触发请求SC的其他实例
      if (!requestContext.isRetry()) {
        retry(requestContext, syncHandlerForInstances(countDownLatch, mInstances));
      } else {
        countDownLatch.countDown();
      }
      return;
    }
    response.bodyHandler(
        bodyBuffer -> {
          try {
            mInstances.setRevision(response.getHeader("X-Resource-Revision"));
            switch (response.statusCode()) {
              case 304:
                mInstances.setNeedRefresh(false);
                break;
              case 200:
                mInstances
                    .setInstancesResponse(JsonUtils.readValue(bodyBuffer.getBytes(), FindInstancesResponse.class));
                break;
              default:
                LOGGER.warn(bodyBuffer.toString());
                break;
            }
          } catch (Exception e) {
            LOGGER.warn("read value failed and response message is {}", bodyBuffer.toString());
          }
          countDownLatch.countDown();
        });
  };
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
/**
 * Similar to {@link #body} except that it also parses the body buffer to a {@link JsonObject}
 * @param response the response from a http call
 * @return A {@link Future} that will resolve to a {@link JsonObject} if no HTTP errors or exceptions
 */
static Future<JsonObject> bodyObject(HttpClientResponse response) {
  Future<JsonObject> result = Future.future();
  response.bodyHandler(buffer -> {
    try {
      JsonObject jo = buffer.toJsonObject();
      result.complete(jo);
    } catch (Throwable err) {
      result.fail(err);
    }
  });
  return result;
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
/**
 * Similar to {@link #body} except that it also parses the body buffer to a {@link JsonArray}
 * @param response the response from a http call
 * @return A {@link Future} that will resolve to a {@link JsonArray} if no HTTP errors or exceptions
 */
static Future<JsonArray> bodyArray(HttpClientResponse response) {
  Future<JsonArray> result = Future.future();
  response.bodyHandler(buffer -> {
    try {
      JsonArray ja = buffer.toJsonArray();
      result.complete(ja);
    } catch (Throwable err) {
      result.fail(err);
    }
  });
  return result;
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
private void checkGeoJsonResponse(HttpClientResponse response, TestContext context, Handler<JsonObject> handler) {
  response.bodyHandler(body -> {
    JsonObject returned = body.toJsonObject();
    context.assertNotNull(returned);
    context.assertTrue(returned.containsKey("geometries"));
    handler.handle(returned);
  });
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
@Override
public void handleSuccess(HttpClientResponse rh) {

	WebRootResponse response = new WebRootResponse();
	NodeDownloadResponse downloadResponse = new NodeDownloadResponse();
	String contentType = rh.getHeader(MeshHeaders.WEBROOT_RESPONSE_TYPE);
	if (contentType == null) {
		future.fail("The {" + MeshHeaders.WEBROOT_RESPONSE_TYPE + "} header was not set correctly.");
		return;
	}
	if (contentType.startsWith("node")) {
		// Delegate the response to the json handler
		ModelResponseHandler<NodeResponse> handler = new ModelResponseHandler<>(NodeResponse.class, getMethod(), contentType);
		handler.handle(rh);
		handler.getFuture().setHandler(rh2 -> {
			if (rh2.failed()) {
				future.fail(rh2.cause());
			} else {
				response.setNodeResponse(rh2.result());
				future.complete(response);
			}
		});
	} else {
		downloadResponse.setContentType(contentType);
		String disposition = rh.getHeader("content-disposition");
		String filename = disposition.substring(disposition.indexOf("=") + 1);
		downloadResponse.setFilename(filename);

		rh.bodyHandler(buffer -> {
			downloadResponse.setBuffer(buffer);
			response.setDownloadResponse(downloadResponse);
			future.complete(response);
		});
	}
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
/**
 * Handle the mesh response. This method will deserialise the JSON response.
 */
public void handleSuccess(HttpClientResponse response) {
	String contentType = response.getHeader("Content-Type");
	//FIXME TODO in theory it would also be possible that a customer uploads JSON into mesh. In those cases we would also need to return it directly (without parsing)
	if (contentType == null && response.statusCode() == NO_CONTENT.code()) {
		if (log.isDebugEnabled()) {
			log.debug("Got {" + NO_CONTENT.code() + "} response.");
		}
		future.complete();
	} else if (contentType != null && contentType.startsWith(HttpConstants.APPLICATION_JSON)) {
		response.bodyHandler(bh -> {
			String json = bh.toString();
			if (log.isDebugEnabled()) {
				log.debug(json);
			}
			try {
				T restObj = JsonUtil.readValue(json, classOfT);
				future.complete(restObj);
			} catch (Exception e) {
				log.error("Failed to deserialize json to class {" + classOfT + "}", e);
				future.fail(e);
			}
		});
	} else {
		//TODO move regular string success handler into dedicated interface
		if (classOfT.isAssignableFrom(String.class)) {
			response.bodyHandler(buffer -> {
				future.complete((T) buffer.toString());
			});
		} else {
			response.bodyHandler(buffer -> {
				future.fail(new RuntimeException("Request can't be handled by this handler since the content type was {" + contentType + "}"));
			});
		}
	}
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
@Override
public void handleSuccess(HttpClientResponse rh) {
	NodeDownloadResponse response = new NodeDownloadResponse();
	String contentType = rh.getHeader(HttpHeaders.CONTENT_TYPE.toString());
	response.setContentType(contentType);
	String disposition = rh.getHeader("content-disposition");
	String filename = disposition.substring(disposition.indexOf("=") + 1);
	response.setFilename(filename);

	rh.bodyHandler(buffer -> {
		response.setBuffer(buffer);
		future.complete(response);
	});
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
default void handleSuccess(HttpClientResponse response) {
	String contentType = response.getHeader("Content-Type");
	// FIXME TODO in theory it would also be possible that a customer uploads JSON into mesh. In those cases we would also need to return it directly
	// (without parsing)
	if (contentType == null && response.statusCode() == NO_CONTENT.code()) {
		if (log.isDebugEnabled()) {
			log.debug("Got {" + NO_CONTENT.code() + "} response.");
		}
		getFuture().complete();
	} else if (contentType.startsWith(HttpConstants.APPLICATION_JSON)) {
		response.bodyHandler(bh -> {
			String json = bh.toString();
			if (log.isDebugEnabled()) {
				log.debug(json);
			}
			try {
				getFuture().setBodyJson(json);
				getFuture().complete(new JsonObject(json));
			} catch (Exception e) {
				log.error("Failed to deserialize json", e);
				getFuture().fail(e);
			}
		});
	} else {
		response.bodyHandler(buffer -> {
			getFuture().fail(new RuntimeException("Request can't be handled by this handler since the content type was {" + contentType + "}"));
		});
	}
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
private void processText(HttpClientResponse resp) {
    resp.bodyHandler(
            buffer -> {
                try {
                    parser.parse(url, buffer.toString());
                } catch (Exception e) {
                    logger.error("Failed to parse {}: {}", url, e.getMessage());
                } finally {
                    processResult();
                }
            });
}
 

import io.vertx.core.http.HttpClientResponse; //导入方法依赖的package包/类
/**
 * Given a {@link HttpClientResponse} returns a {@link Future Future<Buffer>} for retrieving the body of the request as a {@link Buffer}
 * @param response the response from a http call
 * @return A future that will resolve to a {@link Buffer} if the Http response is not a HTTP error status
 */
static Future<Buffer> body(HttpClientResponse response) {
  Future<Buffer> result = Future.future();
  response.bodyHandler(result::complete);
  return result;
}