下面列出了怎么用java.net.http.HttpRequest.BodyPublishers的API类实例代码及写法，或者点击链接到github查看源代码。
public void postUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User");
userVO.setAddress("X Address");
userVO.setCity("X City");
userVO.setPhoneNo("1234567890");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint),
Optional.empty()
).POST(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void putUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User 1");
userVO.setAddress("X Address 1");
userVO.setCity("X City 1");
userVO.setPhoneNo("1234567899");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3"),
Optional.empty()
).PUT(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void postUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User");
userVO.setAddress("X Address");
userVO.setCity("X City");
userVO.setPhoneNo("1234567890");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint),
Optional.empty()
).POST(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void putUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User 1");
userVO.setAddress("X Address 1");
userVO.setCity("X City 1");
userVO.setPhoneNo("1234567899");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3"),
Optional.empty()
).PUT(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void postUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User");
userVO.setAddress("X Address");
userVO.setCity("X City");
userVO.setPhoneNo("1234567890");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint),
Optional.empty()
).POST(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void putUser() throws Exception {
UserVO userVO = new UserVO();
userVO.setId("3");
userVO.setName("X User 1");
userVO.setAddress("X Address 1");
userVO.setCity("X City 1");
userVO.setPhoneNo("1234567899");
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3"),
Optional.empty()
).PUT(BodyPublishers.ofString(objectMapper.writeValueAsString(userVO))).build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void bodyExample() throws IOException, InterruptedException {
HttpClient client = HttpClient.newHttpClient();
HttpRequest request = HttpRequest.newBuilder()
.header("Content-Type", "application/json")
.POST(BodyPublishers.ofString(
"{\"email\":\"[email protected]\",\"password\":\"cityslicka\"}"))
.uri(URI.create("https://reqres.in/api/login"))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
System.out.println("Status code: " + response.statusCode());
System.out.println("\n Body: " + response.body());
}
private SafeFuture<BLSSignature> sign(final Bytes signingRoot) {
final String publicKey = blsPublicKey.getPublicKey().toString();
return SafeFuture.ofComposed(
() -> {
final String requestBody = createSigningRequestBody(signingRoot);
final URI uri = signingServiceUrl.toURI().resolve("/signer/sign/" + publicKey);
final HttpRequest request =
HttpRequest.newBuilder()
.uri(uri)
.timeout(timeout)
.POST(BodyPublishers.ofString(requestBody))
.build();
return HttpClient.newHttpClient()
.sendAsync(request, BodyHandlers.ofString())
.handleAsync(this::getBlsSignature);
});
}
protected void handleRouteJsonBodySend(@Nonnull final Route finalRoute, @Nonnull final QueuedRequest request) {
final OutboundRequest r = request.request();
final String encoded;
if(r.object() != null) {
for(final Extension extension : catnip.extensionManager().extensions()) {
for(final CatnipHook hook : extension.hooks()) {
r.object(hook.rawRestSendObjectHook(finalRoute, r.object()));
}
}
encoded = JsonWriter.string(r.object());
} else if(r.array() != null) {
encoded = JsonWriter.string(r.array());
} else {
encoded = null;
}
executeHttpRequest(finalRoute, encoded == null ? BodyPublishers.noBody() : BodyPublishers.ofString(encoded), request, "application/json");
}
private static void postAsync(){
HttpClient httpClient = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:3333/something"))
.POST(BodyPublishers.ofString("Hi there!"))
.build();
CompletableFuture<String> cf =
httpClient.sendAsync(req, BodyHandlers.ofString())
.thenApply(resp -> "Server responded: " + resp.body());
System.out.println("The request was sent asynchronously...");
try {
System.out.println("CompletableFuture get: " +
cf.get(5, TimeUnit.SECONDS));
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println("Exit the client...");
}
private void upload(String url, File file, String contentType) {
HttpRequest request;
try {
request = createRequest(url).header("Content-Type", contentType).PUT(BodyPublishers.ofFile(file.toPath())).build();
} catch (FileNotFoundException e) {
LOG.error("unable to upload: {}", url, e);
return;
}
httpclient.sendAsync(request, BodyHandlers.ofString()).exceptionally(ex -> {
Util.logIOException(LOG, "unable to upload: " + url, ex);
return null;
}).thenAccept(response -> {
if (response != null && response.statusCode() != 200 && LOG.isErrorEnabled()) {
LOG.error("unable to upload: {} response code: {}. response: {}", url, response.statusCode(), response.body());
}
});
}
/**
* Performs HTTP POST request.
* Credits https://stackoverflow.com/questions/3324717/sending-http-post-request-in-java
* @param address the URL of the connection in String format, like "http://www.google.com"
* @param arguments the body of the POST request, as a HashMap
* @return response object
* @throws IOException if an I/O error occurs
* @throws InterruptedException if the operation is interrupted
*/
public static HttpResponse<String> httpPost(String address, HashMap<String, String> arguments)
throws IOException, InterruptedException {
var sj = new StringJoiner("&");
for (var entry : arguments.entrySet()) {
sj.add(URLEncoder.encode(entry.getKey(), "UTF-8") + "="
+ URLEncoder.encode(entry.getValue(), "UTF-8"));
}
var out = sj.toString().getBytes(StandardCharsets.UTF_8);
var request = HttpRequest.newBuilder()
.uri(URI.create(address))
.headers("Content-Type", "application/x-www-form-urlencoded; charset=UTF-8")
.POST(BodyPublishers.ofByteArray(out))
.build();
return HttpClient.newHttpClient().send(request, BodyHandlers.ofString());
}
/**
* Build the body for the request builder. Handling compression type of the request.
*
* @param builder Request Builder
* @param algoliaRequest HttpClient agnostic Algolia's request
*/
private BodyPublisher buildRequestBody(
@Nonnull Builder builder, @Nonnull HttpRequest algoliaRequest) {
if (algoliaRequest.getBody() == null) {
return java.net.http.HttpRequest.BodyPublishers.noBody();
}
if (algoliaRequest.canCompress()) {
builder.header(Defaults.CONTENT_ENCODING_HEADER, Defaults.CONTENT_ENCODING_GZIP);
} else {
builder.header(Defaults.CONTENT_TYPE_HEADER, Defaults.APPLICATION_JSON);
}
return BodyPublishers.ofInputStream(algoliaRequest::getBody);
}
@Override
public Map<String, String> insertImage(final String digest, byte[] decoded) {
var blobUri = this.createBlobUri(digest);
var request = HttpRequest.newBuilder(blobUri).
PUT(BodyPublishers.ofByteArray(decoded)).build();
try {
var response = client.send(request, HttpResponse.BodyHandlers.ofString());
var result = new HashMap<String, String>();
result.put("digest", digest);
result.put("url", "/image/" + digest);
result.put("status", String.valueOf(response.statusCode()));
return result;
} catch (IOException | InterruptedException e) {
throw new DataIntegrityViolationException("Failed to call blob endpoint", e);
}
}
public void patchUser() throws Exception {
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3/name?value=Duke+Williams"), Optional.empty())
.method("PATCH", BodyPublishers.noBody())
.build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void patchUser() throws Exception {
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3/name?value=Duke+Williams"), Optional.empty())
.method("PATCH", BodyPublishers.noBody())
.build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
public void patchUser() throws Exception {
HttpRequest request = restClient.requestBuilder(
URI.create(userEndpoint + "/3/name?value=Duke+Williams"), Optional.empty())
.method("PATCH", BodyPublishers.noBody())
.build();
HttpResponse<String> response = restClient.send(request);
LOG.info("Response status code: {}", response.statusCode());
LOG.info("Response headers: {}", response.headers());
LOG.info("Response body: {}", response.body());
}
@Override
public void setBody(String body) {
if (method.equals("GET") || method.equals("DELETE")) {
builder.method(method, BodyPublishers.noBody());
} else {
builder.method(method, BodyPublishers.ofString(body));
}
}
public BodyPublisher build() {
if(partsSpecificationList.isEmpty()) {
throw new IllegalStateException("Must have at least one part to build multipart message.");
}
addFinalBoundary();
return BodyPublishers.ofByteArrays(PartsIterator::new);
}
private static void post(){
HttpClient httpClient = HttpClient.newHttpClient();
HttpRequest req = HttpRequest.newBuilder()
.uri(URI.create("http://localhost:3333/something"))
.POST(BodyPublishers.ofString("Hi there!"))
.build();
try {
HttpResponse<String> resp = httpClient.send(req, BodyHandlers.ofString());
System.out.println("Response: " + resp.statusCode() + " : " + resp.body());
} catch (Exception ex) {
ex.printStackTrace();
}
}
public static void main(String[] args) throws IOException, InterruptedException {
HttpClient client = HttpClient.newBuilder().build();
HttpRequest post = HttpRequest
.newBuilder(POSTMAN_POST)
.POST(new LoggingBodyPublisher(BodyPublishers.ofFile(LARGE_JSON)))
.header("Content-Type", "application/json")
.build();
HttpResponse<String> response = client
.send(post, BodyHandlers.ofString());
System.out.println("Status: " + response.statusCode());
System.out.println(response.body());
}
@Override
public boolean imageExists(@NonNull final String digest) {
var request = HttpRequest
.newBuilder(this.createBlobUri(digest))
.method("HEAD", HttpRequest.BodyPublishers.noBody())
.build();
try {
var response = client.send(request, HttpResponse.BodyHandlers.discarding());
return response.statusCode() == HttpStatus.OK.value();
} catch (IOException | InterruptedException e) {
throw new DataIntegrityViolationException("Failed to call blob endpoint", e);
}
}
/**
* Sets a String body to the request
*
* @param body The request body to use
*
* @return TestResponse instance
*/
public TestResponse withStringBody(String body) {
if (StringUtils.isNotBlank(body)) {
this.body = BodyPublishers.ofString(body);
}
return this;
}
/**
* Simulates a FORM post by setting:
*
* Content-Type to application/x-www-form-urlencoded
* HTTP method to POST
* URLEncoding of the given parameters
*
* @param parameters The parameters to use
* @return TestResponse instance
*/
public TestResponse withForm(Multimap<String, String> parameters) {
String form = parameters.entries()
.stream()
.map(entry -> entry.getKey() + "=" + URLEncoder.encode(entry.getValue(), Charset.forName(Default.ENCODING.toString())))
.collect(Collectors.joining("&"));
this.httpRequest.header(CONTENT_TYPE, "application/x-www-form-urlencoded");
this.body = BodyPublishers.ofString(form);
this.method = Methods.POST.toString();
return this;
}
public static void httpPostRequest() throws URISyntaxException, IOException, InterruptedException {
HttpClient client = HttpClient.newBuilder()
.version(HttpClient.Version.HTTP_2)
.build();
HttpRequest request = HttpRequest.newBuilder(new URI("http://jsonplaceholder.typicode.com/posts"))
.version(HttpClient.Version.HTTP_2)
.POST(BodyPublishers.ofString("Sample Post Request"))
.build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
String responseBody = response.body();
System.out.println("httpPostRequest : " + responseBody);
}
protected void executeHttpRequest(@Nonnull final Route route, @Nullable final BodyPublisher body,
@Nonnull final QueuedRequest request, @Nonnull final String mediaType) {
final HttpRequest.Builder builder;
final String apiHostVersion = catnip.options().apiHost() + "/api/v" + catnip.options().apiVersion();
if(route.method() == GET) {
// No body
builder = HttpRequest.newBuilder(URI.create(apiHostVersion + route.baseRoute())).GET();
} else {
final var fakeBody = request.request.emptyBody();
builder = HttpRequest.newBuilder(URI.create(apiHostVersion + route.baseRoute()))
.setHeader("Content-Type", mediaType)
.method(route.method().name(), fakeBody ? BodyPublishers.ofString(" ") : body);
if(fakeBody) {
// If we don't have a body, then the body param is null, which
// seems to not set a Content-Length. This explicitly tries to set
// up a request shaped in a way that makes Discord not complain.
catnip.logAdapter().trace("Set fake body due to lack of body.");
}
}
// Required by Discord
builder.setHeader("User-Agent", "DiscordBot (https://github.com/mewna/catnip, " + CatnipMeta.VERSION + ')');
// Request more precise ratelimit headers for better timing
// NOTE: THIS SHOULD NOT BE CONFIGURABLE BY THE END USER
// This is pretty important for getting timing of things like reaction
// routes correct, so there's no use for the end-user messing around
// with this.
// If they REALLY want it, they can write their own requester.
builder.setHeader("X-RateLimit-Precision", "millisecond");
if(request.request().needsToken()) {
builder.setHeader("Authorization", "Bot " + catnip.options().token());
}
if(request.request().reason() != null) {
catnip.logAdapter().trace("Adding reason header due to specific needs.");
builder.header(Requester.REASON_HEADER, Utils.encodeUTF8(request.request().reason()));
}
// Update request start time as soon as possible
// See QueuedRequest docs for why we do this
request.start = System.nanoTime();
catnip.options().httpClient().sendAsync(builder.build(), BodyHandlers.ofString())
.thenAccept(res -> {
final int code = res.statusCode();
final String message = "Unavailable to due Java's HTTP client.";
final long requestEnd = System.nanoTime();
catnip.rxScheduler().scheduleDirect(() ->
handleResponse(route, code, message, requestEnd, res.body(), res.headers(), request));
})
.exceptionally(e -> {
request.bucket.failedRequest(request, e);
return null;
});
}
private HttpRequest.Builder createJsonRequest(String path, JsonValue json) {
return createRequest(path).header("Content-Type", "application/json").POST(BodyPublishers.ofString(json.toString(), StandardCharsets.UTF_8));
}
private HttpRequest.Builder createJsonPost(String path, JsonObject obj) {
return createAuthRequest(path).header("Content-Type", "application/json").POST(BodyPublishers.ofString(obj.toString(), StandardCharsets.UTF_8));
}