SpringWebflux(基于函数式编程模型)

(1)在使用函数式编程模型操作时候，需要自己初始化服务器
(2)基于函数式编程模型时候，有两个核心接口：RouterFunction(实现路由功能，请求转发给对应的handler)和HandlerFunction(处理请求生成响应的函数)。核心任务定义两个函数式接口的实现并且启动需要的服务器。
(3)SpringWebflux请求和响应不再是ServletRequest和ServletResponse,而是ServerRequest ServerResponse

第一步：把注解编程模型工程复制一份，保留entity和service内容
第二步：创建Handler(具体实现方法)

public class Userhandler {
 
    private final UserService userService;
 
    public Userhandler(UserService userService){
        this.userService = userService;
    }
 
    //根据id查询
    public Mono<ServerResponse> getUserById(ServerRequest request){
        //获取id值
        Integer id = Integer.valueOf(request.pathVariable("id"));
        //空值处理
        Mono<ServerResponse> notFound = ServerResponse.notFound().build();
        //调用sever方法得到数据
        Mono<User> userMono = this.userService.getUserById(id);
        //把 userMono 进行转换返回--其中一种写法，可以用下面查询所有写法
        //使用 Reactor操作符 flatMap
       return userMono.flatMap(person ->
            ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                    .body(fromObject(person))
                    ).switchIfEmpty(notFound);
    }
 
    //查询所有
    public Mono<ServerResponse> getAll(ServerRequest request){
        //调用sevice得到结果
        Flux<User> users = this.userService.getAll();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }
 
    //添加
    public Mono<ServerResponse> saveUser(ServerRequest request){
        //得到user对象
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.saveUser(userMono));
    }
}

				

					
				
				

					
				
				

					
				
				

					
				
			

第三步：初始化服务器，编写Router
创建路由的方法

  //1 创建 Router 路由
    public RouterFunction<ServerResponse> routerFunction(){
 
        UserService userService = new UserServiceImpl();
 
        Userhandler userhandler = new Userhandler(userService);
        //设置路由
        return RouterFunctions.route(
                GET("/user/{id}").and(accept(APPLICATION_JSON)),userhandler::getUserById)
                .andRoute(GET("/users").and(accept(APPLICATION_JSON)),userhandler::getAll);
    }

				

					
				
				

					
				
				

					
				
				

					
				
			

创建服务器完成适配

    //2 创建服务器 完成适配
    public void createReactorServer(){
        //路由和handler适配
        RouterFunction<ServerResponse> router = routerFunction();
        HttpHandler httpHandler = toHttpHandler(router);
 
        ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
 
        //创建服务器
        HttpServer httpServer = HttpServer.create();
        httpServer.handle(adapter).bindNow();
 
    }

				

					
				
				

					
				
				

					
				
				

					
				
			

最终调用

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

				

					
				
				

					
				
				

					
				
				

					
				
			

(4)使用WebClient调用

public class Client {
 
    public static void main(String[] args) {
        //调用服务器地址
        WebClient webClient = WebClient.create("http://127.0.0.1:51879");
        //根据id查询
        String id = "1";
        User user = webClient.get().uri("/user/{id}", id)
                .accept(MediaType.APPLICATION_JSON).retrieve()
                .bodyToMono(User.class).block();
 
        System.out.println(user.getName());
 
        //查询所有
        Flux<User> userFlux = webClient.get().uri("/users")
                .accept(MediaType.APPLICATION_JSON).retrieve()
                .bodyToFlux(User.class);
        userFlux.map(stu -> stu.getName()).buffer().doOnNext(System.out::println).blockFirst();
    }
}