org.springframework.web.reactive.function.server.ServerResponse Java Examples

@Bean
RouterFunction<ServerResponse> routes(WebClient client) {
		return route(GET("/reservations/names"), r -> {

				Publisher<String> map = client
					.get()
					.uri("http://reservation-service/reservations")
					.retrieve()
					.bodyToFlux(Reservation.class)
					.map(Reservation::getEmail);

				Publisher<String> fallback =
					HystrixCommands
						.from(map)
						.fallback(Mono.just("EEK!"))
						.commandName("fallback")
						.eager()
						.build();

				return ServerResponse.ok().body(fallback, String.class);
		});
}
 

public Mono<ServerResponse> update(ServerRequest req) {

        return Mono
            .zip(
                (data) -> {
                    Post p = (Post) data[0];
                    Post p2 = (Post) data[1];
                    p.setTitle(p2.getTitle());
                    p.setContent(p2.getContent());
                    return p;
                },
                this.posts.findById(req.pathVariable("id")),
                req.bodyToMono(Post.class)
            )
            .cast(Post.class)
            .flatMap(post -> this.posts.save(post))
            .flatMap(post -> ServerResponse.noContent().build());

    }
 

@Override
public Mono<ServerResponse> handleRequest(ServerWebExchange exchange, Throwable ex) {
    if (acceptsHtml(exchange)) {
        return htmlErrorResponse(ex);
    }
    // JSON result by default.
    return ServerResponse.status(HttpStatus.TOO_MANY_REQUESTS)
        .contentType(MediaType.APPLICATION_JSON_UTF8)
        .body(fromObject(buildErrorResult(ex)));
}
 

@Override
protected Mono<ServerResponse> processBody(OtherEntity validBody, ServerRequest originalRequest) {
    String responseBody = String.format("Other object with item %s and quantity %s!", validBody.getItem(), validBody.getQuantity());
    return ServerResponse.ok()
        .contentType(MediaType.APPLICATION_JSON)
        .body(Mono.just(responseBody), String.class);
}
 

public Mono<ServerResponse> create(ServerRequest request) {
    return request
        .bodyToMono(Order.class)
        .flatMap(orderRepository::save)
        .flatMap(o ->
            ServerResponse.created(URI.create("/orders/" + o.getId()))
                          .build()
        );
}
 

@Bean
public RouterFunction<ServerResponse> employeeServiceBox() {
    return route(GET("/listFluxEmps"), dataHandler::empList)
    		   .andRoute(GET("/selectEmpById/{id}"), dataHandler::chooseEmpById)
    		   .andRoute(POST("/selectFluxEmps"), dataHandler::chooseFluxEmps)
    		   .andRoute(POST("/saveEmp"), dataHandler::saveEmployeeMono)
    		   .andRoute(GET("/avgAgeEmps"), dataHandler::averageAge)
    		   .andRoute(GET("/totalAgeEmps"), dataHandler::totalAge)
    		   .andRoute(GET("/countEmps"), dataHandler::countEmps)
    		   .andRoute(GET("/countPerDept/{deptid}"), dataHandler::countEmpsPerDept)
    		   .andRoute(GET("/selectEmpValidAge/{age}"), dataHandler::chooseFluxEmpsValidAge);
}
 

@Override
public Mono<ServerResponse> handle(ServerRequest serverRequest) {
	//生成验证码
	String text = producer.createText();
	BufferedImage image = producer.createImage(text);

	//保存验证码信息
	String randomStr = serverRequest.queryParam("randomStr").get();
	redisTemplate.opsForValue().set(DEFAULT_CODE_KEY + randomStr, text, 120, TimeUnit.SECONDS);

	// 转换流信息写出
	FastByteArrayOutputStream os = new FastByteArrayOutputStream();
	try {
		ImageIO.write(image, "jpeg", os);
	} catch (IOException e) {
		log.error("ImageIO write err", e);
		return Mono.error(e);
	}

	return ServerResponse
		.status(HttpStatus.OK)
		.contentType(MediaType.IMAGE_JPEG)
		.body(BodyInserters.fromResource(new ByteArrayResource(os.toByteArray())));
}
 

@Test
public void write_works_as_expected() {
    // given
    ServerResponse responseMock = mock(ServerResponse.class);
    HttpHeaders responseHeadersMock = mock(HttpHeaders.class);
    MediaType expectedContentTypeMock = mock(MediaType.class);

    doReturn(responseHeadersMock).when(responseMock).headers();
    doReturn(expectedContentTypeMock).when(responseHeadersMock).getContentType();

    // when
    handlerSpy.write(serverWebExchangeMock, responseMock);

    // then
    verify(serverHttpResponseHeadersMock).setContentType(expectedContentTypeMock);
    ArgumentCaptor<ResponseContext> responseContextArgumentCaptor = ArgumentCaptor.forClass(ResponseContext.class);
    verify(responseMock).writeTo(eq(serverWebExchangeMock), responseContextArgumentCaptor.capture());
    ResponseContext responseContext = responseContextArgumentCaptor.getValue();
    assertThat(responseContext.messageWriters()).isEqualTo(messageWriters);
    assertThat(responseContext.viewResolvers()).isEqualTo(viewResolvers);
}
 

@Bean
public RouterFunction<ServerResponse> proxy(WebClient webClient) {
	return route(path(API_PREFIX + SERVICE_PARAM + CATCH_ALL_SUFFIX), request -> authorizedClient(request)
		.map(attr -> webClient.method(request.method())
			.uri(toBackendUri(request))
			.headers(cleanedHeaders(request.headers().asHttpHeaders()))
			.body(fromDataBuffers(request.exchange().getRequest().getBody()))
			.attributes(attr))
		.flatMap(spec -> spec.exchange())
		.flatMap(response -> ServerResponse.status(response.statusCode())
			.headers(cleanedHeaders(response.headers().asHttpHeaders()))
			.body(fromDataBuffers(response.body(toDataBuffers())))));
}
 

private RouterFunction<ServerResponse> routingFunction() {

        return route(GET("/p?ths"), serverRequest -> ok().body(fromObject("/p?ths"))).andRoute(GET("/test/{*id}"), serverRequest -> ok().body(fromObject(serverRequest.pathVariable("id"))))
            .andRoute(GET("/*card"), serverRequest -> ok().body(fromObject("/*card path was accessed")))
            .andRoute(GET("/{var1}_{var2}"), serverRequest -> ok().body(fromObject(serverRequest.pathVariable("var1") + " , " + serverRequest.pathVariable("var2"))))
            .andRoute(GET("/{baeldung:[a-z]+}"), serverRequest -> ok().body(fromObject("/{baeldung:[a-z]+} was accessed and baeldung=" + serverRequest.pathVariable("baeldung"))))
            .and(RouterFunctions.resources("/files/{*filepaths}", new ClassPathResource("files/")));
    }
 

/**
 * Unmatched requests made to this service will be logged by this function.
 */
@NonNull
public Mono<ServerResponse> unmatched(ServerRequest serverRequest) {
    return serverRequest
            .bodyToMono(String.class)
            .doOnError(throwable -> logger.warn("operation=unmatched", throwable))
            .doOnNext(body -> logger.info("operation=log, path={}, headers={}", serverRequest.path(), serverRequest.headers()))
            .then(notFound().build());
}
 

/**
 * monoRouterFunction.
 * @param bookHandler a {@link BookHandler} object.
 * @return a {@link org.springframework.web.reactive.function.server.RouterFunction}
 * object.
 */
@Bean
public RouterFunction<ServerResponse> monoRouterFunction(BookHandler bookHandler) {
	return route(GET("/api/book").and(accept(MediaType.APPLICATION_JSON)), request -> bookHandler.getAll())
			.andRoute(GET("/api/book/{id}").and(accept(MediaType.APPLICATION_JSON)), bookHandler::getBook)
			.andRoute(POST("/api/book/post").and(accept(MediaType.APPLICATION_JSON)), bookHandler::postBook)
			.andRoute(PUT("/api/book/put/{id}").and(accept(MediaType.APPLICATION_JSON)), bookHandler::putBook)
			.andRoute(DELETE("/api/book/delete/{id}").and(accept(MediaType.APPLICATION_JSON)),
					bookHandler::deleteBook);
}
 

private static ApplicationContext applicationContext(WebFilter... webFilters) {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext();
	for(WebFilter filter : webFilters) {
		context.registerBean(WebFilter.class, () -> filter);
	}
	context.registerBean("webHandler", DispatcherHandler.class, () -> new DispatcherHandler());
	context.registerBean(HandlerMapping.class, () -> RouterFunctions.toHandlerMapping(request -> Mono.just(r -> ServerResponse.ok().build())));
	context.registerBean(HandlerAdapter.class, () -> new HandlerFunctionAdapter());
	context.registerBean(HandlerResultHandler.class, () -> new ServerResponseResultHandler());
	context.refresh();

	return context;
}
 

/**
 * PUT a User
 */
public Mono<ServerResponse> putUser(ServerRequest request) {
    // parse id from path-variable
    long customerId = Long.valueOf(request.pathVariable("id"));

    // get customer data from request object
    Mono<User> customer = request.bodyToMono(User.class);

    // get customer from repository 
    Mono<User> responseMono = customerRepository.putUser(customerId, customer);

    // build response
    return responseMono
        .flatMap(cust -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(fromObject(cust)));
}
 

@Override
public void initialize(GenericApplicationContext applicationContext) {
    var environment = applicationContext.getEnvironment();

    if (!environment.acceptsProfiles(Profiles.of("exporter"))) {
        return;
    }

    applicationContext.registerBean(MetricsCollector.class);

    applicationContext.registerBean("prometheus", RouterFunction.class, () -> {
        var metricsCollector = applicationContext.getBean(MetricsCollector.class);
        return RouterFunctions.route()
                .GET("/prometheus", __ -> {
                    return metricsCollector.collect()
                            .collectList()
                            .flatMap(metrics -> {
                                try {
                                    var writer = new StringWriter();
                                    TextFormat.write004(writer, Collections.enumeration(metrics));
                                    return ServerResponse.ok()
                                            .contentType(MediaType.valueOf(TextFormat.CONTENT_TYPE_004))
                                            .bodyValue(writer.toString());
                                } catch (IOException e) {
                                    return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
                                }
                            });
                })
                .build();

    });
}
 

@Bean
RouterFunction<ServerResponse> index() {
    return route(
        GET("/"),
        req -> ServerResponse.temporaryRedirect(URI.create("swagger-ui/index.html?url=../openapi.json")).build()
    );
}
 

public RouterFunction<ServerResponse> routingFunction() {
	UserRepository repository = new UserRepositorySample();
	UserHandler handler = new UserHandler(repository);

	return nest(path("/user"),
			nest(accept(APPLICATION_JSON),
					route(GET("/{id}"), handler::getAllUsers).andRoute(method(HttpMethod.GET),
							handler::getAllUsers)).andRoute(POST("/").and(contentType(APPLICATION_JSON)),
									handler::getAllUsers));
}
 

@Bean
@RouterOperations({ @RouterOperation(path = "/api/user/index", beanClass = UserRepository.class, beanMethod = "getAllUsers"),
		@RouterOperation(path = "/api/user/{id}", beanClass = UserRepository.class, beanMethod = "getUserById"),
		@RouterOperation(path = "/api/user/post", beanClass = UserRepository.class, beanMethod = "saveUser"),
		@RouterOperation(path = "/api/user/put/{id}", beanClass = UserRepository.class, beanMethod = "putUser"),
		@RouterOperation(path = "/api/user/delete/{id}", beanClass = UserRepository.class, beanMethod = "deleteUser") })
public RouterFunction<ServerResponse> monoRouterFunction(UserHandler userHandler) {
	return route(GET("/api/user/index").and(accept(MediaType.APPLICATION_JSON)), userHandler::getAll)
			.andRoute(GET("/api/user/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::getUser)
			.andRoute(POST("/api/user/post").and(accept(MediaType.APPLICATION_JSON)), userHandler::postUser)
			.andRoute(PUT("/api/user/put/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::putUser)
			.andRoute(DELETE("/api/user/delete/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::deleteUser);
}
 

@Bean
public RouterFunction<ServerResponse> loginServiceBox() {
    return route(GET("/listFluxLogins"), loginHandler::loginDetailsList)
    		   .andRoute(GET("/selectLoginById/{id}"), loginHandler::loginDetailsById)
    		   .andRoute(POST("/selectFluxLogins"), loginHandler::chooseFluxLoginDetails)
    		   .andRoute(POST("/saveLogin"), loginHandler::saveLogindetailsMono)
    		   .andRoute(GET("/totalLogins"), loginHandler::countLogins);
}
 

@Bean
RouterFunction<ServerResponse> routes(final Flux<ServerSentEvent<Map>> processor,
                                      final Consumer<String> distributeEvent) {

  final ParameterizedTypeReference<Map<String, String>> type
      = new ParameterizedTypeReference<Map<String, String>>() {};

  return

      route(GET("/**"),
            request -> ok().contentType(request.headers().accept().contains(TEXT_EVENT_STREAM)
                                            ? TEXT_EVENT_STREAM : APPLICATION_STREAM_JSON)
                           .body(processor.map(s -> s), ServerSentEvent.class))

          .andRoute(POST("/**"),
                    request -> accepted().body(request.bodyToMono(type)
                                                      .map(map -> map.getOrDefault("message", ""))
                                                      .map(String::valueOf)
                                                      .map(String::trim)
                                                      .filter(s -> s.length() > 0)
                                                      .doOnNext(distributeEvent)
                                                      .map(m -> format("message '%s' accepted.", m))
                                                      .map(message -> singletonMap("response", message))
                                                      .subscribeOn(Schedulers.elastic())
                                                      .flatMap(Mono::just), Map.class))
      ;
}
 

public Mono<ServerResponse> countEmpsPerDept(ServerRequest req) {
	Function<Employee, Integer> ages = (emp) -> emp.getAge();
	Function<Employee, Mono<Integer>> flatMapAge = (emp) -> Mono.just(emp).map(ages);
	Mono<Integer> count = Flux.fromIterable(employeeServiceImpl.findAllEmps()).filter((emp) -> emp.getDeptid().equals(Integer.parseInt(req.pathVariable("deptid"))))
			.flatMap(flatMapAge)
			.reduce((total, increment) -> total + increment);
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(count, Integer.class)
			.switchIfEmpty(ServerResponse.notFound().build());
}
 

@Bean
public RouterFunction<ServerResponse> departmentServiceBox(){
	return route(GET("/listFluxDepts"), dataHandler::deptList)
			.andRoute(GET("/selectDeptById/{id}"), dataHandler::chooseDeptById)
			.andRoute(POST("/selectFluxDepts"), dataHandler::chooseFluxDepts)
			.andRoute(POST("/saveFluxDept"), dataHandler::saveDepartmentMono)
			.andRoute(GET("/countFluxDepts"), dataHandler::countDepts);
	
}
 

public Mono<ServerResponse> countLogins(ServerRequest req) {
	
	Mono<Long> count = Flux.fromIterable(logindetailsServiceImpl.findAllLogindetails())
			.count();
	TotalUsers countEmp = new TotalUsers();
	countEmp.setCount(count.block());
	Mono<TotalUsers> monoCntLogins = Mono.justOrEmpty(countEmp);
	return ok().contentType(MediaType.APPLICATION_STREAM_JSON).body(monoCntLogins, TotalUsers.class)
			.switchIfEmpty(ServerResponse.notFound().build());
}
 

/**
 * Handle the given request.
 *
 * @param request the request to handler
 * @return the response
 */
@Override
public Mono<ServerResponse> handle(ServerRequest request) {
	return ServerResponse.status(HttpStatus.OK)
		.contentType(MediaType.APPLICATION_JSON)
		.body(BodyInserters.fromValue(UiConfigurationBuilder.builder().build()));
}
 

@Bean
RouterFunction<ServerResponse> routes(final UserHandlers handlers) {

  return route(GET("/api/v1/users/**"),
               handlers::streamUsers)
      .andRoute(POST("/api/v1/users/**"),
                handlers::saveUser)
      ;
}
 

Mono<ServerResponse> handleLogin(ServerRequest request) {
    return request.body(toFormData())
        .map(MultiValueMap::toSingleValueMap)
        .filter(formData -> "baeldung".equals(formData.get("user")))
        .filter(formData -> "you_know_what_to_do".equals(formData.get("token")))
        .flatMap(formData -> ok().body(Mono.just("welcome back!"), String.class))
        .switchIfEmpty(ServerResponse.badRequest()
            .build());
}
 

@Bean
public RouterFunction<ServerResponse> testWhenMetricPathIsNotMeet() {
	RouterFunction<ServerResponse> route = RouterFunctions.route(
			RequestPredicates.path("/actuator/metrics/gateway.requests"),
			request -> ServerResponse.ok().body(BodyInserters
					.fromValue(HELLO_FROM_FAKE_ACTUATOR_METRICS_GATEWAY_REQUESTS)));
	return route;
}
 

public Mono<ServerResponse> getSubnet(ServerRequest request) {
    UUID projectId = UUID.fromString(request.pathVariable("projectId"));
    UUID subnetId = UUID.fromString(request.pathVariable("subnetId"));

    Mono<SubnetWebJson> subnetInfo = serviceProxy.findSubnetById(projectId, subnetId);

    return subnetInfo.flatMap(od -> ServerResponse.ok()
            .contentType(APPLICATION_JSON)
            .body(fromObject(od)))
            .onErrorResume(SubnetNotFoundException.class, e -> ServerResponse.notFound().build());
}
 

/**
 * 参考AbstractErrorWebExceptionHandler
 *
 * @param exchange
 * @param response
 * @return
 */
private Mono<? extends Void> write(ServerWebExchange exchange,
                                   ServerResponse response,Throwable ex) {
    exchange.getResponse().getHeaders()
            .setContentType(response.headers().getContentType());
    // 保存日志
    accessLogService.sendLog(exchange, (Exception) ex);
    return response.writeTo(exchange, new ResponseContext());
}
 

@Bean
RouterFunction<ServerResponse> githubRoutes(final GithubProperties props,
                                            final WebClient githubWebClient) {
  return

      route(GET("/github/props/manual"),
            request -> ok().body(Mono.just(
                singletonMap("github",
                             singletonMap("token", props.getToken()))),
                                 Map.class))

          .andRoute(GET("/github/props/**"),
                    request -> ok().body(Mono.just(props), GithubProperties.class))

          .andRoute(GET("/github/search/users/{username}"), // ?page=1&size=2
                    request -> ok().body(githubWebClient.get()
                                                        .uri(
                                                            "/search/users?q={q}&page={page}&per_page={per_page}",
                                                            HashMap.of(
                                                                "q", request.pathVariable("username"),
                                                                "page", request.queryParam("page").orElse("0"),
                                                                "per_page", request.queryParam("size").orElse("3")
                                                            ).toJavaMap()
                                                        )
                                                        .exchange()
                                                        .subscribeOn(Schedulers.elastic())
                                                        .flatMapMany(response -> response.bodyToFlux(Map.class)),
                                         Map.class))

          .andRoute(GET("/**"),
                    request -> ok().body(Mono.just(singletonMap("result", "TODO")),
                                         Map.class))
      ;
}