Skip to main content

Flowable HTTP Client

Flowable uses an instance of FlowableHttpClient in the platform to perform HTTP requests. This Flowable HTTP Client is used in the HTTP Task and the Service Registry REST models.

Flowable has 3 types of implementations:

Based on what is available on the classpath that would take precedence. e.g. Spring WebClient has precedence over Apache HTTP 5, which has a precedence over Apache HTTP 4.

The http client can be configured using the properties with prefix flowable.http. The properties are defined here.

Depending on which client is being used there are other customizations options.

Configuring TLS with SSL bundles​

2026.1.0+

The Flowable HTTP Client can be configured to use a Spring Boot SSL bundle for its TLS configuration. This is useful when the endpoints called by the HTTP Task or the Service Registry REST tasks present a certificate that is not trusted by the default JVM truststore (for example a self-signed or internal CA certificate), or when the endpoint requires mutual TLS (client authentication).

First, define an SSL bundle using the standard Spring Boot spring.ssl.bundle properties. A bundle can be backed by PEM files or by a Java keystore. For example, to trust an internal CA certificate:

spring.ssl.bundle.pem.my-endpoint.truststore.certificate=classpath:certificates/rootCA.cert.pem

For mutual TLS, also configure the keystore with the client certificate and private key:

spring.ssl.bundle.pem.my-endpoint.truststore.certificate=classpath:certificates/rootCA.cert.pem
spring.ssl.bundle.pem.my-endpoint.keystore.certificate=classpath:certificates/client.cert.pem
spring.ssl.bundle.pem.my-endpoint.keystore.private-key=classpath:certificates/client.key.pem

Then reference the bundle by name from the Flowable HTTP Client:

flowable.http.ssl.bundle=my-endpoint

The SSL bundle is applied regardless of which client implementation is used (Spring WebClient, Apache HTTP 5 or Apache HTTP 4). When a truststore is configured on the bundle, it replaces the default JVM truststore for the HTTP client, it does not add to it. The client then trusts only the certificates in the bundle's truststore, and public CA certificates from the default JVM truststore are no longer trusted.

Because flowable.http.ssl.bundle configures the shared HTTP Client used by both the HTTP Task and all Service Registry REST tasks, calls to endpoints that rely on public CA certificates will start failing unless those certificates are also included in the bundle's truststore. To trust an internal CA while keeping public endpoints working, add both the internal CA and the required public CA certificates to the bundle's truststore. A single PEM file can contain multiple certificates concatenated one after another, so the internal and public CA certificates can all live in one truststore file.

If you only configure a keystore (for mutual TLS) and leave the truststore unset, the default JVM truststore remains in effect. For multiple TLS certificates (for example an internal CA for one service and the default trust for the rest), either create an SSL bundle with both the default root CA certs and the custom certificates or configure a custom FlowableHttpClient per Service Registry service definition instead. See Extension: Custom FlowableHttpClient.

note

The SSL bundle is only used when certificate verification is enabled. When flowable.http.disable-cert-verify is set to true, the configured bundle is ignored because all certificates are trusted.

Customizing Spring WebClient​

The available configuration properties for the Spring WebClient are defined here.

v3.14.0+

A bean of type FlowableHttpClientWebClientCustomizer can be used to provide more complex customization of the WebClient.Builder

e.g.

@Configuration(proxyBeanMethods = false)
public class CustomConfiguration {

    @Bean
    public FlowableHttpClientWebClientCustomizer httpClientCustomizer() {
        return webClientBuilder -> {
            // Customization
        };
    }
    
}

Customizing Reactor Netty HttpClient​

2025.1.04+ 2025.2.01+

When the Spring WebClient backed implementation is used, a bean of type FlowableHttpReactorClientCustomizer can be used to customize the underlying Reactor Netty HttpClient created by default by Flowable.

e.g.

@Configuration(proxyBeanMethods = false)
public class CustomConfiguration {

    @Bean
    public FlowableHttpReactorClientCustomizer httpClientCustomizer() {
        return httpClient -> {
            // Customization
        };
    }

}

Customizing Apache HTTP Client 5​

The available configuration properties for the Apache HTTP Client 5 are defined here.

v3.14.0+

A bean of type FlowableHttpClientApacheHttpClient5Customizer can be used to provide more complex customization of the HttpAsyncClientBuilder

e.g.

@Configuration(proxyBeanMethods = false)
public class CustomConfiguration {

    @Bean
    public FlowableHttpClientApacheHttpClient5Customizer httpClientCustomizer() {
        return clientBuilder -> {
            // Customization
        };
    }
    
}
note

If you want to customize the HTTP proxy you can set flowable.http.use-system-properties to true and then configure the default Java HTTP proxy properties

Customizing Apache HTTP Client 4​

v3.14.5+

A bean of type FlowableHttpClientApacheHttpClient4Customizer can be used to provide more complex customization of the HttpClientBuilder

e.g.

@Configuration(proxyBeanMethods = false)
public class CustomConfiguration {

    @Bean
    public FlowableHttpClientApacheHttpClient4Customizer httpClientCustomizer() {
        return clientBuilder -> {
            // Customization
        };
    }
    
}
note

If you want to customize the HTTP proxy you can set flowable.http.use-system-properties to true and then configure the default Java HTTP proxy properties

Multiple FlowableHttpClient(s)

In case multiple FlowableHttpClient(s) are needed, e.g. a custom one for a specific Service Registry Service Definition Model, then the FlowableHttpClientBuilder can be used to provide an instance of the default implementation (see here for an example).

e.g.

@Configuration(proxyBeanMethods = false)
public class CustomConfiguration {

    @Bean
    public FlowableHttpClient customFlowableHttpClient(FlowableHttpClientBuilder<HttpAsyncClientBuilder> flowableHttpBuilder) {
        // Replace HttpAsyncClientBuilder with the appropriate builder
        return flowableHttpBuilder
                .addCustomizer(builder -> {
                    // Provide customizations
                })
                .build();
    }

    @Bean
    @Primary
    public FlowableHttpClient defaultFlowableHttpClient(FlowableHttpClientBuilder<?> builder) {
        return builder.build();
    }
    
}
note

The use of the HttpAsyncClientBuilder is an example. Depending on which client type is the generic should be the appropriate type. e.g. WebClient.Builder when using the Spring WebClient, HttpAsyncClientBuilder when using the Apache HTTP Client 5 and HttpClientBuilder when using the Apache HTTP Client 4.