HTT4J

Fork

(Almost) all the code is from the original project here.

All credits go to the original contributors.

Description

This is a simple, lightweight and tiny wrapper for Java's HttpURLConnection. It has no external dependencies and is written for Java 8.

It comes with a entity mapping system (serialization and deserialization for request and response bodies) with optional mappings for third party libraries (currently supporting: GSON).

Rationale

Most HTTP client for Java are either built for Java 11+, or have a large amount of dependencies, which means that in order to use them, one needs to built a fatjar that often end up being huge. This aims to offer a nicer way to interact with the Java 8 HTTP client, without having to double the size of the output artifacts.

Usage

Repository

repositories {
    mavenCentral()
    maven("https://repo.deltapvp.net/")
}

dependencies {
    compileOnly("net.deltapvp:http4j:1.5.2-SNAPSHOT")
}

<dependency>
    <groupId>net.deltapvp</groupId>
    <artifactId>http4j</artifactId>
    <version>1.5.2-SNAPSHOT</version>
</dependency>

Code

JavaDocs: https://reposilite.deltapvp.net/javadoc/snapshots/net/deltapvp/http4j/1.5.2-SNAPSHOT

All requests are done using an instance of com.intellectualsites.http.HttpClient:

HttpClient client = HttpClient.newBuilder()
    .withBaseURL("https://your.api.com")
    .withEntityMapper(EntityMapper.newInstance())
    .build();

The client also take in a com.intellectualsites.http.EntityMapper instance. This is used to map request & response bodies to Java objects. By default, it includes a mapper for Java strings.

EntityMapper entityMapper = EntityMapper.newInstance()
    .registerDeserializer(JsonObject.class, GsonMapper.deserializer(JsonObject.class, GSON));

The above snippet would create an entity mapper that maps to and from Java strings, and from HTTP response's to GSON json objects.

This can then be included in the HTTP client by using <builder>.withEntityMapper(mapper) to be used in all requests, or added to individual requests.

HTTP4J also supports request decorators, that can be used to modify each request. These are added by using:

builder.withDecorator(request -> {
    request.doSomething();
});

The built client can then be used to make HTTP requests, like such:

client.post("/some/api").withInput(() -> "Hello World")
    .onStatus(200, response -> {
        System.out.println("Everything is fine");
        System.out.println("Response: " + response.getResponseEntity(String.class));
    })
    .onStatus(404, response -> System.err.println("Could not find the resource =("))
    .onRemaining(response -> System.err.printf("Got status code: %d\n", response.getStatusCode()))
    .onException(Throwable::printStackTrace)
    .execute();

Exception Handling

HTTP4J will forward all RuntimeExceptions by default, and wrap all other exceptions (that do not extend RuntimeException) in a RuntimeException.

By using onException(exception -> {}) you are able to modify the behaviour.

Examples

More examples can be found in HttpClientTest.java

Projects using HTTP4J:

IntellectualSites/Arkitektonika-Client: Client for the Arkitektonika API broccolai/tickets: Discord bot