@Test public void secureHeadersFilterWorks() { Mono<ClientResponse> result = webClient.get() .uri("/headers") .header("Host", "www.secureheaders.org") .exchange(); SecureHeadersProperties defaults = new SecureHeadersProperties(); StepVerifier.create(result) .consumeNextWith( response -> { assertStatus(response, HttpStatus.OK); HttpHeaders httpHeaders = response.headers().asHttpHeaders(); assertThat(httpHeaders.getFirst(X_XSS_PROTECTION_HEADER)).isEqualTo(defaults.getXssProtectionHeader()); assertThat(httpHeaders.getFirst(STRICT_TRANSPORT_SECURITY_HEADER)).isEqualTo(defaults.getStrictTransportSecurity()); assertThat(httpHeaders.getFirst(X_FRAME_OPTIONS_HEADER)).isEqualTo(defaults.getFrameOptions()); assertThat(httpHeaders.getFirst(X_CONTENT_TYPE_OPTIONS_HEADER)).isEqualTo(defaults.getContentTypeOptions()); assertThat(httpHeaders.getFirst(REFERRER_POLICY_HEADER)).isEqualTo(defaults.getReferrerPolicy()); assertThat(httpHeaders.getFirst(CONTENT_SECURITY_POLICY_HEADER)).isEqualTo(defaults.getContentSecurityPolicy()); assertThat(httpHeaders.getFirst(X_DOWNLOAD_OPTIONS_HEADER)).isEqualTo(defaults.getDownloadOptions()); assertThat(httpHeaders.getFirst(X_PERMITTED_CROSS_DOMAIN_POLICIES_HEADER)).isEqualTo(defaults.getPermittedCrossDomainPolicies()); }) .expectComplete() .verify(DURATION); }
.toFuture(); final CompletableFuture<HttpStatus> status = Try.of(() -> githubWebClient.get() .exchange() .doOnSuccessOrError(errorLogger) .map(ClientResponse::statusCode)
private void getFees() { BitcoinFeesRecommended recommended = this.webClient.get().retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(BitcoinFeesRequestFailedException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(BitcoinFeesRequestFailedException::new) ) .bodyToMono(BitcoinFeesRecommended.class).block(); if (null != recommended) { this.priority = BigInteger.valueOf(recommended.getFastestFee()); this.normal = BigInteger.valueOf(recommended.getHalfHourFee()); this.economy = BigInteger.valueOf(recommended.getHourFee()); } }
private void getGases() { EthGasAPI ethGasAPI = this.webClient.get().retrieve() .onStatus(HttpStatus::is4xxClientError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(EthGasStationRequestFailedException::new) ) .onStatus(HttpStatus::is5xxServerError, clientResponse -> clientResponse .bodyToMono(ByteArrayResource.class) .map(ByteArrayResource::getByteArray) .map(String::new) .map(EthGasStationRequestFailedException::new) ) .bodyToMono(EthGasAPI.class).block(); if (null != ethGasAPI) { this.priority = BigInteger.valueOf(ethGasAPI.getFastest().longValue()); this.normal = BigInteger.valueOf(ethGasAPI.getFast().longValue()); this.economy = BigInteger.valueOf(ethGasAPI.getAverage().longValue()); } }
@Override protected Mono<Health> doHealthCheck(Health.Builder builder) { return webClient.get().uri("/actuator/health") .exchange() .map(ClientResponse::statusCode) .map((status -> status.is2xxSuccessful() ? Health.up() : Health.down())) .map(Health.Builder::build); }
@GetMapping("/user/{id}") public Mono<ServerResponse> handleGetUserById(@PathVariable String id) { return WebClient.create("http://localhost:9000").get().uri("/api/user/" + id) .accept(MediaType.APPLICATION_JSON).exchange().flatMap(resp -> ServerResponse.ok().body(resp.bodyToMono(User.class), User.class)); }
@Test public void testFilterFunctionWorks() { String value = WebClient.builder() .baseUrl("http://testservice") .filter(lbFunction) .build() .get() .uri("/hello") .retrieve() .bodyToMono(String.class).block(); assertThat(value).isEqualTo("Hello World"); }
@Override protected Mono<Health> doHealthCheck(Builder builder) { return vaultOperations .doWithSession(it -> it.get().uri("sys/health").exchange()) .flatMap(it -> it.bodyToMono(VaultHealthImpl.class)) .onErrorResume(WebClientResponseException.class, VaultReactiveHealthIndicator::deserializeError) .map(vaultHealthResponse -> { return getHealth(builder, vaultHealthResponse); }); }
@PostMapping("/booking") public Mono<ResponseEntity<Void>> book() { logger.debug("Processing booking request.."); return carsClient.get().uri("/cars") .retrieve() .bodyToFlux(Car.class) .doOnNext(car -> logger.debug("Trying to book " + car)) .take(5) .flatMap(this::requestCar) .next() .doOnNext(car -> logger.debug("Booked car " + car)); }
@GetMapping("/foos/{id}") public Mono<Foo> getFooResource(@RegisteredOAuth2AuthorizedClient("custom") OAuth2AuthorizedClient client, @PathVariable final long id){ return webClient .get() .uri("http://localhost:8088/spring-security-oauth-resource/foos/{id}", id) .attributes(oauth2AuthorizedClient(client)) .retrieve() .bodyToMono(Foo.class); }
@Override public Mono<Void> delete(String path) { Assert.hasText(path, "Path must not be empty"); return sessionClient.delete().uri(path).exchange() .flatMap(mapResponse(String.class, path)).then(); }
@SuppressWarnings("unchecked") @Override public <T> Mono<VaultResponseSupport<T>> read(String path, Class<T> responseType) { ParameterizedTypeReference<VaultResponseSupport<T>> ref = VaultResponses .getTypeReference(responseType); return sessionClient.get().uri(path).exchange().flatMap(mapResponse(ref, path)); }
Mono<GeoTimesResponse> get(final Mono<String> monoUrl) { return monoUrl.flatMap(url -> webClient .get() .uri(url) .accept(MediaType.APPLICATION_JSON) .exchange() .flatMap(clientResponse -> clientResponse.bodyToMono(GeoTimesResponse.class))); }
@GetMapping("/user") public Mono<ServerResponse> handleGetUsers() { return WebClient.create("http://localhost:9000").get().uri("/api/user") .accept(MediaType.APPLICATION_JSON).exchange().flatMap(resp -> ServerResponse.ok().body(resp.bodyToFlux(User.class), User.class)); }
@Test public void testNoHostName() { ClientResponse clientResponse = WebClient.builder() .baseUrl("http:///foobar") .filter(lbFunction) .build() .get().exchange().block(); assertThat(clientResponse.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST); }
Mono<GeoLocationResponse> get(final Mono<String> urlMono) { return urlMono.flatMap(url -> webClient .get() .uri(url) .accept(MediaType.APPLICATION_JSON) .exchange() .flatMap(clientResponse -> clientResponse.bodyToMono(GeoLocationResponse.class))); }
@Test public void testNoInstance() { ClientResponse clientResponse = WebClient.builder() .baseUrl("http://foobar") .filter(lbFunction) .build() .get().exchange().block(); assertThat(clientResponse.statusCode()).isEqualTo(HttpStatus.SERVICE_UNAVAILABLE); }
private Mono<Void> doHttpInvoke() { if (requestDTO.getHttpMethod().equals(HttpMethodEnum.GET.getName())) { String uri = buildRealURL(); if (StringUtils.isNoneBlank(requestDTO.getExtInfo())) { uri = uri + "?" + GSONUtils.getInstance().toGetParam(requestDTO.getExtInfo()); } return WEB_CLIENT.get().uri(uri) .headers(httpHeaders -> { httpHeaders.addAll(exchange.getRequest().getHeaders()); httpHeaders.remove(HttpHeaders.HOST); }) .exchange() .doOnError(e -> LogUtils.error(LOGGER, e::getMessage)) .timeout(Duration.ofMillis(timeout)) .flatMap(this::doNext); } else if (requestDTO.getHttpMethod().equals(HttpMethodEnum.POST.getName())) { return WEB_CLIENT.post().uri(buildRealURL()) .headers(httpHeaders -> { httpHeaders.addAll(exchange.getRequest().getHeaders()); httpHeaders.remove(HttpHeaders.HOST); }) .contentType(buildMediaType()) .body(BodyInserters.fromDataBuffers(exchange.getRequest().getBody())) .exchange() .doOnError(e -> LogUtils.error(LOGGER, e::getMessage)) .timeout(Duration.ofMillis(timeout)) .flatMap(this::doNext); } return Mono.empty(); }
} else { requestHeadersSpec = this.webClient.get() .uri(userInfoUri) .header(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON_VALUE) .headers(headers -> headers.setBearerAuth(userRequest.getAccessToken().getTokenValue()));
@Test @SuppressWarnings("Duplicates") public void sseAsEventWithoutAcceptHeader() { Flux<ServerSentEvent<String>> result = this.webClient.get() .uri("/event") .accept(TEXT_EVENT_STREAM) .exchange() .flatMapMany(response -> response.body( toFlux(new ParameterizedTypeReference<ServerSentEvent<String>>() {}))); StepVerifier.create(result) .consumeNextWith( event -> { assertEquals("0", event.id()); assertEquals("foo", event.data()); assertEquals("bar", event.comment()); assertNull(event.event()); assertNull(event.retry()); }) .consumeNextWith( event -> { assertEquals("1", event.id()); assertEquals("foo", event.data()); assertEquals("bar", event.comment()); assertNull(event.event()); assertNull(event.retry()); }) .thenCancel() .verify(Duration.ofSeconds(5L)); }