Java Code Examples for java.net.http.HttpResponse#body()

/**
 * Make the HTTP request without using the burp callbacks interface
 */
public void makeRequestWithoutBurp(){
    HttpClient client = HttpClient.newBuilder().followRedirects(HttpClient.Redirect.ALWAYS).build();
    HttpRequest request = HttpRequest.newBuilder()
        .uri(URI.create(urlString))
        .build();
    try {
        HttpResponse<String> response = client.send(request, BodyHandlers.ofString());
        statusCode = (short) response.statusCode();
        responseBody = response.body();
        responseBodyBytes = response.body().getBytes();
    }
    catch (Exception ex) {
        System.err.println("[-] There was an issue getting the JavaScript file at " + urlString);
        ex.printStackTrace();
        responseBody = NO_DATA_RECEIVED;
    }
}
 

/**
 * Test file.
 *
 * @throws Exception when a serious error occurs.
 */
@Test
public void testFile() throws Exception {
    HttpServer server = createServer(8765);
    server.start();
    try {
        HttpClient client = HttpClient.newHttpClient();
        HttpRequest request = HttpRequest.newBuilder(URI.create("http://localhost:8765/pom.xml")).build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString(StandardCharsets.UTF_8));
        assertEquals(response.statusCode(), 200);
        String responseText = response.body();
        assertTrue(responseText.contains("modelVersion"));
    } catch (IOException ioe) {
        throw new RuntimeException(ioe);
    } finally {
        server.stop();
    }
}
 

private Map<String, Object> retrieveAccessToken(String code){
    try {
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(buildClaimsRetrieverUrl()))
            .header("Content-Type", openIdConfiguration().getContentType())
            .POST(HttpRequest.BodyPublishers.ofString(buildRetrieveClaimsUrlBody(code)))
            .build();

        HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
        if(HttpUtils.callSuccessful(response)) {
            logger.trace("Access Token successfully retrieved");
            return objectMapper.readValue(response.body(), new TypeReference<>() {});
        } else {
            logger.warn("cannot retrieve access token");
            throw new IllegalStateException("cannot retrieve access token. Response from server: " +response.body());
        }
    } catch (Exception e) {
        logger.error("There has been an error retrieving the access token from the idp using the authorization code", e);
        throw new RuntimeException(e);
    }
}
 

/**
 * Download the source code for a release to the specified directory
 * @param release to download
 * @param directory to store the downloaded zip file
 * @return path to the download zip file or null
 */
public static Path downloadReleaseSourceCode(Release release, Path directory)
{
    HttpClient client = HttpClient.newBuilder()
        .followRedirects(HttpClient.Redirect.ALWAYS)
        .build();

    System.out.println("Downloading: " + release.getDownloadUrl());
    HttpRequest request = HttpRequest.newBuilder().uri(URI.create(release.getDownloadUrl())).build();

    try
    {
        HttpResponse<Path> response = client.send(request, HttpResponse.BodyHandlers.ofFileDownload(directory,
            StandardOpenOption.CREATE, StandardOpenOption.WRITE));
        System.out.println("Download Complete: HTTP Status " + response.statusCode());
        return response.body();
    }
    catch(Exception e)
    {
        System.out.println("Download Failed: Error downloading source code from GitHub - " + e.getLocalizedMessage());
        e.printStackTrace();
    }

    return null;
}
 

private SimpleHttpClientCachedResponse callRemoteAndSaveResponse(HttpRequest request) throws IOException {
    HttpResponse<InputStream> response = null;
    try {
        response = httpClient.send(request, HttpResponse.BodyHandlers.ofInputStream());
    } catch (InterruptedException exception) {
        Thread.currentThread().interrupt();
        logInterruption(exception);
    }
    Path tempFile = null;
    if (HttpUtils.callSuccessful(response)) {
        InputStream body = response.body();
        if (body != null) {
            tempFile = Files.createTempFile("extension-out", ".tmp");
            try (FileOutputStream out = new FileOutputStream(tempFile.toFile())) {
                body.transferTo(out);
            }
        }
    }
    return new SimpleHttpClientCachedResponse(
        HttpUtils.callSuccessful(response),
        response.statusCode(),
        response.headers().map(),
        tempFile != null ? tempFile.toAbsolutePath().toString() : null);
}
 

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);
}
 

@Override
public byte[] postRequestForBinaryData(String url, String parameter,
                                HttpDataType reqDataType) throws IOException, InterruptedException {
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .timeout(Duration.ofSeconds(20))
            .header("Content-Type", toContentType(reqDataType))
            .POST(HttpRequest.BodyPublishers.ofString(parameter))
            .build();

    HttpResponse<byte[]> response = client.send(request, HttpResponse.BodyHandlers.ofByteArray());
    if(response.statusCode() != HTTP_SUCCESS) throw new IOException("Call returned bad status " + response.statusCode());
    return response.body();

}
 

@Override
public String postRequestForString(String url, String parameter,
                                       HttpDataType reqDataType) throws IOException, InterruptedException {
    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(url))
            .timeout(Duration.ofSeconds(20))
            .header("Content-Type", toContentType(reqDataType))
            .POST(HttpRequest.BodyPublishers.ofString(parameter))
            .build();

    HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
    if(response.statusCode() != HTTP_SUCCESS) throw new IOException("Call returned bad status " + response.statusCode());
    return response.body();
}
 

@Override
public ClientResponse executeRequest(String url) throws IOException, InterruptedException {
    HttpRequest request = HttpRequest.newBuilder()
            .GET()
            .header(HEADER_KEY_CLIENT_TYPE, getClientType().getValue())
            .uri(URI.create(url))
            .build();

    HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());

    return new ClientResponse(response.body(), response.statusCode());
}
 

public static void httpGetRequest() throws URISyntaxException, IOException, InterruptedException {
    HttpClient client = HttpClient.newHttpClient();
    HttpRequest request = HttpRequest.newBuilder()
        .version(HttpClient.Version.HTTP_2)
        .uri(URI.create("http://jsonplaceholder.typicode.com/posts/1"))
        .headers("Accept-Enconding", "gzip, deflate")
        .build();
    HttpResponse<String> response = client.send(request, BodyHandlers.ofString());

    String responseBody = response.body();
    int responseStatusCode = response.statusCode();

    System.out.println("httpGetRequest: " + responseBody);
    System.out.println("httpGetRequest status code: " + responseStatusCode);
}
 

public String getFile(String url) {
	HttpResponse<String> response = getFileResponse(url);
	if (response.statusCode() != 200) {
		LOG.info("response: {}", response.body());
		throw new RuntimeException("invalid status code: " + response.statusCode());
	}
	return response.body();
}
 

@Override
public Metadata metadata() {
    try {
        HttpRequest request = HttpRequest.newBuilder(withArtifactPath(apiUrl, id)).build();
        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString(UTF_8));
        if (response.statusCode() != 200)
            throw new RuntimeException("Status code '" + response.statusCode() + "' and body\n'''\n" +
                                       response.body() + "\n'''\nfor request " + request);

        return Metadata.fromXml(response.body());
    }
    catch (IOException | InterruptedException e) {
        throw new RuntimeException(e);
    }
}
 

private SimpleHttpClientResponse callRemote(HttpRequest request) throws IOException {
    HttpResponse<String> response = null;
    try {
        response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
    } catch (InterruptedException exception) {
        Thread.currentThread().interrupt();
        logInterruption(exception);
    }
    return new SimpleHttpClientResponse(
        HttpUtils.callSuccessful(response),
        response.statusCode(),
        response.headers().map(),
        response.body());
}
 

private static boolean recaptchaRequest(HttpClient client, String secret, String response) {
    if(response == null) {
        return false;
    }

    try {
        var params = Map.of("secret", secret, "response", response);
        HttpResponse<String> httpResponse = HttpUtils.postForm(client, "https://www.google.com/recaptcha/api/siteverify", params);
        String body = httpResponse.body();
        return body != null && Json.fromJson(body, RecatpchaResponse.class).success;
    } catch (IOException | InterruptedException e) {
        return false;
    }
}
 

/** Returns the response body as a String, or throws if the status code is non-2XX. */
private static String asString(HttpResponse<byte[]> response) {
    return new String(response.body(), UTF_8);
}
 

public static void main(String[] args)
        throws IOException, InterruptedException {

    HttpClient client = HttpClient.newHttpClient();

    HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://reqres.in/api/users/2"))
            .build();

    // HttpResponse.BodyHandlers.ofString()
    HttpResponse<String> responseOfString = client.send(
            request, HttpResponse.BodyHandlers.ofString());
    System.out.println("HttpResponse.BodyHandlers.ofString():");
    System.out.println("Status code: " + responseOfString.statusCode());
    System.out.println("Body: " + responseOfString.body());

    // HttpResponse.BodyHandlers.ofFile()
    HttpResponse<Path> responseOfFile = client.send(
            request, HttpResponse.BodyHandlers.ofFile(Path.of("response.json")));
    System.out.println("\nHttpResponse.BodyHandlers.ofFile():");
    System.out.println("Status code: " + responseOfFile.statusCode());
    System.out.println("Body: " + responseOfFile.body());

    // HttpResponse.BodyHandlers.ofByteArray()
    HttpResponse<byte[]> responseOfByteArray = client.send(
            request, HttpResponse.BodyHandlers.ofByteArray());
    System.out.println("\nHttpResponse.BodyHandlers.ofByteArray():");
    System.out.println("Status code: " + responseOfByteArray.statusCode());
    System.out.println("Body: " + new String(responseOfByteArray.body()));

    // HttpResponse.BodyHandlers.ofLines()
    HttpResponse<Stream<String>> responseOfLines = client.send(
            request, HttpResponse.BodyHandlers.ofLines());
    System.out.println("\nHttpResponse.BodyHandlers.ofLines():");
    System.out.println("Status code: " + responseOfLines.statusCode());
    System.out.println("Body: " + responseOfLines.body().collect(toList()));

    // HttpResponse.BodyHandlers.ofInputStream()
    HttpResponse<InputStream> responseOfInputStream = client.send(
            request, HttpResponse.BodyHandlers.ofInputStream());
    System.out.println("\nHttpResponse.BodyHandlers.ofInputStream():");
    System.out.println("Status code: " + responseOfInputStream.statusCode());

    byte[] allBytes;
    try ( InputStream fromIs = responseOfInputStream.body()) {
        allBytes = fromIs.readAllBytes();
    }

    System.out.println("Body: " + new String(allBytes, StandardCharsets.UTF_8));
}
 

private void downloadAndSaveTo(String url, Path dst) throws IOException {
	Path tempPath = dst.getParent().resolve(dst.getFileName() + ".tmp").normalize();
	if (Files.exists(tempPath) && !Util.deleteDirectory(tempPath)) {
		throw new RuntimeException("unable to delete tmp directory: " + tempPath);
	}
	Files.createDirectories(tempPath);
	Builder result = HttpRequest.newBuilder().uri(URI.create(url));
	result.timeout(Duration.ofMillis(TIMEOUT));
	result.header("User-Agent", R2Cloud.getVersion() + " [email protected]");
	HttpRequest request = result.build();
	try {
		HttpResponse<InputStream> response = httpclient.send(request, BodyHandlers.ofInputStream());
		if (response.statusCode() != 200) {
			throw new IOException("invalid status code: " + response.statusCode());
		}
		Optional<String> contentType = response.headers().firstValue("Content-Type");
		if (contentType.isEmpty() || !contentType.get().equals("application/zip")) {
			throw new IOException("Content-Type is empty or unsupported: " + contentType);
		}
		try (ZipInputStream zis = new ZipInputStream(response.body())) {
			ZipEntry zipEntry = null;
			while ((zipEntry = zis.getNextEntry()) != null) {
				Path destFile = tempPath.resolve(zipEntry.getName()).normalize();
				if (!destFile.startsWith(tempPath)) {
					throw new IOException("invalid archive. zip slip detected: " + destFile);
				}
				if (zipEntry.isDirectory()) {
					Files.createDirectories(destFile);
					continue;
				}
				if (!Files.exists(destFile.getParent())) {
					Files.createDirectories(destFile.getParent());
				}
				Files.copy(zis, destFile, StandardCopyOption.REPLACE_EXISTING);
			}

			Files.move(tempPath, dst, StandardCopyOption.REPLACE_EXISTING);
		}
	} catch (InterruptedException e) {
		Thread.currentThread().interrupt();
		throw new RuntimeException(e);
	}
}
 

public static void main(String[] args) throws IOException, InterruptedException {

        Jsonb jsonb = JsonbBuilder.create();
        HttpClient client = HttpClient.newHttpClient();

        System.out.println("-------------------------------------");
        System.out.println("-------------Get a user--------------");
        System.out.println("-------------------------------------");

        HttpRequest requestGet = HttpRequest.newBuilder()
                .uri(URI.create("https://reqres.in/api/users/2"))
                .build();

        HttpResponse<User> responseGet = client.send(requestGet,
                JsonBodyHandler.jsonBodyHandler(jsonb, User.class));

        System.out.println("Status code: " + responseGet.statusCode());

        User user = responseGet.body();
        System.out.println(user);

        System.out.println();
        System.out.println("-------------------------------------");
        System.out.println("-------------Update user-------------");
        System.out.println("-------------------------------------");

        user.getData().setEmail("[email protected]");

        HttpRequest requestPut = HttpRequest.newBuilder()
                .header("Content-Type", "application/json")
                .uri(URI.create("https://reqres.in/api/users"))
                .PUT(HttpRequest.BodyPublishers.ofString(jsonb.toJson(user)))
                .build();

        HttpResponse<User> responsePut = client.send(
                requestPut, JsonBodyHandler.jsonBodyHandler(jsonb, User.class));

        System.out.println("Status code: " + responsePut.statusCode());

        User updatedUser = responsePut.body();
        System.out.println(updatedUser);

        System.out.println();
        System.out.println("-------------------------------------");
        System.out.println("-------------Post new user------------");
        System.out.println("-------------------------------------");

        Data data = new Data();
        data.setId(10);
        data.setFirstName("John");
        data.setLastName("Year");
        data.setAvatar("https://johnyear.com/jy.png");

        User newUser = new User();
        newUser.setData(data);

        HttpRequest requestPost = HttpRequest.newBuilder()
                .header("Content-Type", "application/json")
                .uri(URI.create("https://reqres.in/api/users"))
                .POST(HttpRequest.BodyPublishers.ofString(jsonb.toJson(user)))
                .build();

        HttpResponse<Void> responsePost = client.send(
                requestPost, HttpResponse.BodyHandlers.discarding());

        System.out.println("Status code: " + responsePost.statusCode());
    }