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

@Bean
public RouterFunction<ServerResponse> routeCity(InfluxProxyHandler influxProxyHandler) {
    return RouterFunctions
            .route(RequestPredicates.path("/query")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::query)
            .andRoute(RequestPredicates.POST("/write")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::write)
            .andRoute(RequestPredicates.GET("/ping")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::ping)
            .andRoute(RequestPredicates.path("/debug/{opt}")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::debug)
            .andRoute(RequestPredicates.path("/debug")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::debug)
            .andRoute(RequestPredicates.path("/refresh/allBackend")
                            .and(RequestPredicates.accept(MediaType.ALL)),
                    influxProxyHandler::refreshAllBackend)
            ;
}
 

public RouterFunction<ServerResponse> routingFunction() {
	UserRepository repository = new UserRepositorySample();
	UserHandler handler = new UserHandler(repository);
	
	return nest (
		path("/user"),
		nest(
			accept(MediaType.ALL),
			route(GET("/"), handler::getAllUsers)
		)
		.andRoute(GET("/{id}"), handler::getUser)
		.andRoute(POST("/").and(contentType(APPLICATION_JSON)), handler::createUser)
		.andRoute(PUT("/").and(contentType(APPLICATION_JSON)), handler::updateUser)
		.andRoute(DELETE("/{id}").and(contentType(APPLICATION_JSON)), handler::deleteUser)
	);
}
 

@Bean
RouterFunction routes(final HandlerFunction<ServerResponse> fallbackHandler) {
  return
      nest(
          path("/"),
          nest(
              accept(APPLICATION_JSON),
              route(
                  GET("/api/orders"),
                  getOrdersHandler()
              )
          ).andNest(
              accept(APPLICATION_JSON),
              route(
                  GET("/api"),
                  getCountQueryHandler()
              )
          )
      ).andOther(
          route(
              GET("/**"),
              fallbackHandler
          )
      )
      ;
}
 

@Bean
@RouterOperations({ @RouterOperation(path = "/employees-composed/update", beanClass = EmployeeRepository.class, beanMethod = "updateEmployee"),
		@RouterOperation(path = "/employees-composed/{id}", beanClass = EmployeeRepository.class, beanMethod = "findEmployeeById"),
		@RouterOperation(path = "/employees-composed", beanClass = EmployeeRepository.class, beanMethod = "findAllEmployees") })
RouterFunction<ServerResponse> composedRoutes() {
	return
			route(GET("/employees-composed"),
					req -> ok().body(
							employeeRepository().findAllEmployees(), Employee.class))
					.and(route(GET("/employees-composed/{id}"),
							req -> ok().body(
									employeeRepository().findEmployeeById(req.pathVariable("id")), Employee.class)))
					.and(route(POST("/employees-composed/update"),
							req -> req.body(BodyExtractors.toMono(Employee.class))
									.doOnNext(employeeRepository()::updateEmployee)
									.then(ok().build())));
}
 

@Bean
public RouterFunction<ServerResponse> routes(OrderHandler orderHandler) {
	return
		nest(path("/orders"),
			nest(accept(APPLICATION_JSON),
				route(GET("/{id}"), orderHandler::get)
				.andRoute(method(HttpMethod.GET), orderHandler::list)
			)
			.andNest(contentType(APPLICATION_JSON),
				route(POST("/"), orderHandler::create)
			)
			.andNest((serverRequest) -> serverRequest.cookies()
			                                         .containsKey("Redirect-Traffic"),
				route(all(), serverRedirectHandler)
			)
		);
}
 

@Bean
RouterFunction<ServerResponse> composedRoutes() {
  return 
      route(GET("/employees"), 
        req -> ok().body(
          employeeRepository().findAllEmployees(), Employee.class))
        
      .and(route(GET("/employees/{id}"), 
        req -> ok().body(
          employeeRepository().findEmployeeById(req.pathVariable("id")), Employee.class)))
        
      .and(route(POST("/employees/update"), 
        req -> req.body(toMono(Employee.class))
                  .doOnNext(employeeRepository()::updateEmployee)
                  .then(ok().build())));
}
 

@Bean
  public RouterFunction<ServerResponse> routes(final FileItemsHandler handler) {
/*    return
        nest(path("/api/v1/file-items"),
             route(GET("/"), handler::getAll)
                 .andRoute(GET("/like/{filename}/**"), handler::searchAny)
                 .andRoute(POST("/all/**"), handler::saveAll))
                 .andRoute(GET("/{id}/**"), handler::getById)
                 .andRoute(POST("/**"), handler::save)
            .andRoute(path("/**"), handler::getAll);
*/
    return
        route(GET("/api/v1/file-items/like/{filename}"), handler::searchAny)
            .andRoute(POST("/api/v1/file-items/all"), handler::saveAll)
            .andRoute(GET("/api/v1/file-items/{id}"), handler::getById)
            .andRoute(POST("/api/v1/file-items"), handler::save)
            .andRoute(path("/**"), handler::getAll)
        ;
  }
 

private RouterFunction<ServerResponse> routingFunction() {
    FormHandler formHandler = new FormHandler();

    RouterFunction<ServerResponse> restfulRouter = route(GET("/"),
        serverRequest -> ok().body(Flux.fromIterable(actors), Actor.class)).andRoute(POST("/"),
            serverRequest -> serverRequest.bodyToMono(Actor.class)
                .doOnNext(actors::add)
                .then(ok().build()));

    return route(GET("/test"), serverRequest -> ok().body(fromObject("helloworld")))
        .andRoute(POST("/login"), formHandler::handleLogin)
        .andRoute(POST("/upload"), formHandler::handleUpload)
        .and(RouterFunctions.resources("/files/**", new ClassPathResource("files/")))
        .andNest(path("/actor"), restfulRouter)
        .filter((request, next) -> {
            System.out.println("Before handler invocation: " + request.path());
            return next.handle(request);
        });
}
 

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

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

@Bean
public RouterFunction<ServerResponse> upperCookieRouter() {
    return route()
        .GET("/", request -> {
            String text = request.cookies()
                .getFirst("text")
                .getValue()
                .toUpperCase();
            ResponseCookie cookie = ResponseCookie.from("text", text).build();

            return noContent().cookie(cookie).build();
        })
        .build();
}
 

public ServletRegistrationBean routeServlet1(RouterFunction<?> routerFunction) throws Exception {
HttpHandler httpHandler = RouterFunctions.toHttpHandler(routerFunction );
ServletHttpHandlerAdapter servlet = new ServletHttpHandlerAdapter(httpHandler);

     ServletRegistrationBean registrationBean = new ServletRegistrationBean<>(servlet, "/flux" + "/*");
     registrationBean.setLoadOnStartup(1);
     registrationBean.setAsyncSupported(true);
     
 	System.out.println("starts server");		
     return registrationBean;
 }
 

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

			Flux<String> names = client
				.getAllReservations()
				.map(Reservation::getName);

			Publisher<String> cb = HystrixCommands
				.from(names)
				.eager()
				.commandName("names")
				.fallback(Flux.just("EEK!"))
				.build();


		/*	// hedging
			WebClient wc = null; ///
			DiscoveryClient dc = null; ///
			List<ServiceInstance> instances = dc.getInstances("foo-service");
			if (instances.size() >= 3) {
				List<ServiceInstance> serviceInstances = instances.subList(0, 3);

				Flux<Reservation> callThreeServicesAtTheSameTime = Flux
					.fromStream(serviceInstances.stream())
					.map(si -> si.getHost() + ':' + si.getPort())
					.flatMap(uri -> wc.get().uri(uri).retrieve().bodyToFlux(Reservation.class));

				Flux<Reservation> first = Flux.first(callThreeServicesAtTheSameTime);

			}
*/
			return ServerResponse.ok().body(cb, String.class);
		});
	}
 

@Bean
RouterFunction<ServerResponse> returnAllStudentWithCombineFun(){
	
       HandlerFunction<ServerResponse> studentHandler = 
               serverRequest -> 
            	  ServerResponse.ok().body(studentMongoRepository.findAll(), Student.class);
	
	RouterFunction<ServerResponse> studentResponse =
   		RouterFunctions.route(RequestPredicates.GET("/api/f/combine/getAllStudent"),
   				studentHandler);
	
	return studentResponse;
   }
 

@Bean
RouterFunction<ServerResponse> routes(Handlers handlers) {
  return nest(path("/api/v1"), route()
      .GET("/hey", handlers::hey)
      .GET("/hoy", handlers::hoy)
      .GET("/collect", handlers::collect)
      .build())
      .andRoute(path("/**"), handlers::falback);
}
 

@Bean
public RouterFunction<ServerResponse> indexRouter(
		@Value("classpath:/static/index.html") final Resource indexHtml) {

	// Serve static index.html at root, for convenient message publishing.
	return route(
			GET("/"),
			request -> ok().contentType(MediaType.TEXT_HTML).bodyValue(indexHtml));
}
 

@Bean
RouterFunction<ServerResponse> updateEmployeeRoute() {
  return route(POST("/employees/update"), 
    req -> req.body(toMono(Employee.class))
              .doOnNext(employeeRepository()::updateEmployee)
              .then(ok().build()));
}
 

@Bean
public RouterFunction<ServerResponse> route(TestHandler testHandler) {
    return RouterFunctions
            .route(RequestPredicates.GET("/route")
                                    .and(RequestPredicates.accept(MediaType.TEXT_PLAIN)),
                   testHandler::route)
            .andRoute(RequestPredicates.POST("/route2")
                                       .and(RequestPredicates.contentType(MediaType.APPLICATION_JSON)),
                      testHandler::route2)
            .andRoute(RequestPredicates.HEAD("/route3"), request -> ServerResponse.ok().build());
}
 

@Bean
public RouterFunction<ServerResponse> route(GreetingHandler greetingHandler) {
  return RouterFunctions
      .route(RequestPredicates.GET("/hello")
              .and(RequestPredicates.accept(MediaType.TEXT_PLAIN)),
          greetingHandler::hello);
}
 

@Bean
@RouterOperations({
		@RouterOperation(path = "/books", produces = {MediaType.APPLICATION_XML_VALUE, MediaType.APPLICATION_JSON_VALUE} , beanClass = BookRepository.class, beanMethod = "findAll"),
		@RouterOperation(path = "/books", produces = {MediaType.TEXT_PLAIN_VALUE, MediaType.APPLICATION_XML_VALUE} , beanClass = BookRepository.class, beanMethod = "findAll"),
		@RouterOperation(path = "/books/{author}", beanClass = BookRepository.class, beanMethod = "findByAuthor",
				operation = @Operation(operationId = "findByAuthor"
						,parameters = { @Parameter(in = ParameterIn.PATH, name = "author")})) })
RouterFunction<?> routes(BookRepository br) {
	return
			route(GET("/books").and(accept(MediaType.APPLICATION_JSON)).and(accept(MediaType.APPLICATION_XML)), req -> ok().body(br.findAll(), Book.class))
					.and(route(GET("/books").and(accept(MediaType.APPLICATION_XML)).and(accept(MediaType.TEXT_PLAIN)), req -> ok().body(br.findAll(), Book.class)))
					.andRoute(GET("/books/{author}"), req -> ok().body(br.findByAuthor(req.pathVariable("author")), Book.class));
}
 

@Bean
public RouterFunction<ServerResponse> upperHeaderRouter() {
    return route()
        .GET("/", request -> {
            String text = request.headers()
                .header("text")
                .get(0)
                .toUpperCase();

            return noContent().header("text", text).build();
        })
        .build();
}
 

private void registerEndpoint(GenericApplicationContext context) {
	context.registerBean(StringConverter.class,
			() -> new BasicStringConverter(context.getBean(FunctionInspector.class), context.getBeanFactory()));
	context.registerBean(RequestProcessor.class,
			() -> new RequestProcessor(context.getBean(FunctionInspector.class),
					context.getBean(FunctionCatalog.class), context.getBeanProvider(JsonMapper.class),
					context.getBean(StringConverter.class), context.getBeanProvider(ServerCodecConfigurer.class)));
	context.registerBean(PublicFunctionEndpointFactory.class,
			() -> new PublicFunctionEndpointFactory(context.getBean(FunctionCatalog.class),
					context.getBean(FunctionInspector.class), context.getBean(RequestProcessor.class),
					context.getEnvironment()));
	context.registerBean(RouterFunction.class,
			() -> context.getBean(PublicFunctionEndpointFactory.class).functionEndpoints());
}
 

@Test
public void noMatch() {
	RouterFunction<ServerResponse> routerFunction = request -> Mono.empty();
	RouterFunctionMapping mapping = new RouterFunctionMapping(routerFunction);
	mapping.setMessageReaders(this.codecConfigurer.getReaders());

	Mono<Object> result = mapping.getHandler(this.exchange);

	StepVerifier.create(result)
			.expectComplete()
			.verify();
}
 

@Bean
RouterFunction<ServerResponse> movieRouterFunction(final MovieHandler handler) {

  return route(GET("/first"), handler::getFirstLike)
      .andRoute(GET("/all"), handler::searchAll)
      .andRoute(GET("/{id}"), handler::getMovie)
      .andRoute(GET("/events/{id}"), handler::eventStream)
      .andRoute(GET("/**"), handler::getMovies)
      ;
}
 

public ServletRegistrationBean routeServlet1(RouterFunction<?> routerFunction) throws Exception {
HttpHandler httpHandler = RouterFunctions.toHttpHandler(routerFunction );
ServletHttpHandlerAdapter servlet = new ServletHttpHandlerAdapter(httpHandler);

     ServletRegistrationBean registrationBean = new ServletRegistrationBean<>(servlet, "/flux" + "/*");
     registrationBean.setLoadOnStartup(1);
     registrationBean.setAsyncSupported(true);
     
 	System.out.println("starts server");		
     return registrationBean;
 }
 

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

/**
 * 暴露6200管理端口
 */
@Override
public void run(ApplicationArguments args) throws Exception {
    RouterFunction manageRouterFunction = RouterFunctions
            .route(RequestPredicates.GET("/ok"), req -> {
                return ServerResponse.ok()
                        .syncBody("online");
            })
            .andRoute(RequestPredicates.GET("/cmd/{line}"), request -> {
                String pathVar = request.pathVariable("line");
                try {
                    if ("down".equals(pathVar)) {
                        refuseRequestService.setRefuseRequest(true);
                    } else if ("up".equals(pathVar)) {
                        refuseRequestService.setRefuseRequest(false);
                    }
                    return ServerResponse.ok().body(Mono.just("ok"), String.class);
                } catch (Throwable e) {
                    LOGGER.error("{} request err!", pathVar, e);
                    return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
                }
            });

    HttpHandler handler = RouterFunctions.toHttpHandler(manageRouterFunction);
    int managePort = serverPort - 1000;

    ReactorHttpHandlerAdapter inboundAdapter = new ReactorHttpHandlerAdapter(handler);

    // manage port
    HttpServer.create().port(managePort).handle(inboundAdapter).bind();
    // HttpServer.create(managePort).newHandler(inboundAdapter).block();

    LOGGER.info("management services run on port:{}", managePort);
}
 

@Bean
public RouterFunction<ServerResponse> htmlRouter(@Value("classpath:/public/index.html") Resource html) {
    return route(
            GET("/"),
            request -> ok()
                    .contentType(MediaType.TEXT_HTML)
                    .syncBody(html)
    );
}
 

@Bean
RouterFunction<ServerResponse> route() {
	return RouterFunctions.route()
			.GET("/api/fn/{id}", serverRequest -> ServerResponse.ok()
					.bodyValue(serverRequest.pathVariable("id")))
			.build();
}
 

public ServletRegistrationBean routeServlet1(RouterFunction<?> routerFunction) throws Exception {
HttpHandler httpHandler = RouterFunctions.toHttpHandler(routerFunction );
ServletHttpHandlerAdapter servlet = new ServletHttpHandlerAdapter(httpHandler);

     ServletRegistrationBean registrationBean = new ServletRegistrationBean<>(servlet, "/flux" + "/*");
     registrationBean.setLoadOnStartup(1);
     registrationBean.setAsyncSupported(true);
     
 	System.out.println("starts server");		
     return registrationBean;
 }
 

@Bean
public RouterFunction<ServerResponse> routes(PostHandler postController) {
    return route(GET("/posts"), postController::all)
        .andRoute(POST("/posts"), postController::create)
        .andRoute(GET("/posts/{id}"), postController::get)
        .andRoute(PUT("/posts/{id}"), postController::update)
        .andRoute(DELETE("/posts/{id}"), postController::delete);
}