BlockingSphereClient (Composable Commerce JVM SDK 2.17.0-SNAPSHOT API)

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

All Methods Static Methods Instance Methods Abstract Methods Default Methods
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.

Interface BlockingSphereClient

Method Summary

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

Method Detail

close

execute

executeBlocking

executeBlocking

executeBlocking

of

of