Java ClientResponse类代码示例

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
public static WebClient mockWebClient(final WebClient originalClient, final Mono<?> mono){
    WebClient client = spy(originalClient);

    WebClient.UriSpec uriSpec = mock(WebClient.UriSpec.class);
    doReturn(uriSpec).when(client).get();

    WebClient.RequestHeadersSpec<?> headerSpec = mock(WebClient.RequestHeadersSpec.class);
    doReturn(headerSpec).when(uriSpec).uri(anyString());
    doReturn(headerSpec).when(headerSpec).accept(any());

    ClientResponse clientResponse = mock(ClientResponse.class);
    doReturn(mono).when(clientResponse).bodyToMono(Mockito.any());
    doReturn(Mono.just(clientResponse)).when(headerSpec).exchange();

    return client;
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Override
public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
	// NOTICE: nothing in "pre" filter stage as CLIENT_RESPONSE_ATTR is not added
	// until the WebHandler is run
	return chain.filter(exchange).then(Mono.defer(() -> {
		ClientResponse clientResponse = exchange.getAttribute(CLIENT_RESPONSE_ATTR);
		if (clientResponse == null) {
			return Mono.empty();
		}
		log.trace("WebClientWriteResponseFilter start");
		ServerHttpResponse response = exchange.getResponse();

		return response.writeWith(clientResponse.body(BodyExtractors.toDataBuffers())).log("webClient response");
	}));
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void hostRouteWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/get")
			.header("Host", "www.example.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.OK);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(HANDLER_MAPPER_HEADER))
								.isEqualTo(RoutePredicateHandlerMapping.class.getSimpleName());
						assertThat(httpHeaders.getFirst(ROUTE_ID_HEADER))
								.isEqualTo("host_example_to_httpbin");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void pathRouteWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/get")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.OK);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(HANDLER_MAPPER_HEADER))
								.isEqualTo(RoutePredicateHandlerMapping.class.getSimpleName());
						assertThat(httpHeaders.getFirst(ROUTE_ID_HEADER))
								.isEqualTo("default_path_to_httpbin");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void hostRouteWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/get")
			.header("Host", "www.method.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.OK);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(HANDLER_MAPPER_HEADER))
								.isEqualTo(RoutePredicateHandlerMapping.class.getSimpleName());
						assertThat(httpHeaders.getFirst(ROUTE_ID_HEADER))
								.isEqualTo("method_test");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void compositeRouteWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/headers?foo=bar&baz")
			.header("Host", "www.foo.org")
			.header("X-Request-Id", "123")
			.cookie("chocolate", "chip")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.OK);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(HANDLER_MAPPER_HEADER))
								.isEqualTo(RoutePredicateHandlerMapping.class.getSimpleName());
						assertThat(httpHeaders.getFirst(ROUTE_ID_HEADER))
								.isEqualTo("host_foo_path_headers_to_httpbin");
						assertThat(httpHeaders.getFirst("X-Response-Foo"))
								.isEqualTo("Bar");
					})
			.expectComplete()
			.verify();
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void defaultFiltersWorks() {
	assertThat(this.properties.getDefaultFilters()).isNotEmpty();

	Mono<ClientResponse> result = webClient.get()
			.uri("/headers")
			.header("Host", "www.addresponseheader.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst("X-Response-Default-Foo"))
								.isEqualTo("Default-Bar");
						assertThat(httpHeaders.get("X-Response-Default-Foo")).hasSize(1);
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void loadBalancerFilterWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/get")
			.header("Host", "www.loadbalancerclient.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.OK);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(ROUTE_ID_HEADER))
								.isEqualTo("load_balancer_client_test");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void removeResponseHeaderFilterWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/headers")
			.header("Host", "www.removereresponseheader.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders).doesNotContainKey("X-Request-Foo");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@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);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void redirectToFilterWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/")
			.header("Host", "www.redirectto.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						assertStatus(response, HttpStatus.FOUND);
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders.getFirst(HttpHeaders.LOCATION))
								.isEqualTo("http://example.org");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Test
public void setResponseHeaderFilterWorks() {
	Mono<ClientResponse> result = webClient.get()
			.uri("/headers")
			.header("Host", "www.setreresponseheader.org")
			.exchange();

	StepVerifier.create(result)
			.consumeNextWith(
					response -> {
						HttpHeaders httpHeaders = response.headers().asHttpHeaders();
						assertThat(httpHeaders).containsKey("X-Request-Foo");
						assertThat(httpHeaders.get("X-Request-Foo")).containsExactly("Bar");
					})
			.expectComplete()
			.verify(DURATION);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
@Override
public Mono<ClientResponse> filter(ClientRequest request, ExchangeFunction next) {
	URI originalUrl = request.url();
	String serviceId = originalUrl.getHost();
	Assert.state(serviceId != null, "Request URI does not contain a valid hostname: " + originalUrl);
	//TODO: reactive lb client

	ServiceInstance instance = this.loadBalancerClient.choose(serviceId);
	URI uri = this.loadBalancerClient.reconstructURI(instance, originalUrl);
	ClientRequest newRequest = ClientRequest.method(request.method(), uri)
			.headers(headers -> headers.addAll(request.headers()))
			.cookies(cookies -> cookies.addAll(request.cookies()))
			.attributes(attributes -> attributes.putAll(request.attributes()))
			.body(request.body())
			.build();
	return next.exchange(newRequest);
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
public Mono<ClientResponse> createUser(String username, char[] password, List<String> tags) {
    if(username == null) {
        throw new IllegalArgumentException("username cannot be null");
    }
    if(password == null) {
        throw new IllegalArgumentException("password cannot be null or empty. If you need to create a user that "
            + "will only authenticate using an x509 certificate, use createUserWithPasswordHash with a blank hash.");
    }
    Map<String, Object> body = new HashMap<String, Object>();
    body.put("password", new String(password));
    body.put("tags", StringUtils.collectionToCommaDelimitedString(tags));

    return client
        .put()
        .uri("/users/{username}", username)
        .syncBody(body)
        .exchange();
}
 

import org.springframework.web.reactive.function.client.ClientResponse; //导入依赖的package包/类
public Mono<ClientResponse> createUserWithPasswordHash(String username, char[] passwordHash, List<String> tags) {
    if(username == null) {
        throw new IllegalArgumentException("username cannot be null");
    }
    // passwordless authentication is a thing. See
    // https://github.com/rabbitmq/hop/issues/94 and https://www.rabbitmq.com/authentication.html. MK.
    if(passwordHash == null) {
        passwordHash = "".toCharArray();
    }
    Map<String, Object> body = new HashMap<String, Object>();
    body.put("password_hash", String.valueOf(passwordHash));
    body.put("tags", StringUtils.collectionToCommaDelimitedString(tags));

    return client
        .put()
        .uri("/users/{username}", username)
        .syncBody(body)
        .exchange();
}