HttpBuilder (http-builder-ng 1.0.4 API)

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

java.lang.Object
- groovyx.net.http.HttpBuilder

All Implemented Interfaces:

java.io.Closeable, java.lang.AutoCloseable

Direct Known Subclasses:

ApacheHttpBuilder, JavaHttpBuilder, OkHttpBuilder
```
public abstract class HttpBuilder
extends java.lang.Object
implements java.io.Closeable
```
This class is the main entry point into the "HttpBuilder-NG" API. It provides access to the HTTP Client configuration and the HTTP verbs to be executed.

The HttpBuilder is configured using one of the three static configure methods:
```
HttpBuilder configure(Function<HttpObjectConfig, ? extends HttpBuilder> factory)

HttpBuilder configure(@DelegatesTo(HttpObjectConfig) Closure closure)

HttpBuilder configure(Function<HttpObjectConfig, ? extends HttpBuilder> factory, @DelegatesTo(HttpObjectConfig) Closure closure)
```
Where the factory parameter is a Function used to instantiate the underlying builder with the appropriate HTTP Client implementation. Two implementations are provided by default, one based on the Apache HTTPClient, and the other based on the HttpURLConnection class. It is generally preferable to use the Apache implementation; however, the HttpURLConnection is instantiated by default to minimize required external dependencies. Both are fully supported.

The closure parameter is used to provide configuration for the client instance - the allowed configuration values are provided by the configuration interfaces (delegated to by the closure): HttpConfig and HttpObjectConfig.

Once you have the HttpBuilder configured, you can execute HTTP verb operations (e.g. GET, POST):
```
def http = HttpBuilder.configure {
    request.uri = 'http://localhost:10101/rest'
}

def content = http.get {
    request.uri.path = '/list'
}

def result = http.post {
    request.uri.path = '/save'
    request.body = infoRecord
    request.contentType = ContentTypes.JSON[0]
}
```
See the HTTP verb method docs (below) or the User Guide for more examples.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

protected static class HttpBuilder.ResponseHandlerFunction

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`HttpBuilder.ResponseHandlerFunction`

Constructor Summary

Constructors
Modifier Constructor and Description

protected HttpBuilder(HttpObjectConfig objectConfig)

Constructors
Modifier	Constructor and Description
`protected`	`HttpBuilder(HttpObjectConfig objectConfig)`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`protected void`	`addCookieStore(java.net.URI uri, java.util.List<FromServer.Header<?>> headers)`
`static HttpBuilder`	`configure(Closure closure)` Creates an `HttpBuilder` using the `JavaHttpBuilder` factory instance configured with the provided configuration closure.
`static HttpBuilder`	`configure(java.util.function.Consumer<HttpObjectConfig> configuration)` Creates an `HttpBuilder` using the `JavaHttpBuilder` factory instance configured with the provided configuration function.
`static HttpBuilder`	`configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory)` Creates an `HttpBuilder` with the default configuration using the provided factory function (`JavaHttpBuilder` or one of the other HTTP client implementation functions.
`static HttpBuilder`	`configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory, Closure closure)` Creates an `HttpBuilder` configured with the provided configuration closure, using the `defaultFactory` as the client factory.
`static HttpBuilder`	`configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory, java.util.function.Consumer<HttpObjectConfig> configuration)` Creates an `HttpBuilder` using the provided client factory function, configured with the provided configuration function.
`static java.util.List<java.net.HttpCookie>`	`cookies(java.util.List<FromServer.Header<?>> headers)`
`protected java.util.Map<java.lang.String,java.lang.String>`	`cookiesToAdd(HttpObjectConfig.Client clientConfig, ChainedHttpConfig.ChainedRequest cr)`
`java.lang.Object`	`delete()` Executes a DELETE request on the configured URI.
`<T> T`	`delete(java.lang.Class<T> type, Closure closure)` Executes an DELETE request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`delete(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a DELETE request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`delete(Closure closure)` Executes a DELETE request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`delete(java.util.function.Consumer<HttpConfig> configuration)` Executes a DELETE request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`deleteAsync()` Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the `delete()` method).
`<T> java.util.concurrent.CompletableFuture<T>`	`deleteAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the `delete(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`deleteAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the `delete(Class,Consumer)` method), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`deleteAsync(Closure closure)` Executes an asynchronous DELETE request on the configured URI (an asynchronous alias to the `delete(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`deleteAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the `delete(Consumer)` method), with additional configuration provided by the configuration function.
`protected abstract java.lang.Object`	`doDelete(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doGet(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doHead(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doOptions(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doPatch(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doPost(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doPut(ChainedHttpConfig config)`
`protected abstract java.lang.Object`	`doTrace(ChainedHttpConfig config)`
`static java.lang.Throwable`	`findCause(java.lang.Exception e)`
`java.lang.Object`	`get()` Executes a GET request on the configured URI.
`<T> T`	`get(java.lang.Class<T> type, Closure closure)` Executes a GET request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`get(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a GET request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`get(Closure closure)` Executes a GET request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`get(java.util.function.Consumer<HttpConfig> configuration)` Executes a GET request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`getAsync()` Executes an asynchronous GET request on the configured URI (asynchronous alias to the `get()` method.
`<T> java.util.concurrent.CompletableFuture<T>`	`getAsync(java.lang.Class<T> type, Closure closure)` Executes asynchronous GET request on the configured URI (alias for the `get(Class, Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`getAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes asynchronous GET request on the configured URI (alias for the `get(Class, Consumer)` method), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`getAsync(Closure closure)` Executes an asynchronous GET request on the configured URI (asynchronous alias to the `get(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`getAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous GET request on the configured URI (asynchronous alias to `get(Consumer)`), with additional configuration provided by the configuration function.
`abstract java.lang.Object`	`getClientImplementation()` Used to retrieve the instance of the internal client implementation.
`protected java.net.CookieManager`	`getCookieManager()`
`java.net.CookieStore`	`getCookieStore()` Returns the cookie store used by this builder
`abstract java.util.concurrent.Executor`	`getExecutor()`
`protected abstract ChainedHttpConfig`	`getObjectConfig()`
`protected java.lang.Object`	`handleException(ChainedHttpConfig.ChainedResponse cr, java.lang.Exception e)`
`java.lang.Object`	`head()` Executes a HEAD request on the configured URI.
`<T> T`	`head(java.lang.Class<T> type, Closure closure)` Executes a HEAD request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`head(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a HEAD request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`head(Closure closure)` Executes a HEAD request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`head(java.util.function.Consumer<HttpConfig> configuration)` Executes a HEAD request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`headAsync()` Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the `head()` method.
`<T> java.util.concurrent.CompletableFuture<T>`	`headAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the `head(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`headAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous HEAD request on the configured URI (asynchronous alias to `head(Class,Consumer)`), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`headAsync(Closure closure)` Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the `head(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`headAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous HEAD request on the configured URI (asynchronous alias to `head(Consumer)`), with additional configuration provided by the configuration function.
`java.lang.Object`	`options()` Executes a OPTIONS request on the configured URI.
`<T> T`	`options(java.lang.Class<T> type, Closure closure)` Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`options(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`options(Closure closure)` Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`options(java.util.function.Consumer<HttpConfig> configuration)` Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`optionsAsync()` Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the `options()` method.
`<T> java.util.concurrent.CompletableFuture<T>`	`optionsAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the `options(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`optionsAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to `options(Class,Consumer)`), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`optionsAsync(Closure closure)` Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the `options(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`optionsAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to `options(Consumer)`), with additional configuration provided by the configuration function.
`java.lang.Object`	`patch()` Executes a PATCH request on the configured URI.
`<T> T`	`patch(java.lang.Class<T> type, Closure closure)` Executes a PATCH request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`patch(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a PATCH request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`patch(Closure closure)` Executes a PATCH request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`patch(java.util.function.Consumer<HttpConfig> configuration)` Executes a PATCH request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`patchAsync()` Executes an asynchronous PATCH request on the configured URI (asynchronous alias to the `patch()` method.
`<T> java.util.concurrent.CompletableFuture<T>`	`patchAsync(java.lang.Class<T> type, Closure closure)` Executes asynchronous PATCH request on the configured URI (alias for the `patch(Class, Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`patchAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes asynchronous PATCH request on the configured URI (alias for the `patch(Class, Consumer)` method), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`patchAsync(Closure closure)` Executes an asynchronous PATCH request on the configured URI (asynchronous alias to the `patch(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`patchAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous PATCH request on the configured URI (asynchronous alias to `patch(Consumer)`), with additional configuration provided by the configuration function.
`java.lang.Object`	`post()` Executes a POST request on the configured URI.
`<T> T`	`post(java.lang.Class<T> type, Closure closure)` Executes an POST request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`post(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a POST request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`post(Closure closure)` Executes a POST request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`post(java.util.function.Consumer<HttpConfig> configuration)` Executes a POST request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`postAsync()` Executes an asynchronous POST request on the configured URI (asynchronous alias to the `post()` method).
`<T> java.util.concurrent.CompletableFuture<T>`	`postAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous POST request on the configured URI (asynchronous alias to the `post(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`postAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous POST request on the configured URI (asynchronous alias to `put(Class,Consumer)`), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`postAsync(Closure closure)` Executes an asynchronous POST request on the configured URI (an asynchronous alias to the `post(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`postAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous POST request on the configured URI (asynchronous alias to `post(Consumer)`), with additional configuration provided by the configuration function.
`java.lang.Object`	`put()` Executes a PUT request on the configured URI.
`<T> T`	`put(java.lang.Class<T> type, Closure closure)` Executes an PUT request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`put(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a PUT request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`put(Closure closure)` Executes a PUT request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`put(java.util.function.Consumer<HttpConfig> configuration)` Executes a PUT request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`putAsync()` Executes an asynchronous PUT request on the configured URI (asynchronous alias to the `put()` method).
`<T> java.util.concurrent.CompletableFuture<T>`	`putAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous PUT request on the configured URI (asynchronous alias to the `put(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`putAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous PUT request on the configured URI (asynchronous alias to `put(Class,Consumer)`), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`putAsync(Closure closure)` Executes an asynchronous PUT request on the configured URI (an asynchronous alias to the `put(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`putAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous PUT request on the configured URI (asynchronous alias to `put(Consumer)`), with additional configuration provided by the configuration function.
`java.lang.Object`	`trace()` Executes a TRACE request on the configured URI.
`<T> T`	`trace(java.lang.Class<T> type, Closure closure)` Executes a TRACE request on the configured URI, with additional configuration provided by the configuration closure.
`<T> T`	`trace(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes a TRACE request on the configured URI, with additional configuration provided by the configuration function.
`java.lang.Object`	`trace(Closure closure)` Executes a TRACE request on the configured URI, with additional configuration provided by the configuration closure.
`java.lang.Object`	`trace(java.util.function.Consumer<HttpConfig> configuration)` Executes a TRACE request on the configured URI, with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`traceAsync()` Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the `trace()` method.
`<T> java.util.concurrent.CompletableFuture<T>`	`traceAsync(java.lang.Class<T> type, Closure closure)` Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the `trace(Class,Closure)` method), with additional configuration provided by the configuration closure.
`<T> java.util.concurrent.CompletableFuture<T>`	`traceAsync(java.lang.Class<T> type, java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous TRACE request on the configured URI (asynchronous alias to `trace(Class,Consumer)`), with additional configuration provided by the configuration function.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`traceAsync(Closure closure)` Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the `trace(Closure)` method), with additional configuration provided by the configuration closure.
`java.util.concurrent.CompletableFuture<java.lang.Object>`	`traceAsync(java.util.function.Consumer<HttpConfig> configuration)` Executes an asynchronous TRACE request on the configured URI (asynchronous alias to `trace(Consumer)`), with additional configuration provided by the configuration function.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.io.Closeable
close

- Constructor Detail
  - HttpBuilder
```
protected HttpBuilder(HttpObjectConfig objectConfig)
```
- Method Detail
  - configure
```
public static HttpBuilder configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory)
```
    Creates an HttpBuilder with the default configuration using the provided factory function (JavaHttpBuilder or one of the other HTTP client implementation functions.
    def http = HttpBuilder.configure({ c -> new ApacheHttpBuilder(c); } as Function)
    When configuring the HttpBuilder with this method, the verb configurations are required to specify the request.uri property.
    Parameters:
    
    factory - the HttpObjectConfig factory function (JavaHttpBuilder or one of the other HTTP client implementation functions
    
    Returns:
    
    the configured HttpBuilder
  - configure
```
public static HttpBuilder configure(@DelegatesTo(value=HttpObjectConfig.class)
                                    Closure closure)
```
    Creates an HttpBuilder using the JavaHttpBuilder factory instance configured with the provided configuration closure.
    
    The configuration closure delegates to the HttpObjectConfig interface, which is an extension of the HttpConfig interface - configuration properties from either may be applied to the global client configuration here. See the documentation for those interfaces for configuration property details.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' }
    Parameters:
    
    closure - the configuration closure (delegated to HttpObjectConfig)
    
    Returns:
    
    the configured HttpBuilder
  - configure
```
public static HttpBuilder configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory,
                                    @DelegatesTo(value=HttpObjectConfig.class)
                                    Closure closure)
```
    Creates an HttpBuilder configured with the provided configuration closure, using the defaultFactory as the client factory.
    
    The configuration closure delegates to the HttpObjectConfig interface, which is an extension of the HttpConfig interface - configuration properties from either may be applied to the global client configuration here. See the documentation for those interfaces for configuration property details.
    def factory = { c -> new ApacheHttpBuilder(c); } as Function def http = HttpBuilder.configure(factory){ request.uri = 'http://localhost:10101' }
    Parameters:
    
    factory - the HttpObjectConfig factory function (JavaHttpBuilder or ApacheHttpBuilder)
    
    closure - the configuration closure (delegated to HttpObjectConfig)
    
    Returns:
    
    the configured HttpBuilder
  - configure
```
public static HttpBuilder configure(java.util.function.Consumer<HttpObjectConfig> configuration)
```
    Creates an HttpBuilder using the JavaHttpBuilder factory instance configured with the provided configuration function.
    
    The configuration Consumer function accepts an instance of the HttpObjectConfig interface, which is an extension of the HttpConfig interface - configuration properties from either may be applied to the global client configuration here. See the documentation for those interfaces for configuration property details.
    
    This configuration method is generally meant for use with standard Java.
    HttpBuilder.configure(new Consumer<HttpObjectConfig>() { public void accept(HttpObjectConfig config) { config.getRequest().setUri(format("http://localhost:%d", serverRule.getPort())); } });
    Or, using lambda expressions:
    HttpBuilder.configure(config -> { config.getRequest().setUri(format("http://localhost:%d", serverRule.getPort())); });
    Parameters:
    
    configuration - the configuration function (accepting HttpObjectConfig)
    
    Returns:
    
    the configured HttpBuilder
  - configure
```
public static HttpBuilder configure(java.util.function.Function<HttpObjectConfig,? extends HttpBuilder> factory,
                                    java.util.function.Consumer<HttpObjectConfig> configuration)
```
    Creates an HttpBuilder using the provided client factory function, configured with the provided configuration function.
    
    The configuration Consumer function accepts an instance of the HttpObjectConfig interface, which is an extension of the HttpConfig interface - configuration properties from either may be applied to the global client configuration here. See the documentation for those interfaces for configuration property details.
    
    This configuration method is generally meant for use with standard Java.
    HttpBuilder.configure(JavaHttpBuilder::new, new Consumer<HttpObjectConfig>() { public void accept(HttpObjectConfig config) { config.getRequest().setUri("http://localhost:10101"); } });
    Or, using lambda expressions:
    HttpBuilder.configure(JavaHttpBuilder::new, config -> { config.getRequest().setUri("http://localhost:10101"); });
    Parameters:
    
    factory - the HttpObjectConfig factory function (JavaHttpBuilder or groovyx.net.http.optional.ApacheHttpBuilder)
    
    configuration - the configuration function (accepting HttpObjectConfig)
    
    Returns:
    
    the configured HttpBuilder
  - getCookieManager
```
protected java.net.CookieManager getCookieManager()
```
  - getCookieStore
```
public java.net.CookieStore getCookieStore()
```
    Returns the cookie store used by this builder
    
    Returns:
    
    the cookie store used by this builder
  - cookiesToAdd
```
protected java.util.Map<java.lang.String,java.lang.String> cookiesToAdd(HttpObjectConfig.Client clientConfig,
                                                                        ChainedHttpConfig.ChainedRequest cr)
                                                                 throws java.net.URISyntaxException
```
    Throws:
    
    java.net.URISyntaxException
  - cookies
```
public static java.util.List<java.net.HttpCookie> cookies(java.util.List<FromServer.Header<?>> headers)
```
  - addCookieStore
```
protected void addCookieStore(java.net.URI uri,
                              java.util.List<FromServer.Header<?>> headers)
```
  - get
```
public java.lang.Object get()
```
    Executes a GET request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.get()
    Returns:
    
    the resulting content
  - get
```
public <T> T get(java.lang.Class<T> type,
                 @DelegatesTo(value=HttpConfig.class)
                 Closure closure)
```
    Executes a GET request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } String result = http.get(String){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - get
```
public <T> T get(java.lang.Class<T> type,
                 java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a GET request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.get(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - getAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> getAsync()
```
    Executes an asynchronous GET request on the configured URI (asynchronous alias to the get() method. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.getAsync() def result = future.get()
    Returns:
    
    a CompletableFuture for retrieving the resulting content
  - getAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> getAsync(@DelegatesTo(value=HttpConfig.class)
                                                                         Closure closure)
```
    Executes an asynchronous GET request on the configured URI (asynchronous alias to the get(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.getAsync(){ request.uri.path = '/something' } def result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - getAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> getAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous GET request on the configured URI (asynchronous alias to get(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.getAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - getAsync
```
public <T> java.util.concurrent.CompletableFuture<T> getAsync(java.lang.Class<T> type,
                                                              @DelegatesTo(value=HttpConfig.class)
                                                              Closure closure)
```
    Executes asynchronous GET request on the configured URI (alias for the get(Class, Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.getAsync(String){ request.uri.path = '/something' } String result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture for the resulting content cast to the specified type
  - getAsync
```
public <T> java.util.concurrent.CompletableFuture<T> getAsync(java.lang.Class<T> type,
                                                              java.util.function.Consumer<HttpConfig> configuration)
```
    Executes asynchronous GET request on the configured URI (alias for the get(Class, Consumer) method), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally meant for use with standard Java.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.get(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture for the resulting content cast to the specified type
  - head
```
public java.lang.Object head()
```
    Executes a HEAD request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.head()
    Returns:
    
    the resulting content - which should always be null for this method
  - head
```
public <T> T head(java.lang.Class<T> type,
                  @DelegatesTo(value=HttpConfig.class)
                  Closure closure)
```
    Executes a HEAD request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type. A response to a HEAD request contains no data; however, the response.when() methods may provide data based on response headers, which will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } Date result = http.head(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - head
```
public <T> T head(java.lang.Class<T> type,
                  java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a HEAD request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.head(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - headAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> headAsync()
```
    Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the head() method. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.headAsync()
    There is no response content, unless provided by request.when() method closure.
    Returns:
    
    a CompletableFuture for retrieving the resulting content
  - headAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> headAsync(@DelegatesTo(value=HttpConfig.class)
                                                                          Closure closure)
```
    Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the head(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.headAsync(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    
    The response will not contain content unless the response.when() method closure provides it based on the response headers.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - headAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> headAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous HEAD request on the configured URI (asynchronous alias to head(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.headAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - headAsync
```
public <T> java.util.concurrent.CompletableFuture<T> headAsync(java.lang.Class<T> type,
                                                               @DelegatesTo(value=HttpConfig.class)
                                                               Closure closure)
```
    Executes an asynchronous HEAD request on the configured URI (asynchronous alias to the head(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type. A response to a HEAD request contains no data; however, the response.when() methods may provide data based on response headers, which will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } CompletableFuture future = http.headAsync(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } } Date result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    a CompletableFuture which may be used to access the resulting content (if present)
  - headAsync
```
public <T> java.util.concurrent.CompletableFuture<T> headAsync(java.lang.Class<T> type,
                                                               java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous HEAD request on the configured URI (asynchronous alias to head(Class,Consumer)), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.headAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type wrapped in a CompletableFuture
  - post
```
public java.lang.Object post()
```
    Executes a POST request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.post()
    Returns:
    
    the resulting content
  - post
```
public <T> T post(java.lang.Class<T> type,
                  @DelegatesTo(value=HttpConfig.class)
                  Closure closure)
```
    Executes an POST request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } Date date = http.post(Date){ request.uri.path = '/date' request.body = '{ "timezone": "America/Chicago" }' request.contentType = 'application/json' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the result of the request cast to the specified type
  - post
```
public <T> T post(java.lang.Class<T> type,
                  java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a POST request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.post(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - postAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> postAsync()
```
    Executes an asynchronous POST request on the configured URI (asynchronous alias to the post() method). The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.postAsync() def result = future.get()
    Returns:
    
    the CompletableFuture containing the future access to the response
  - postAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> postAsync(@DelegatesTo(value=HttpConfig.class)
                                                                          Closure closure)
```
    Executes an asynchronous POST request on the configured URI (an asynchronous alias to the post(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.postAsync(){ request.uri.path = '/something' request.body = 'My content' request.contentType = 'text/plain' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the future result data
  - postAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> postAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous POST request on the configured URI (asynchronous alias to post(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.postAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - postAsync
```
public <T> java.util.concurrent.CompletableFuture<T> postAsync(java.lang.Class<T> type,
                                                               @DelegatesTo(value=HttpConfig.class)
                                                               Closure closure)
```
    Executes an asynchronous POST request on the configured URI (asynchronous alias to the post(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletedFuture<Date> future = http.postAsync(Date){ request.uri.path = '/date' request.body = '{ "timezone": "America/Chicago" }' request.contentType = 'application/json' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } } Date date = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the result of the request
  - postAsync
```
public <T> java.util.concurrent.CompletableFuture<T> postAsync(java.lang.Class<T> type,
                                                               java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous POST request on the configured URI (asynchronous alias to put(Class,Consumer)), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<String> future = http.postAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); }); String result = future.get();
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type, wrapped in a CompletableFuture
  - put
```
public java.lang.Object put()
```
    Executes a PUT request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.put()
    Returns:
    
    the resulting content
  - put
```
public <T> T put(java.lang.Class<T> type,
                 @DelegatesTo(value=HttpConfig.class)
                 Closure closure)
```
    Executes an PUT request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } Date date = http.put(Date){ request.uri.path = '/date' request.body = '{ "timezone": "America/Chicago" }' request.contentType = 'application/json' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the result of the request cast to the specified type
  - put
```
public <T> T put(java.lang.Class<T> type,
                 java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a PUT request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.get(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - putAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> putAsync()
```
    Executes an asynchronous PUT request on the configured URI (asynchronous alias to the put() method). The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.putAsync() def result = future.get()
    Returns:
    
    the CompletableFuture containing the future access to the response
  - putAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> putAsync(@DelegatesTo(value=HttpConfig.class)
                                                                         Closure closure)
```
    Executes an asynchronous PUT request on the configured URI (an asynchronous alias to the put(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.putAsync(){ request.uri.path = '/something' request.body = 'My content' request.contentType = 'text/plain' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the future result data
  - putAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> putAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous PUT request on the configured URI (asynchronous alias to put(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.putAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - putAsync
```
public <T> java.util.concurrent.CompletableFuture<T> putAsync(java.lang.Class<T> type,
                                                              @DelegatesTo(value=HttpConfig.class)
                                                              Closure closure)
```
    Executes an asynchronous PUT request on the configured URI (asynchronous alias to the put(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletedFuture<Date> future = http.putAsync(Date){ request.uri.path = '/date' request.body = '{ "timezone": "America/Chicago" }' request.contentType = 'application/json' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } } Date date = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the result of the request
  - putAsync
```
public <T> java.util.concurrent.CompletableFuture<T> putAsync(java.lang.Class<T> type,
                                                              java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous PUT request on the configured URI (asynchronous alias to put(Class,Consumer)), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<String> future = http.putAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); }); String result = future.get();
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type, wrapped in a CompletableFuture
  - delete
```
public java.lang.Object delete()
```
    Executes a DELETE request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.delete()
    Returns:
    
    the resulting content
  - delete
```
public <T> T delete(java.lang.Class<T> type,
                    @DelegatesTo(value=HttpConfig.class)
                    Closure closure)
```
    Executes an DELETE request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } Date date = http.delete(Date){ request.uri.path = '/date' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the result of the request cast to the specified type
  - delete
```
public <T> T delete(java.lang.Class<T> type,
                    java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a DELETE request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.delete(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - deleteAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> deleteAsync()
```
    Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the delete() method). The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.deleteAsync() def result = future.get()
    Returns:
    
    the CompletableFuture containing the future access to the response
  - deleteAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> deleteAsync(@DelegatesTo(value=HttpConfig.class)
                                                                            Closure closure)
```
    Executes an asynchronous DELETE request on the configured URI (an asynchronous alias to the delete(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.deleteAsync(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the future result data
  - deleteAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> deleteAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the delete(Consumer) method), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.deleteAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the result of the request
  - deleteAsync
```
public <T> java.util.concurrent.CompletableFuture<T> deleteAsync(java.lang.Class<T> type,
                                                                 @DelegatesTo(value=HttpConfig.class)
                                                                 Closure closure)
```
    Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the delete(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletedFuture<Date> future = http.deleteAsync(Date){ request.uri.path = '/date' response.parser('text/date') { ChainedHttpConfig config, FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.inputStream.text) } } Date date = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the resulting object
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the result of the request
  - deleteAsync
```
public <T> java.util.concurrent.CompletableFuture<T> deleteAsync(java.lang.Class<T> type,
                                                                 java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous DELETE request on the configured URI (asynchronous alias to the delete(Class,Consumer) method), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<String> future = http.deleteAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); }); String result = future.get();
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the resulting object
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture containing the result of the request
  - get
```
public java.lang.Object get(@DelegatesTo(value=HttpConfig.class)
                            Closure closure)
```
    Executes a GET request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.get(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - get
```
public java.lang.Object get(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a GET request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.delete(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - head
```
public java.lang.Object head(@DelegatesTo(value=HttpConfig.class)
                             Closure closure)
```
    Executes a HEAD request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.head(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content - which will be null unless provided by a request.when() closure
  - head
```
public java.lang.Object head(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a HEAD request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.delete(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - post
```
public java.lang.Object post(@DelegatesTo(value=HttpConfig.class)
                             Closure closure)
```
    Executes a POST request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.post(){ request.uri.path = '/something' request.body = 'My content' request.contentType = 'text/plain' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - post
```
public java.lang.Object post(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a POST request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.post(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - put
```
public java.lang.Object put(@DelegatesTo(value=HttpConfig.class)
                            Closure closure)
```
    Executes a PUT request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.put(){ request.uri.path = '/something' request.body = 'My content' request.contentType = 'text/plain' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - put
```
public java.lang.Object put(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a PUT request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.put(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - delete
```
public java.lang.Object delete(@DelegatesTo(value=HttpConfig.class)
                               Closure closure)
```
    Executes a DELETE request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.delete(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - delete
```
public java.lang.Object delete(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a DELETE request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.delete(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - patch
```
public java.lang.Object patch()
```
    Executes a PATCH request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.patch()
    Returns:
    
    the resulting content
  - patch
```
public java.lang.Object patch(@DelegatesTo(value=HttpConfig.class)
                              Closure closure)
```
    Executes a PATCH request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } def result = http.patch(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - patch
```
public java.lang.Object patch(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a PATCH request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.patch(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - patch
```
public <T> T patch(java.lang.Class<T> type,
                   @DelegatesTo(value=HttpConfig.class)
                   Closure closure)
```
    Executes a PATCH request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } String result = http.patch(String){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - patch
```
public <T> T patch(java.lang.Class<T> type,
                   java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a PATCH request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.patch(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - patchAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> patchAsync()
```
    Executes an asynchronous PATCH request on the configured URI (asynchronous alias to the patch() method. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.patchAsync() def result = future.get()
    Returns:
    
    a CompletableFuture for retrieving the resulting content
  - patchAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> patchAsync(@DelegatesTo(value=HttpConfig.class)
                                                                           Closure closure)
```
    Executes an asynchronous PATCH request on the configured URI (asynchronous alias to the patch(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.patchAsync(){ request.uri.path = '/something' } def result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - patchAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> patchAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous PATCH request on the configured URI (asynchronous alias to patch(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.patchAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - patchAsync
```
public <T> java.util.concurrent.CompletableFuture<T> patchAsync(java.lang.Class<T> type,
                                                                @DelegatesTo(value=HttpConfig.class)
                                                                Closure closure)
```
    Executes asynchronous PATCH request on the configured URI (alias for the patch(Class, Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } CompletableFuture future = http.patchAsync(String){ request.uri.path = '/something' } String result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture for the resulting content cast to the specified type
  - patchAsync
```
public <T> java.util.concurrent.CompletableFuture<T> patchAsync(java.lang.Class<T> type,
                                                                java.util.function.Consumer<HttpConfig> configuration)
```
    Executes asynchronous PATCH request on the configured URI (alias for the patch(Class, Consumer) method), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally meant for use with standard Java.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.patch(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the CompletableFuture for the resulting content cast to the specified type
  - options
```
public java.lang.Object options(@DelegatesTo(value=HttpConfig.class)
                                Closure closure)
```
    Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.options(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content - which will be null unless provided by a request.when() closure
  - options
```
public java.lang.Object options(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.options(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - options
```
public java.lang.Object options()
```
    Executes a OPTIONS request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.options()
    Returns:
    
    the resulting content - which should always be null for this method
  - options
```
public <T> T options(java.lang.Class<T> type,
                     @DelegatesTo(value=HttpConfig.class)
                     Closure closure)
```
    Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type. A response to an OPTIONS request contains no data; however, the response.when() methods may provide data based on response headers, which will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } Date result = http.options(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - options
```
public <T> T options(java.lang.Class<T> type,
                     java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a OPTIONS request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.options(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - optionsAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> optionsAsync()
```
    Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the options() method. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.optionsAsync()
    There is no response content, unless provided by request.when() method closure.
    Returns:
    
    a CompletableFuture for retrieving the resulting content
  - optionsAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> optionsAsync(@DelegatesTo(value=HttpConfig.class)
                                                                             Closure closure)
```
    Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the options(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.optionsAsync(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    
    The response will not contain content unless the response.when() method closure provides it based on the response headers.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - optionsAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> optionsAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to options(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.optionsAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - optionsAsync
```
public <T> java.util.concurrent.CompletableFuture<T> optionsAsync(java.lang.Class<T> type,
                                                                  @DelegatesTo(value=HttpConfig.class)
                                                                  Closure closure)
```
    Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to the options(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type. A response to a OPTIONS request contains no data; however, the response.when() methods may provide data based on response headers, which will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } CompletableFuture future = http.optionsAsync(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } } Date result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    a CompletableFuture which may be used to access the resulting content (if present)
  - optionsAsync
```
public <T> java.util.concurrent.CompletableFuture<T> optionsAsync(java.lang.Class<T> type,
                                                                  java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous OPTIONS request on the configured URI (asynchronous alias to options(Class,Consumer)), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.optionsAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type wrapped in a CompletableFuture
  - trace
```
public java.lang.Object trace(@DelegatesTo(value=HttpConfig.class)
                              Closure closure)
```
    Executes a TRACE request on the configured URI, with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.trace(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - trace
```
public java.lang.Object trace(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a TRACE request on the configured URI, with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); http.trace(config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - trace
```
public java.lang.Object trace()
```
    Executes a TRACE request on the configured URI. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.trace()
    Returns:
    
    the resulting content
  - trace
```
public <T> T trace(java.lang.Class<T> type,
                   @DelegatesTo(value=HttpConfig.class)
                   Closure closure)
```
    Executes a TRACE request on the configured URI, with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } Date result = http.trace(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - trace
```
public <T> T trace(java.lang.Class<T> type,
                   java.util.function.Consumer<HttpConfig> configuration)
```
    Executes a TRACE request on the configured URI, with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.options(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type
  - traceAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> traceAsync()
```
    Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the trace() method. The request.uri property should be configured in the global client configuration in order to have a target for the request.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.traceAsync()
    Returns:
    
    a CompletableFuture for retrieving the resulting content
  - traceAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> traceAsync(@DelegatesTo(value=HttpConfig.class)
                                                                           Closure closure)
```
    Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the trace(Closure) method), with additional configuration provided by the configuration closure.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101' } http.traceAsync(){ request.uri.path = '/something' }
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content
  - traceAsync
```
public java.util.concurrent.CompletableFuture<java.lang.Object> traceAsync(java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous TRACE request on the configured URI (asynchronous alias to trace(Consumer)), with additional configuration provided by the configuration function.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); CompletableFuture<Object> future = http.traceAsync(config -> { config.getRequest().getUri().setPath("/foo"); }); Object result = future.get();
    The configuration function allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    configuration - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    the resulting content wrapped in a CompletableFuture
  - traceAsync
```
public <T> java.util.concurrent.CompletableFuture<T> traceAsync(java.lang.Class<T> type,
                                                                @DelegatesTo(value=HttpConfig.class)
                                                                Closure closure)
```
    Executes an asynchronous TRACE request on the configured URI (asynchronous alias to the trace(Class,Closure) method), with additional configuration provided by the configuration closure. The result will be cast to the specified type.
    def http = HttpBuilder.configure { request.uri = 'http://localhost:10101/date' } CompletableFuture future = http.traceAsync(Date){ response.success { FromServer fromServer -> Date.parse('yyyy.MM.dd HH:mm', fromServer.headers.find { it.key == 'stamp' }.value) } } Date result = future.get()
    The configuration closure allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    closure - the additional configuration closure (delegated to HttpConfig)
    
    Returns:
    
    a CompletableFuture which may be used to access the resulting content (if present)
  - traceAsync
```
public <T> java.util.concurrent.CompletableFuture<T> traceAsync(java.lang.Class<T> type,
                                                                java.util.function.Consumer<HttpConfig> configuration)
```
    Executes an asynchronous TRACE request on the configured URI (asynchronous alias to trace(Class,Consumer)), with additional configuration provided by the configuration function. The result will be cast to the specified type.
    
    This method is generally used for Java-specific configuration.
    HttpBuilder http = HttpBuilder.configure(config -> { config.getRequest().setUri("http://localhost:10101"); }); String result = http.traceAsync(String.class, config -> { config.getRequest().getUri().setPath("/foo"); });
    The configuration Consumer allows additional configuration for this request based on the HttpConfig interface.
    Parameters:
    
    type - the type of the response content
    
    configuration - the additional configuration function (delegated to HttpConfig)
    
    Returns:
    
    the resulting content cast to the specified type wrapped in a CompletableFuture
  - getClientImplementation
```
public abstract java.lang.Object getClientImplementation()
```
    Used to retrieve the instance of the internal client implementation. All client configuration will have been performed by the time this method is accessible. If additional configuration is desired and not supported by HttpBuilder-NG directly, you should use the HttpObjectConfig::Client::clientCustomizer(Consumer<Object>) method.
    
    This functionality is optional and client-implementation-dependent. If access to the internal client is not supported, an UnsupportedOperationException will be thrown.
    
    Returns:
    
    a reference to the internal client implementation used (or null if not supported)
  - doGet
```
protected abstract java.lang.Object doGet(ChainedHttpConfig config)
```
  - doHead
```
protected abstract java.lang.Object doHead(ChainedHttpConfig config)
```
  - doPost
```
protected abstract java.lang.Object doPost(ChainedHttpConfig config)
```
  - doPut
```
protected abstract java.lang.Object doPut(ChainedHttpConfig config)
```
  - doDelete
```
protected abstract java.lang.Object doDelete(ChainedHttpConfig config)
```
  - doPatch
```
protected abstract java.lang.Object doPatch(ChainedHttpConfig config)
```
  - doOptions
```
protected abstract java.lang.Object doOptions(ChainedHttpConfig config)
```
  - doTrace
```
protected abstract java.lang.Object doTrace(ChainedHttpConfig config)
```
  - getObjectConfig
```
protected abstract ChainedHttpConfig getObjectConfig()
```
  - getExecutor
```
public abstract java.util.concurrent.Executor getExecutor()
```
  - findCause
```
public static java.lang.Throwable findCause(java.lang.Exception e)
```
  - handleException
```
protected java.lang.Object handleException(ChainedHttpConfig.ChainedResponse cr,
                                           java.lang.Exception e)
```

Skip navigation links

All Classes

Summary:
Nested |
Field |
Constr |
Method

Detail:
Field |
Constr |
Method

Class HttpBuilder

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.io.Closeable

Constructor Detail

HttpBuilder

Method Detail

configure

configure

configure

configure

configure

getCookieManager

getCookieStore

cookiesToAdd

cookies

addCookieStore

get

get

get

getAsync

getAsync

getAsync

getAsync

getAsync

head

head

head

headAsync

headAsync

headAsync

headAsync

headAsync

post

post

post

postAsync

postAsync

postAsync

postAsync

postAsync

put

put

put

putAsync

putAsync

putAsync

putAsync

putAsync

delete

delete

delete

deleteAsync

deleteAsync

deleteAsync

deleteAsync

deleteAsync

get

get

head

head

post

post

put

put

delete

delete

patch

patch

patch

patch

patch

patchAsync

patchAsync

patchAsync

patchAsync

patchAsync

options