add option to execute requests with the ApiHttpClient

finalize method parameters

Author: jenschude

commercetools/commercetools-sdk-java-api/src/main/java/com/commercetools/api/models/PagedQueryResourceRequest.java

@@ -1,10 +1,11 @@
 
 package com.commercetools.api.models;
 
+import io.vrap.rmf.base.client.ClientRequestCommand;
 import io.vrap.rmf.base.client.RequestCommand;
 
 public interface PagedQueryResourceRequest<T extends PagedQueryResourceRequest<T, TResult>, TResult>
-        extends RequestCommand<TResult> {
+        extends RequestCommand<TResult>, ClientRequestCommand<TResult> {
     T withLimit(final Integer limit);
 
     T withOffset(final Integer offset);

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/Accessor.java

@@ -4,7 +4,7 @@
 public abstract class Accessor<T> {
     protected final T value;
 
-    public Accessor(T value) {
+    public Accessor(final T value) {
         this.value = value;
     }
 }

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ApiHttpClient.java

@@ -9,7 +9,9 @@
 public interface ApiHttpClient extends AutoCloseable, VrapHttpClient {
     public String CLOSED_MESSAGE = "Client is already closed.";
 
-    public <O> CompletableFuture<ApiHttpResponse<O>> execute(ApiHttpRequest request, Class<O> outputType);
+    public <O> CompletableFuture<ApiHttpResponse<O>> execute(final ApiHttpRequest request, final Class<O> outputType);
+
+    public <O> CompletableFuture<ApiHttpResponse<O>> execute(final ClientRequestCommand<O> method);
 
     public ResponseSerializer getSerializerService();
 
@@ -21,11 +23,12 @@ public static ApiHttpClient of(final URI baseUri, final HandlerStack stack) {
         return of(baseUri, stack, ResponseSerializer.of());
     }
 
-    public static ApiHttpClient of(final String baseUri, final HandlerStack stack, ResponseSerializer serializer) {
+    public static ApiHttpClient of(final String baseUri, final HandlerStack stack,
+            final ResponseSerializer serializer) {
         return of(URI.create(baseUri), stack, serializer);
     }
 
-    public static ApiHttpClient of(final URI baseUri, final HandlerStack stack, ResponseSerializer serializer) {
+    public static ApiHttpClient of(final URI baseUri, final HandlerStack stack, final ResponseSerializer serializer) {
         return new ApiHttpClientImpl(baseUri, stack, serializer);
     }
 }

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ApiHttpClientImpl.java

@@ -20,7 +20,7 @@ public ApiHttpClientImpl(final URI baseUri, final HandlerStack stack) {
         this(baseUri, stack, ResponseSerializer.of());
     }
 
-    public ApiHttpClientImpl(final URI baseUri, final HandlerStack stack, ResponseSerializer serializer) {
+    public ApiHttpClientImpl(final URI baseUri, final HandlerStack stack, final ResponseSerializer serializer) {
         this.stack = stack;
         this.baseUri = baseUri;
         this.serializer = serializer;
@@ -33,7 +33,12 @@ public CompletableFuture<ApiHttpResponse<byte[]>> execute(final ApiHttpRequest r
     }
 
     @Override
-    public <O> CompletableFuture<ApiHttpResponse<O>> execute(final ApiHttpRequest request, Class<O> outputType) {
+    public <O> CompletableFuture<ApiHttpResponse<O>> execute(final ClientRequestCommand<O> method) {
+        return method.execute(this);
+    }
+
+    @Override
+    public <O> CompletableFuture<ApiHttpResponse<O>> execute(final ApiHttpRequest request, final Class<O> outputType) {
         return execute(request).thenApply(response -> serializer.convertResponse(response, outputType));
     }
 

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ApiHttpException.java

@@ -66,7 +66,7 @@ public ApiHttpException(final int statusCode, @Nullable final String body, @Null
         this.serializer = serializer;
     }
 
-    public <T> T getBodyAs(Class<T> clazz) throws SerializationException {
+    public <T> T getBodyAs(final Class<T> clazz) throws SerializationException {
         try {
             return serializer.convertResponse(response, clazz).getBody();
         }

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ApiMethod.java

@@ -15,7 +15,8 @@
 
 import javax.annotation.Nullable;
 
-public abstract class ApiMethod<T extends ApiMethod<T, TResult>, TResult> implements RequestCommand<TResult> {
+public abstract class ApiMethod<T extends ApiMethod<T, TResult>, TResult>
+        implements RequestCommand<TResult>, ClientRequestCommand<TResult> {
     public static class ParamEntry<K, V> implements Map.Entry<K, V> {
         protected final K key;
         protected V value;
@@ -209,13 +210,25 @@ public String getFirstQueryParam(final String key) {
 
     public abstract ApiHttpRequest createHttpRequest();
 
-    public abstract CompletableFuture<ApiHttpResponse<TResult>> execute();
+    public CompletableFuture<ApiHttpResponse<TResult>> execute() {
+        return execute(apiHttpClient());
+    }
+
+    public abstract CompletableFuture<ApiHttpResponse<TResult>> execute(ApiHttpClient client);
 
     public ApiHttpResponse<TResult> executeBlocking() {
-        return executeBlocking(Duration.ofSeconds(120));
+        return executeBlocking(apiHttpClient(), Duration.ofSeconds(120));
+    };
+
+    public ApiHttpResponse<TResult> executeBlocking(ApiHttpClient client) {
+        return executeBlocking(client, Duration.ofSeconds(120));
     };
 
-    public abstract ApiHttpResponse<TResult> executeBlocking(Duration timeout);
+    public ApiHttpResponse<TResult> executeBlocking(Duration timeout) {
+        return executeBlocking(apiHttpClient(), timeout);
+    }
+
+    public abstract ApiHttpResponse<TResult> executeBlocking(ApiHttpClient client, Duration timeout);
 
     public CompletableFuture<ApiHttpResponse<byte[]>> send() {
         return apiHttpClient.execute(createHttpRequest());

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/AuthenticationToken.java

@@ -34,23 +34,23 @@ public String getAccessToken() {
         return accessToken;
     }
 
-    public void setAccessToken(String accessToken) {
+    public void setAccessToken(final String accessToken) {
         this.accessToken = accessToken;
     }
 
     public String getTokenType() {
         return tokenType;
     }
 
-    public void setTokenType(String tokenType) {
+    public void setTokenType(final String tokenType) {
         this.tokenType = tokenType;
     }
 
     public Long getExpiresIn() {
         return expiresIn;
     }
 
-    public void setExpiresIn(Long expiresIn) {
+    public void setExpiresIn(final Long expiresIn) {
         this.expiresInZonedDateTime = Optional.ofNullable(expiresIn)
                 .map(seconds -> ZonedDateTime.now().plusSeconds(seconds).minusMinutes(5))
                 .orElse(null);
@@ -61,15 +61,15 @@ public String getScope() {
         return scope;
     }
 
-    public void setScope(String scope) {
+    public void setScope(final String scope) {
         this.scope = scope;
     }
 
     public String getRefresherToken() {
         return refresherToken;
     }
 
-    public void setRefresherToken(String refresherToken) {
+    public void setRefresherToken(final String refresherToken) {
         this.refresherToken = refresherToken;
     }
 

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/Base.java

@@ -9,7 +9,7 @@
 abstract class Base {
 
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(final Object o) {
         return EqualsBuilder.reflectionEquals(this, o);
     }
 

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ClientBuilder.java

@@ -33,15 +33,15 @@ public static ClientBuilder of() {
         return new ClientBuilder();
     }
 
-    public static ClientBuilder of(VrapHttpClient httpClient) {
+    public static ClientBuilder of(final VrapHttpClient httpClient) {
         return new ClientBuilder(httpClient);
     }
 
-    public static ClientBuilder of(HandlerStack stack) {
+    public static ClientBuilder of(final HandlerStack stack) {
         return new ClientBuilder(stack);
     }
 
-    private ClientBuilder(HandlerStack stack) {
+    private ClientBuilder(final HandlerStack stack) {
         this.stack = () -> stack;
         this.serializer = ResponseSerializer.of();
     }
@@ -64,40 +64,41 @@ private Supplier<HandlerStack> stackSupplier() {
         };
     }
 
-    private ClientBuilder(VrapHttpClient httpClient) {
+    private ClientBuilder(final VrapHttpClient httpClient) {
         this.httpClient = httpClient;
         this.stack = stackSupplier();
         this.serializer = ResponseSerializer.of();
     }
 
-    public ClientBuilder withHandlerStack(HandlerStack stack) {
+    public ClientBuilder withHandlerStack(final HandlerStack stack) {
         this.stack = () -> stack;
         return this;
     }
 
-    public ClientBuilder withHttpClient(VrapHttpClient httpClient) {
+    public ClientBuilder withHttpClient(final VrapHttpClient httpClient) {
         this.httpClient = httpClient;
         return this;
     }
 
-    public ClientBuilder withSerializer(ResponseSerializer serializer) {
+    public ClientBuilder withSerializer(final ResponseSerializer serializer) {
         this.serializer = serializer;
         return this;
     }
 
-    public ClientBuilder defaultClient(String apiBaseUrl) {
+    public ClientBuilder defaultClient(final String apiBaseUrl) {
         return withApiBaseUrl(apiBaseUrl).withErrorMiddleware()
                 .withSerializer(ResponseSerializer.of())
                 .withInternalLoggerFactory((request, topic) -> InternalLogger.getLogger(COMMERCETOOLS + "." + topic))
                 .withUserAgentSupplier(ClientBuilder::buildDefaultUserAgent)
                 .addAcceptGZipMiddleware();
     }
 
-    public ClientBuilder defaultClient(String apiBaseUrl, ClientCredentials credentials, String tokenEndpoint) {
+    public ClientBuilder defaultClient(final String apiBaseUrl, final ClientCredentials credentials,
+            final String tokenEndpoint) {
         return defaultClient(apiBaseUrl).withClientCredentials(credentials, tokenEndpoint);
     }
 
-    public ClientBuilder withClientCredentials(ClientCredentials credentials, String tokenEndpoint) {
+    public ClientBuilder withClientCredentials(final ClientCredentials credentials, final String tokenEndpoint) {
         this.oAuthMiddleware = () -> {
             final TokenSupplier tokenSupplier = createClientCredentialsTokenSupplier(credentials, tokenEndpoint,
                 requireNonNull(httpClient));
@@ -108,13 +109,13 @@ public ClientBuilder withClientCredentials(ClientCredentials credentials, String
         return this;
     }
 
-    public ClientBuilder withClientCredentials(ClientCredentials credentials, String tokenEndpoint,
+    public ClientBuilder withClientCredentials(final ClientCredentials credentials, final String tokenEndpoint,
             VrapHttpClient httpClient) {
         return withTokenSupplier(createClientCredentialsTokenSupplier(credentials, tokenEndpoint, httpClient));
     }
 
-    private TokenSupplier createClientCredentialsTokenSupplier(ClientCredentials credentials, String tokenEndpoint,
-            VrapHttpClient httpClient) {
+    private TokenSupplier createClientCredentialsTokenSupplier(final ClientCredentials credentials,
+            final String tokenEndpoint, final VrapHttpClient httpClient) {
         return new ClientCredentialsTokenSupplier(credentials.getClientId(), credentials.getClientSecret(),
             credentials.getScopes(), tokenEndpoint, httpClient);
     }
@@ -123,7 +124,7 @@ public ClientBuilder addAcceptGZipMiddleware() {
         return addMiddleware(AcceptGZipMiddleware.of());
     }
 
-    public ClientBuilder withErrorMiddleware(Supplier<ErrorMiddleware> errorMiddleware) {
+    public ClientBuilder withErrorMiddleware(final Supplier<ErrorMiddleware> errorMiddleware) {
         this.errorMiddleware = errorMiddleware;
         return this;
     }
@@ -132,78 +133,78 @@ public ClientBuilder withErrorMiddleware() {
         return withErrorMiddleware(() -> ErrorMiddleware.of(serializer));
     }
 
-    public ClientBuilder withErrorMiddleware(ErrorMiddleware errorMiddleware) {
+    public ClientBuilder withErrorMiddleware(final ErrorMiddleware errorMiddleware) {
         return withErrorMiddleware(() -> errorMiddleware);
     }
 
-    public ClientBuilder withOAuthMiddleware(Supplier<OAuthMiddleware> oAuthMiddleware) {
+    public ClientBuilder withOAuthMiddleware(final Supplier<OAuthMiddleware> oAuthMiddleware) {
         this.oAuthMiddleware = oAuthMiddleware;
         return this;
     }
 
-    public ClientBuilder withOAuthMiddleware(OAuthMiddleware oAuthMiddleware) {
+    public ClientBuilder withOAuthMiddleware(final OAuthMiddleware oAuthMiddleware) {
         return withOAuthMiddleware(() -> oAuthMiddleware);
     }
 
-    public ClientBuilder withTokenSupplier(TokenSupplier tokenSupplier) {
+    public ClientBuilder withTokenSupplier(final TokenSupplier tokenSupplier) {
         final OAuthHandler oAuthHandler = new OAuthHandler(tokenSupplier);
         return withOAuthMiddleware(OAuthMiddleware.of(oAuthHandler));
     }
 
-    public ClientBuilder withInternalLoggerMiddleware(InternalLoggerMiddleware internalLoggerMiddleware) {
+    public ClientBuilder withInternalLoggerMiddleware(final InternalLoggerMiddleware internalLoggerMiddleware) {
         this.internalLoggerMiddleware = internalLoggerMiddleware;
         return this;
     }
 
-    public ClientBuilder withInternalLoggerFactory(InternalLoggerFactory internalLoggerFactory) {
+    public ClientBuilder withInternalLoggerFactory(final InternalLoggerFactory internalLoggerFactory) {
         return withInternalLoggerMiddleware(InternalLoggerMiddleware.of(internalLoggerFactory));
     }
 
     public ClientBuilder withApiBaseUrl(String apiBaseUrl) {
         return withApiBaseUrl(URI.create(apiBaseUrl));
     }
 
-    public ClientBuilder withApiBaseUrl(URI apiBaseUrl) {
+    public ClientBuilder withApiBaseUrl(final URI apiBaseUrl) {
         this.apiBaseUrl = apiBaseUrl;
         return this;
     }
 
-    public ClientBuilder withUserAgentSupplier(Supplier<String> userAgentSupplier) {
+    public ClientBuilder withUserAgentSupplier(final Supplier<String> userAgentSupplier) {
         return withUserAgentMiddleware(new UserAgentMiddleware(userAgentSupplier.get()));
     }
 
-    private ClientBuilder withUserAgentMiddleware(UserAgentMiddleware userAgentMiddleware) {
+    private ClientBuilder withUserAgentMiddleware(final UserAgentMiddleware userAgentMiddleware) {
         this.userAgentMiddleware = userAgentMiddleware;
         return this;
     }
 
-    public ClientBuilder addCorrelationIdProvider(@Nullable CorrelationIdProvider correlationIdProvider) {
+    public ClientBuilder addCorrelationIdProvider(final @Nullable CorrelationIdProvider correlationIdProvider) {
         if (correlationIdProvider != null) {
             return addMiddleware((request, next) -> next.apply(
                 request.withHeader(ApiHttpHeaders.X_CORRELATION_ID, correlationIdProvider.getCorrelationId())));
         }
         return this;
     }
 
-    public ClientBuilder withMiddlewares(List<Middleware> middlewares) {
+    public ClientBuilder withMiddlewares(final List<Middleware> middlewares) {
         this.middlewares = new ArrayList<>(middlewares);
         return this;
     }
 
-    public ClientBuilder withMiddleware(Middleware middleware, Middleware... middlewares) {
+    public ClientBuilder withMiddleware(final Middleware middleware, final Middleware... middlewares) {
         this.middlewares = new ArrayList<>(Collections.singletonList(middleware));
         if (middlewares.length > 0) {
             this.middlewares.addAll(Arrays.asList(middlewares));
         }
         return this;
     }
 
-    public ClientBuilder addMiddlewares(List<Middleware> middlewares) {
+    public ClientBuilder addMiddlewares(final List<Middleware> middlewares) {
         this.middlewares.addAll(middlewares);
         return this;
     }
 
-    public ClientBuilder addMiddleware(Middleware middleware, Middleware... middlewares) {
+    public ClientBuilder addMiddleware(final Middleware middleware, final Middleware... middlewares) {
         this.middlewares.add(middleware);
         if (middlewares.length > 0) {
             this.middlewares.addAll(Arrays.asList(middlewares));

rmf/rmf-java-base/src/main/java/io/vrap/rmf/base/client/ClientRequestCommand.java

@@ -0,0 +1,13 @@
+
+package io.vrap.rmf.base.client;
+
+import java.time.Duration;
+import java.util.concurrent.CompletableFuture;
+
+public interface ClientRequestCommand<TResult> {
+    CompletableFuture<ApiHttpResponse<TResult>> execute(final ApiHttpClient client);
+
+    ApiHttpResponse<TResult> executeBlocking(final ApiHttpClient client);
+
+    ApiHttpResponse<TResult> executeBlocking(final ApiHttpClient client, final Duration timeout);
+}