Skip to content

vertx.md

Latest commit

 

History

History
127 lines (95 loc) · 2.45 KB

vertx.md

File metadata and controls

127 lines (95 loc) · 2.45 KB

Vert.x Client

The VertxArk client returns io.vertx.core.Future<T> - Vert.x native async without Mutiny or CompletableFuture.

Installation

<dependency>
    <groupId>xyz.juandiii</groupId>
    <artifactId>ark-vertx</artifactId>
</dependency>
<dependency>
    <groupId>xyz.juandiii</groupId>
    <artifactId>ark-transport-vertx</artifactId>
</dependency>

Transport

  • Interface: VertxHttpTransport - returns Future<RawResponse>
  • Implementation: ArkVertxFutureTransport - backed by Vert.x WebClient

Building the Client

Vertx vertx = Vertx.vertx();
WebClient webClient = WebClient.create(vertx, new WebClientOptions()
    .setSsl(true)
    .setConnectTimeout(5000)
    .setMaxPoolSize(50));

VertxArk client = VertxArkClient.builder()
    .serializer(new JacksonClassicSerializer(new ObjectMapper()))
    .transport(new ArkVertxFutureTransport(webClient))
    .baseUrl("https://api.example.com")
    .build();

Making Requests

GET

Future<User> user = client.get("/users/1")
    .accept(MediaType.APPLICATION_JSON)
    .retrieve()
    .body(User.class);

POST

Future<User> created = client.post("/users")
    .contentType(MediaType.APPLICATION_JSON)
    .body(new User("Juan", "juan@example.com"))
    .retrieve()
    .body(User.class);

DELETE

Future<ArkResponse<Void>> response = client.delete("/users/1")
    .retrieve()
    .toBodilessEntity();

Full Response

Future<ArkResponse<User>> response = client.get("/users/1")
    .retrieve()
    .toEntity(User.class);

response.onSuccess(r -> {
    int status = r.statusCode();
    User body = r.body();
});

Vert.x Composition

Use Vert.x Future API for chaining:

client.get("/users/1")
    .retrieve()
    .body(User.class)
    .compose(user -> saveToDb(user))
    .onSuccess(saved -> log.info("Saved: {}", saved))
    .onFailure(err -> log.error("Failed", err));

Error Handling

See Error Handling for the full exception hierarchy. Errors propagate through the Future:

client.get("/users/1")
    .retrieve()
    .body(User.class)
    .onFailure(err -> {
        if (err instanceof NotFoundException) {
            // 404
        } else if (err instanceof TimeoutException) {
            // request timed out
        }
    });

Related