（1）在使用函数式编程模型操作时候，需要自己初始化服务器
    （2）基于函数式编程模型时候，有两个核心接口：RouterFunction（实现路由功能，请求转发给对应的 handler）和 HandlerFunction（处理请求生成响应的函数）。核心任务定义两个函数式接口的实现并且启动需要的服务器。
    （ 3 ） SpringWebflux 请 求 和 响 应 不 再 是 ServletRequest 和 ServletResponse ，而是ServerRequest 和 ServerResponse
    第一步 把注解编程模型工程复制一份 ，保留 entity 和 service 内容
    第二步 创建 Handler（具体实现方法）

    1. public class UserHandler {
    2.      private final UserService userService;
    3.      public UserHandler(UserService userService) {
    4.          this.userService = userService;
    5.      }
    7.      //根据 id 查询
    8.      public Mono<ServerResponse> getUserById(ServerRequest request) {
    9.          //获取 id 值
    10.          int userId = Integer.valueOf(request.pathVariable("id"));
    12.          //空值处理
    13.          Mono<ServerResponse> notFound = ServerResponse.notFound().build();
    15.          //调用 service 方法得到数据
    16.          Mono<User> userMono = this.userService.getUserById(userId);
    17.          //把 userMono 进行转换返回
    18.          //使用 Reactor 操作符 flatMap
    19.      return userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(fromObject(person))).
    20.          switchIfEmpty(notFound);
    21.      }
    23.      //查询所有
    24.      public Mono<ServerResponse> getAllUsers() {
    26.      //调用 service 得到结果
    27.      Flux<User> users = this.userService.getAllUser();
    28.          return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    29.      }
    31.      //添加
    32.      public Mono<ServerResponse> saveUser(ServerRequest request) {
    33.      //得到 user 对象
    34.      Mono<User> userMono = request.bodyToMono(User.class);
    35.          return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
    36.      } 
    37. }

    第三步 初始化服务器，编写 Router

    • 创建路由的方法

      1. //1 创建 Router 路由
      2. public RouterFunction<ServerResponse> routingFunction() {
      3.   //创建 hanler 对象
      4.   UserService userService = new UserServiceImpl();
      5.   UserHandler handler = new UserHandler(userService);
      6.   //设置路由
      7.   return RouterFunctions.route(
      9.      GET("/users/{id}").and(accept(APPLICATION_JSON)),handler::getUserById)
      10.       .andRoute(GET("/users").and(accept(APPLICATION_JSON)),handler::getAllUsers);
      11. }

    • 创建服务器完成适配

      1. //2 创建服务器完成适配
      2. public void createReactorServer() {
      3.    //路由和 handler 适配
      4.    RouterFunction<ServerResponse> route = routingFunction();
      5.    HttpHandler httpHandler = toHttpHandler(route);
      6.    ReactorHttpHandlerAdapter adapter = new 
      7.   ReactorHttpHandlerAdapter(httpHandler);
      8.    //创建服务器
      9.    HttpServer httpServer = HttpServer.create();
      10.    httpServer.handle(adapter).bindNow();
      11. }

    • 最终调用

      1. public static void main(String[] args) throws Exception{
      2.    Server server = new Server();
      3.    server.createReactorServer();
      4.    System.out.println("enter to exit");
      5.    System.in.read();
      6. }

      （4）使用 WebClient 调用

      1. public class Client {
      2.    public static void main(String[] args) {
      3.        //调用服务器地址
      4.        WebClient webClient = WebClient.create("http://127.0.0.1:5794");
      5.        //根据 id 查询
      6.        String id = "1";
      7.        User userresult = webClient.get().uri("/users/{id}", id).accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class)
      8.        .block();
      9.        System.out.println(userresult.getName());
      11.        //查询所有
      12.        Flux<User> results = webClient.get().uri("/users").accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
      13.        results.map(stu -> stu.getName()).buffer().doOnNext(System.out::println).blockFirst();
      14.    }
      15. }