Spring的webFlux

1.SpringWebFlux介绍

官方文档：https://docs.spring.io/spring-framework/docs/current/reference/html/web-reactive.html

1.1简介

是Spring5添加新的模块，用于web开发的，功能和SpringMVC类似的，WebFlux使用当前一种比较流行的响应式编程出现的框架。使用场景，SpringCloud中的网关。

1.2描述

使用传统web框架，比如SpringMVC，这些基于Servlet容器，WebFlux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。

1.3什么是异步非阻塞

• 异步同步
• 非阻塞和阻塞
• 上面都是针对对象不一样
• 异步和同步针对调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步。土一点说，同步就是打过招呼后等待的时候啥都不干，异步就是打过招呼后就去干其他事情了。
• 阻塞和非阻塞针对被调用者，被调用者收到请求之后，做完请求任务之后才给出反馈就是阻塞，收到请求之后，马上给出反馈，然后去做事情就是非阻塞。土一点说，阻塞就是，先去做，做完后再说，非阻塞就是先说什么时候能做完，然后再去做。

1.4WebFlux特点

第一 非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程。
第二 函数式编程：Spring5框架基于java8，WebFlux使用Java8函数式编程方式实现路由请求

1.5比较SpringMVC

• 两个框架都可以使用注解方式，都运行在Tomcat等容器中
• SpringMVC采用命令式编程，WebFlux采用异步响应式编程

2.响应式编程

2.1 什么是响应式编程

简称RP（Reactive Programming）
响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

2.2Java8及其之前版本

• 提供的观察者模式两个类，Observer和Observable

public static void main(String[] args) {
        ObserverDemo observer = new ObserverDemo();
        //添加观察者
        observer.addObserver((o,arg) -> {
            System.out.println("发生变化");
        });
        observer.addObserver((o,arg)->{
            System.out.println("被观察者通知准备改变");
        });
        observer.setChanged();//数据变化
        observer.notifyObservers();//通知
    }

2.3响应式编程（Reactor实现）

(1)响应式编程操作中，Reactor式满足Reactive规范
（2）Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，提供丰富操作符。Flux对象实现发布者，返回N个元素；Mono实现发布者，返回0或者一个元素
(3)Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：元素值、错误信号、完成信号，错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号终止数据流同时把错误信息传递给订阅者。
（4）代码演示Flux和Mono
第一步 引入依赖

<!-- 响应式编程Flux 之Reactor -->
		<dependency>
			<groupId>io.projectreactor</groupId>
			<artifactId>reactor-core</artifactId>
			<version>3.4.11</version>
		</dependency>

第二步 编写代码

//just方法直接声明
        Flux.just(1,2,3,4).subscribe(System.out::println);
        Mono.just(1).subscribe(System.out::println);

        //其他的方法
        //数组
        Integer[] arrays = {1,2,3,4};
        Flux.fromArray(arrays);

        //集合
        List<Integer> lsit = Arrays.asList(arrays);
        Flux.fromIterable(lsit);

        //stream流
        Stream<Integer> stream = lsit.stream();
        Flux.fromStream(stream);

（5）三种信号特点

• 错误信号和完成信号都是终止信号，不能共存
• 如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流
• 如果没有错误信号，没有完成信号，表示是无限数据流

3.SpringWebFlux执行流程和核心API

SpringWebFlux基于Reactor，默认使用容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架
（1）Netty
BIO 阻塞

NIO非阻塞

（2）SpringWebflux执行过程和SpringMVC相似的

• SpringWebflux核心控制器DispatchHandler，实现接口WebHandler
• 接口WebHandler有一个方法

//ServerWebExchange 存放http请求响应信息
public Mono<Void> handle(ServerWebExchange exchange) {
        if (this.handlerMappings == null) {
            return this.createNotFoundError();
        } else {
            return CorsUtils.isPreFlightRequest(exchange.getRequest()) ? this.handlePreFlight(exchange) : Flux.fromIterable(this.handlerMappings).concatMap((mapping) -> {
                return mapping.getHandler(exchange);//根据请求地址获取对应mapping
            }).next().switchIfEmpty(this.createNotFoundError()).flatMap((handler) -> {
                return this.invokeHandler(exchange, handler);//调用具体的业务方法
            }).flatMap((result) -> {
                return this.handleResult(exchange, result);//处理结果返回
            });
        }
    }

（3）SpringWebflux里面DispatcherHandler，负责请求的处理

• HandlerMapping：请求查询到处理的方法
• HandlerAdapter：真正负责请求处理
• HandlerResultHandler：响应结果处理
  (4)SpringWebflux实现函数式编程，两个接口：RouterFunction(路由处理)和HandlerFunction（处理函数）

4.SpringWebFlux（基于注解编程模型）

SpringWebflux实现方式有两种：注解编程模型和函数式编程模型
使用注解编程模型方式，和之前SpringMVC使用相似的，只需要把相关依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器。
第一步 创建SpringBoot工程，引入webFlux依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

第二步 配置启动端口号

server.port=8081

第三步 创建包和相关类

• 实例类

public class User {

    private String name;

    private String gender;

    private Integer age;

    public User() {
    }

    public User(String name, String gender, Integer age) {
        this.name = name;
        this.gender = gender;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", age=" + age +
                '}';
    }
}

• 创建接口定义操作的方法

//用户操作接口
public interface UserService {

    //根据id查询用户
    Mono<User> getUserById(int id);

    //查询所有用户
    Flux<User> getAllUser();

    //添加用户
    Mono<Void> saveUserInfo(Mono<User> user);

}

• 接口实现类

public class UserServiceImpl implements UserService {

    private final Map<Integer,User> users = new HashMap<>();

    public UserServiceImpl() {
        this.users.put(1,new User("张三","男",18));
        this.users.put(1,new User("李四","男",19));
        this.users.put(1,new User("王五","男",20));
    }

    @Override
    public Mono<User> getUserById(int id) {
        return Mono.justOrEmpty(this.users.get(id));
    }

    @Override
    public Flux<User> getAllUser() {
        return Flux.fromIterable(this.users.values());
    }

    @Override
    public Mono<Void> saveUserInfo(Mono<User> userMono) {
        return userMono.doOnNext(person -> {
            int id = users.size() + 1;
            users.put(id,person);
        }).thenEmpty(Mono.empty());
    }
}

• 创建controller

@RestController
public class UserController {

    @Autowired
    private UserService userService;

    @GetMapping("/user/{id}")
    public Mono<User> getUserById(@PathVariable Integer id){
        return userService.getUserById(id);
    }

    @GetMapping("/users")
    public Flux<User> getUserList(){
        return userService.getAllUser();
    }

    @PostMapping("/saveuser")
    public Mono<Void> saveUser(@RequestBody User user){
        Mono<User> userMono = Mono.just(user);
        return userService.saveUserInfo(userMono);
    }
}

• SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat
• SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty