Mastering mica-http: Fluent HTTP Requests with OkHttp Wrapper

mica-http

mica-http

is a wrapper of

okhttp

, providing a fluent‑style HTTP utility whose syntax follows the HttpClient Fluent API.

Usage

Maven

<code>&lt;dependency&gt;
  &lt;groupId&gt;net.dreamlu&lt;/groupId&gt;
  &lt;artifactId&gt;mica-http&lt;/artifactId&gt;
  &lt;version&gt;${version}&lt;/version&gt;
&lt;/dependency&gt;
</code>

Gradle

<code>compile("net.dreamlu:mica-http:${version}")</code>

Documentation

Set the global log level (NONE, BASIC, HEADERS, BODY). Default is NONE.

<code>HttpRequest.setGlobalLog(LogLevel.BODY);</code>

Synchronously request a URL; supported methods: GET, POST, PATCH, PUT, DELETE.

<code>HttpRequest.get("https://www.baidu.com")
    .log(LogLevel.BASIC)               // request‑level log level
    .addHeader("x-account-id", "mica001") // add header
    .addCookie(new Cookie.Builder()
        .name("sid")
        .value("mica_user_001")
        .build())
    .query("q", "mica")                 // URL parameter, auto‑encoded
    .queryEncoded("name", "encodedValue")
    .formBuilder()
    .add("id", 123123)                  // form parameter
    .execute()
    .asJsonNode();                       // result conversion (throws on network error)
</code>

Example of synchronous POST with failure handling:

<code>String html = HttpRequest.post("https://www.baidu.com")
    .execute()
    .onFailed((request, e) -> {
        e.printStackTrace();
    })
    .onResponse(ResponseSpec::asString);
</code>

Example of synchronous PATCH with success handling:

<code>String text = HttpRequest.patch("https://www.baidu.com")
    .execute()
    .onSuccess(ResponseSpec::asString);
</code>

Asynchronous request example (DELETE):

<code>HttpRequest.delete("https://www.baidu.com")
    .async()
    .onFailed((request, e) -> {
        e.printStackTrace();
    })
    .onResponse(responseSpec -> {
        int httpCode = responseSpec.code();
    })
    .onSuccessful(responseSpec -> {
        JsonNode jsonNode = responseSpec.asJsonNode();
    })
    .execute();
</code>

Example Code 1

<code>// Set global log level
HttpRequest.setGlobalLog(LogLevel.BODY);

// Use Jackson JSON‑Path syntax
private String getUserEmail(String accessToken) {
    return HttpRequest.get("https://api.linkedin.com/v2/emailAddress?q=members&projection=(elements*(handle~))")
        .addHeader("Host", "api.linkedin.com")
        .addHeader("Connection", "Keep-Alive")
        .addHeader("Authorization", "Bearer " + accessToken)
        .execute()
        .asJsonNode()
        .at("/elements/0/handle~0/emailAddress")
        .asText();
}

// Asynchronous example
public static void test() {
    HttpRequest.post("https://www.baidu.com/do-stuff")
        .log(LogLevel.BASIC)
        .formBuilder()
        .add("a", "b")
        .async()
        .onSuccessful(System.out::println)
        .onFailed((request, e) -> {
            e.printStackTrace();
        })
        .execute();
}
</code>

Example Code 2

<code>HttpRequest.setGlobalLog(LogLevel.BODY);

// Synchronous request, returns null on exception
String html = HttpRequest.get("www.baidu.com")
    .connectTimeout(Duration.ofSeconds(1000))
    .query("test", "a")
    .query("name", "張三")
    .query("x", 1)
    .query("abd", Base64Util.encode("123&$#%"))
    .queryEncoded("abc", Base64Util.encode("123&$#%"))
    .execute()
    .onFailed((request, e) -> {
        e.printStackTrace();
    })
    .onSuccess(ResponseSpec::asString);
System.out.println(html);

// Synchronous call returning Optional, empty on exception
Optional<String> opt = HttpRequest.post(URI.create("https://www.baidu.com"))
    .bodyString("Important stuff")
    .formBuilder()
    .add("a", "b")
    .execute()
    .onSuccessOpt(ResponseSpec::asString);

// Synchronous request with response consumption
HttpRequest.post("https://www.baidu.com/some-form")
    .addHeader("X-Custom-header", "stuff")
    .execute()
    .onSuccessful(responseSpec -> {
        String text = responseSpec.asString();
        System.out.println(text);
    });

// Synchronous request that throws on error
HttpRequest.get("https://www.baidu.com/some-form")
    .execute()
    .asString();

// Asynchronous request with result handling
HttpRequest.get("https://www.baidu.com/some-form")
    .async()
    .onSuccessful(System.out::println)
    .onFailed((request, e) -> {
        e.printStackTrace();
    })
    .execute();
</code>