io.sphere.sdk.client

Interface BlockingSphereClient

All Superinterfaces:

AutoCloseable, SphereClient

public interface BlockingSphereClient
extends SphereClient

A client for Composable Commerce which provides thread blocking and non-blocking methods to execute a request. The implementations should be thread-safe so they can be used by multiple threads in parallel.

Creation requires a SphereClient and you specify the general timeout for all requests:

import io.sphere.sdk.client.BlockingSphereClient;

import io.sphere.sdk.client.SphereClient;

import java.util.concurrent.TimeUnit;

public class BlockingClientCreationDemo {
    public static BlockingSphereClient createBlockingClient(final SphereClient sphereClient) {
        return BlockingSphereClient.of(sphereClient, 500, TimeUnit.MILLISECONDS);
    }
}
See the test code.

Get a value blocking with executeBlocking(SphereRequest):

import io.sphere.sdk.client.BlockingSphereClient;

import io.sphere.sdk.client.SphereRequest;

import io.sphere.sdk.projects.Project;

import io.sphere.sdk.projects.queries.ProjectGet;

import static org.assertj.core.api.AssertionsForClassTypes.assertThat;

public class BlockingClientValueGetDemo {
    public static void demo(final BlockingSphereClient client, final String expectedProjectKey) {
        final SphereRequest<Project> sphereRequest = ProjectGet.of();
        final Project project = client.executeBlocking(sphereRequest);//returns result directly, no CompletionStage
        assertThat(project.getKey()).isEqualTo(expectedProjectKey);
    }
}
See the test code.

Get a value without blocking like in SphereClient.execute(SphereRequest):

import io.sphere.sdk.client.BlockingSphereClient;

import io.sphere.sdk.client.SphereClient;

import io.sphere.sdk.client.SphereRequest;

import io.sphere.sdk.projects.Project;

import io.sphere.sdk.projects.queries.ProjectGet;

import java.util.concurrent.CompletionStage;

import static org.assertj.core.api.Assertions.assertThat;

public class BlockingClientValueAsyncGetDemo {
    public static void demo(final BlockingSphereClient client, final String expectedProjectKey) {
        final SphereRequest<Project> sphereRequest = ProjectGet.of();
        final CompletionStage<Project> projectCompletionStage = client.execute(sphereRequest);
        assertThat(client)
                .as("blocking client can also used as regular sphere client")
                .isInstanceOf(SphereClient.class)
                .isInstanceOf(BlockingSphereClient.class);
    }
}
See the test code.

SphereTimeoutException occurs if the answer is not available in the configured timeout:

final BlockingSphereClient blockingSphereClient = createBlockingSphereClient();//reusable instance among threads

final Throwable throwable = catchThrowable(() -> blockingSphereClient.executeBlocking(DummySphereRequest.of()));

assertThat(throwable).isInstanceOf(SphereTimeoutException.class);
See the test code.

In case of errors sphere exceptions are directly thrown:

import io.sphere.sdk.carts.CartDraft;

import io.sphere.sdk.carts.commands.CartCreateCommand;

import io.sphere.sdk.models.SphereException;

import static org.assertj.core.api.Assertions.assertThat;

import static org.assertj.core.api.Assertions.catchThrowable;

public class BlockingClientSphereExceptionDemo {
    public static void demo(final BlockingSphereClient client) {
        final CartCreateCommand sphereRequest = CartCreateCommand.of(CartDraft.of(null));

        final Throwable throwable = catchThrowable(() -> client.executeBlocking(sphereRequest));

        assertThat(throwable)
                .isInstanceOf(ErrorResponseException.class)
                .isInstanceOf(SphereException.class);
    }
}
See the test code.

Method Summary

Modifier and Type	Method and Description
void	close() Shuts down the client to save resources like connections and threads.
<T> CompletionStage<T>	execute(SphereRequest<T> sphereRequest) Executes asynchronously a request to Composable Commerce.
<T> T	executeBlocking(SphereRequest<T> sphereRequest) Executes a request and blocks the caller thread until the response is available or a client specific timeout occurs.
<T> T	executeBlocking(SphereRequest<T> sphereRequest, Duration duration) Executes a request and blocks the caller thread until the response is available or a request specific timeout occurs.
<T> T	executeBlocking(SphereRequest<T> sphereRequest, long timeout, TimeUnit unit) Executes a request and blocks the caller thread until the response is available or a request specific timeout occurs.
static BlockingSphereClient	of(SphereClient delegate, Duration defaultTimeout) Creates a blocking client with a configured default timeout for blocking requests.
static BlockingSphereClient	of(SphereClient delegate, long defaultTimeout, TimeUnit unit) Creates a blocking client with a configured default timeout for blocking requests.

Methods inherited from interface io.sphere.sdk.client.SphereClient

getConfig, of, of

Method Detail

close

void close()

Description copied from interface: SphereClient

Shuts down the client to save resources like connections and threads.

Specified by:

close in interface AutoCloseable

Specified by:

close in interface SphereClient

execute

<T> CompletionStage<T> execute(SphereRequest<T> sphereRequest)

Description copied from interface: SphereClient

Executes asynchronously a request to Composable Commerce. By default it does not have a timeout.

Specified by:

execute in interface SphereClient

Type Parameters:

T - type of the result for the request

Parameters:

sphereRequest - request to Composable Commerce to perform

Returns:

future monad which can contain the result or an exception

executeBlocking

<T> T executeBlocking(SphereRequest<T> sphereRequest)

Executes a request and blocks the caller thread until the response is available or a client specific timeout occurs.

Type Parameters:

T - type of the result for the request

Parameters:

sphereRequest - request to Composable Commerce to perform

Returns:

result for the request to Composable Commerce

Throws:

SphereTimeoutException - if a timeout occurs

executeBlocking

<T> T executeBlocking(SphereRequest<T> sphereRequest,
                      long timeout,
                      TimeUnit unit)

Executes a request and blocks the caller thread until the response is available or a request specific timeout occurs.

Type Parameters:

T - type of the result for the request

Parameters:

sphereRequest - request to Composable Commerce to perform

timeout - the maximum time to wait for this single request

unit - the time unit of the timeout argument

Returns:

result for the request to Composable Commerce

Throws:

SphereTimeoutException - if a timeout occurs

executeBlocking

<T> T executeBlocking(SphereRequest<T> sphereRequest,
                      Duration duration)

Executes a request and blocks the caller thread until the response is available or a request specific timeout occurs.

Type Parameters:

T - type of the result for the request

Parameters:

sphereRequest - request to Composable Commerce to perform

duration - the maximum duration to wait for this single request

Returns:

result for the request to Composable Commerce

Throws:

SphereTimeoutException - if a timeout occurs

of

static BlockingSphereClient of(SphereClient delegate,
                               long defaultTimeout,
                               TimeUnit unit)

Creates a blocking client with a configured default timeout for blocking requests. The asynchronous calls won't have a timeout by default.

Parameters:

delegate - underlying sphere client which may be initialized with the SphereClientFactory.

defaultTimeout - the default maximum time to wait (to block the thread) which should be greater than the timeout of the underlying HTTP client

unit - the time unit of the defaultTimeout argument

Returns:

wrapped client which can perform blocking calls.

of

static BlockingSphereClient of(SphereClient delegate,
                               Duration defaultTimeout)

Creates a blocking client with a configured default timeout for blocking requests. The asynchronous calls won't have a timeout by default.

Parameters:

delegate - underlying sphere client which may be initialized with the SphereClientFactory.

defaultTimeout - the default maximum duration to wait (to block the thread) which should be greater than the timeout of the underlying HTTP client

Returns:

wrapped client which can perform blocking calls.