/** Connect to server via Reactor Netty. */ DefaultWebTestClientBuilder() { this(new ReactorClientHttpConnector()); }
private ExchangeFunction initExchangeFunction() { if (this.exchangeFunction != null) { return this.exchangeFunction; } else if (this.connector != null) { return ExchangeFunctions.create(this.connector, this.exchangeStrategies); } else { return ExchangeFunctions.create(new ReactorClientHttpConnector(), this.exchangeStrategies); } }
private ReactorClientHttpConnector initConnector() { if (bufferFactory instanceof NettyDataBufferFactory) { ByteBufAllocator allocator = ((NettyDataBufferFactory) bufferFactory).getByteBufAllocator(); return new ReactorClientHttpConnector(this.factory, httpClient -> httpClient.tcpConfiguration(tcpClient -> tcpClient.option(ChannelOption.ALLOCATOR, allocator))); } else { return new ReactorClientHttpConnector(); } }
@Parameterized.Parameters(name = "webClient [{0}]") public static Object[][] arguments() { return new Object[][] { {new JettyClientHttpConnector()}, {new ReactorClientHttpConnector()} }; }
private static WebClient.Builder createDefaultWebClient(Duration connectTimeout, Duration readTimeout) { HttpClient httpClient = HttpClient.create() .compress(true) .tcpConfiguration(tcp -> tcp.bootstrap(bootstrap -> bootstrap.option( ChannelOption.CONNECT_TIMEOUT_MILLIS, (int) connectTimeout.toMillis() )).observe((connection, newState) -> { if (ConnectionObserver.State.CONNECTED.equals(newState)) { connection.addHandlerLast(new ReadTimeoutHandler(readTimeout.toMillis(), TimeUnit.MILLISECONDS )); } })); ReactorClientHttpConnector connector = new ReactorClientHttpConnector(httpClient); return WebClient.builder().clientConnector(connector); } }
@Parameterized.Parameters(name = "server [{0}] webClient [{1}]") public static Object[][] arguments() { File base = new File(System.getProperty("java.io.tmpdir")); return new Object[][] { {new JettyHttpServer(), new ReactorClientHttpConnector()}, {new JettyHttpServer(), new JettyClientHttpConnector()}, {new ReactorHttpServer(), new ReactorClientHttpConnector()}, {new ReactorHttpServer(), new JettyClientHttpConnector()}, {new TomcatHttpServer(base.getAbsolutePath()), new ReactorClientHttpConnector()}, {new TomcatHttpServer(base.getAbsolutePath()), new JettyClientHttpConnector()}, {new UndertowHttpServer(), new ReactorClientHttpConnector()}, {new UndertowHttpServer(), new JettyClientHttpConnector()} }; }
private static WebClientProvider getWebClientProvider(ClientConfiguration clientConfiguration) { Duration connectTimeout = clientConfiguration.getConnectTimeout(); Duration soTimeout = clientConfiguration.getSocketTimeout(); TcpClient tcpClient = TcpClient.create(); if (!connectTimeout.isNegative()) { tcpClient = tcpClient.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(connectTimeout.toMillis())); } if (!soTimeout.isNegative()) { tcpClient = tcpClient.doOnConnected(connection -> connection // .addHandlerLast(new ReadTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS)) .addHandlerLast(new WriteTimeoutHandler(soTimeout.toMillis(), TimeUnit.MILLISECONDS))); } String scheme = "http"; HttpClient httpClient = HttpClient.from(tcpClient); if (clientConfiguration.useSsl()) { httpClient = httpClient.secure(sslConfig -> { Optional<SSLContext> sslContext = clientConfiguration.getSslContext(); sslContext.ifPresent(it -> sslConfig.sslContext(new JdkSslContext(it, true, ClientAuth.NONE))); }); scheme = "https"; } ReactorClientHttpConnector connector = new ReactorClientHttpConnector(httpClient); WebClientProvider provider = WebClientProvider.create(scheme, connector); return provider.withDefaultHeaders(clientConfiguration.getDefaultHeaders()); }
@Before public void setup() { ClientHttpConnector httpConnector = new ReactorClientHttpConnector(); baseUri = "http://localhost:" + port; this.webClient = WebClient.builder().clientConnector(httpConnector) .baseUrl(baseUri).build(); this.testClient = WebTestClient.bindToServer().baseUrl(baseUri).build(); }
@Before public void setup() { try { SslContext sslContext = SslContextBuilder.forClient() .trustManager(InsecureTrustManagerFactory.INSTANCE).build(); HttpClient httpClient = HttpClient.create().secure(ssl -> { ssl.sslContext(sslContext); }); ClientHttpConnector httpConnector = new ReactorClientHttpConnector( httpClient); baseUri = "https://localhost:" + port; this.webClient = WebClient.builder().clientConnector(httpConnector) .baseUrl(baseUri).build(); this.testClient = WebTestClient.bindToServer(httpConnector).baseUrl(baseUri).build(); } catch (SSLException e) { throw new RuntimeException(e); } }
/** Connect to server via Reactor Netty. */ DefaultWebTestClientBuilder() { this(new ReactorClientHttpConnector()); }
/** Connect to server via Reactor Netty. */ DefaultWebTestClientBuilder() { this(new ReactorClientHttpConnector()); }
@Configuration public class WebClientConfig { @Bean public ObjectMapper jacksonObjectMapper(){ return new ObjectMapper(); } @Bean public WebClient webClient(){ WebClient webClient = new WebClient(new ReactorClientHttpConnector()); return webClient; } }
protected ReactorClientHttpConnector buildTrustAllSslConnector() { HttpClient client = HttpClient.create().secure( (sslContextSpec) -> sslContextSpec.sslContext(createSslContext())); return new ReactorClientHttpConnector(client); }
/** * Create a {@link ClientHttpConnector} for the given {@link ClientOptions} and * {@link SslConfiguration}. * * @param options must not be {@literal null} * @param sslConfiguration must not be {@literal null} * @return a new {@link ClientHttpConnector}. */ public static ClientHttpConnector create(ClientOptions options, SslConfiguration sslConfiguration) { HttpClient client = HttpClient.create(); if (hasSslConfiguration(sslConfiguration)) { SslContextBuilder sslContextBuilder = SslContextBuilder.forClient(); configureSsl(sslConfiguration, sslContextBuilder); client = client.secure(builder -> { builder.sslContext(sslContextBuilder); }); } client = client.tcpConfiguration(it -> it.option( ChannelOption.CONNECT_TIMEOUT_MILLIS, Math.toIntExact(options.getConnectionTimeout().toMillis()))); return new ReactorClientHttpConnector(client); }
@Override public Builder<T> options(ReactiveOptions options) { if (!options.isEmpty()) { ReactorClientHttpConnector connector = new ReactorClientHttpConnector( opts -> { if (options.getConnectTimeoutMillis() != null) { opts.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, options.getConnectTimeoutMillis().intValue()); } if (options.getReadTimeoutMillis() != null) { opts.afterNettyContextInit(ctx -> { ctx.addHandlerLast(new ReadTimeoutHandler( options.getReadTimeoutMillis(), TimeUnit.MILLISECONDS)); }); } if (options.isTryUseCompression() != null) { opts.compression(options.isTryUseCompression()); } }); setWebClient(webClient.mutate().clientConnector(connector).build()); } return this; }
/** * Sets request options using Feign {@link Request.Options} * * @param options Feign {@code Request.Options} object * @return this builder */ public Builder<T> options(final ReactiveOptions options) { if (!options.isEmpty()) { ReactorClientHttpConnector connector = new ReactorClientHttpConnector( opts -> { if (options.getConnectTimeoutMillis() != null) { opts.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, options.getConnectTimeoutMillis()); } if (options.getReadTimeoutMillis() != null) { opts.afterNettyContextInit(ctx -> { ctx.addHandlerLast(new ReadTimeoutHandler( options.getReadTimeoutMillis(), TimeUnit.MILLISECONDS)); }); } if (options.isTryUseCompression() != null) { opts.compression(options.isTryUseCompression()); } }); this.webClient = webClient.mutate().clientConnector(connector).build(); } return this; }