reactor/reactor-netty

    /**
     * Create the reactive netty WebClient
     *
     * @param connectionMap connection map
     * @return The WebClient to perform reactive web request
     */
    WebClient getWebClient(Map<String, String> connectionMap) {
        return webClientBuilder.clientConnector(new ReactorClientHttpConnector(getHttpClient(connectionMap))).build();
    }


    /**
     * Prepare Reactor-Netty HttpClient with Http-Proxy-Settings, Read-Timeout and Write-Timeout.
     *
     * @param connectionMap connection map
     * @return The http client
     */
    private HttpClient getHttpClient(Map<String, String> connectionMap) {
        return HttpClient.create(connectionProvider).tcpConfiguration(getTcpMapper(connectionMap));
    }

    /**
     * Initialize tcp client with it's basic ChannelOption settings.
     * SO_KEEPALIVE         If true then the channel try to keep alive when server allows similar functionality
     * TCP_NODELAY          improved latency and throughput on a certain workload. Nagle's algorithm was introduced
     * to reduce the overhead of TCP/IP packets (i.e. smaller a packet, bigger the overhead).
     * It is basically to prevent a poor user application from generating too many small packets.
     * AUTO_CLOSE           If true then the Channel is closed automatically and immediately on write failure.
     *
     * @param tcpClient     the targeted tcp client
     * @param connectionMap the key-value pair that keeps all the http connection configuration.
     * @return the tcp client
     */
    protected TcpClient initTcpClient(TcpClient tcpClient, Map<String, String> connectionMap) {
        boolean keepAlive=env.getProperty(KEEP_ALIVE_KEY, Boolean.class, SO_KEEP_ALIVE_STATUS);
        return tcpClient
                .option(ChannelOption.SO_KEEPALIVE, keepAlive)
                .option(ChannelOption.CONNECT_TIMEOUT_MILLIS,
                        Integer.valueOf(connectionMap.get(TIMEOUT)))
                .doOnConnected(conn -> {
                        long readWriteTimeout=Long.parseLong(connectionMap.get(SO_TIMEOUT));
                        conn.addHandlerLast(
                        new ReadTimeoutHandler(readWriteTimeout, TimeUnit.MILLISECONDS)).addHandlerLast(new WriteTimeoutHandler(readWriteTimeout, TimeUnit.MILLISECONDS));
                });
    }

    protected Function<TcpClient, TcpClient> getTcpMapper(Map<String, String> connectionMap) {
        return (TcpClient tcpClient) -> {
            tcpClient = initTcpClient(tcpClient, connectionMap);
            return tcpClient;
        };
    }