Spring5新功能-Webflux响应式编程

1、SpringWebflux介绍

(1)是Spring5添加新的模块，用于web开发的，功能和springMVC类似的，webflux使用当前一种比较流行响应式编程出现的框架

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

(3)什么是异步非阻塞

异步和同步针对于调用者，调用者发送请求，如果等着对方回应之后才去做其他事情就是同步，如果发送请求之后不等着对方回应就去做其他事情就是异步

阻塞和非阻塞针对于被调用者，被调用者受到请求之后，做完请求任务之后才给出反馈就是阻塞，受到请求之后马上给出反馈然后再去做事情就是非阻塞

(4)Webflux特点

第一非阻塞式：在有限资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程

第二函数式编程：Spring5框架基于Java8，Webflux使用Java8函数时编程方式实现路由请求

(4)Webflux与SpringMVC比较

第一两个框架都可以使用注解方式，都运行在Tomcat的等容器中

第二SpringMVC采用命令式编程，Webflux采用异步响应式编程(重复调用建议采取)

2、响应式编程

(1)什么是响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播

例如：电子表格程序就是一个响应式编程的一个例子。单元格可以包含字面值或类似“=B1+C1”的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化

(2)Java8及其之前版本

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

package com.atguigu.demorector.rector8;

import java.util.Observable;

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

3、响应式编程(Reactor实现)

(1)响应式编程操作中，Reactor是满足Reactive规范框架

(2)Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，提供丰富操作符。Flux对象实现发布者，返回N个元素；Mono实现发布者，返回0或者1个元素

(3)Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据信号：元素值，错误信号，完成信号。错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了，错误信号种植数据流同时把错误信息传递给订阅者

(4)Flux和Mono实例代码

    public static void main(String[] args) {
         //just方法直接声明
        Flux.just(1,2,3,4).subscribe(System.out::print);
        Mono.just(1).subscribe(System.out::print);
        //其他的方法
        Integer[] integers={1,2,3,4};
        Flux.fromArray(integers);

        List<Integer> list= Arrays.asList(integers);
        Flux.fromIterable(list);

        Stream<Integer> stream=list.stream();
        Flux.fromStream(stream);
    }

 

 (5)三种信号特点

错误信号和完成信号都是终止信号，不能共存的

如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流

如果没有错误信号，没有完成信号，表示是无限数据流

(6)调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的

(7)操作符

对数据流进行一道道操作，成为操作符，比如工厂流水线

第一 map元素映射为新元素

第二 flatMap元素映射为流

把每个元素转化为流，把转化之后多个流合并大的流

 

4、 SpringWebflux执行流程和核心API

SpringWebflux基于Reactor，默认使用容器时Netty，Netty是高性能的NIO框架，异步非阻塞的框架

(1)Netty

BIO(阻塞)

 

 NIO(非阻塞)

(2)Springwebflux执行过程和SpringMVC相似

Springwebflux核心控制器DispatchHandler，实现接口WebHandler

接口WebHandler有一个方法

 

 (3)SpringWebflux里面DispatcherHandler,负责请求的处理

HandlerMapping：请求查询到处理的方法

HandlerAdapter：真正负责请求处理

HandlerResultHandler：响应结果处理

(4)SpringWebflux实现函数式编程，两个接口：RouterFunction(路由处理)和HandlerFunction(处理函数)

5、SpringWebflux(基于注解编程模型)

SpringWebflux实现方式有两种：注解编程模型和函数式编程模型

使用注解编程模式方式，和之前SpringMVC使用相似的，只需要把相关依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器

第一步：床架SpringBoot工程，引入相关依赖

 第二步 配置启动端口号

 第三步 创建包和相关类

创建实体类

package com.atguigu.demorector.entity;

public class User {
    private String name;
    private  String gender;
    private Integer 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;
    }

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

    public User() {
    }
}

创建接口定义操作方法

package com.atguigu.demorector.service;

import com.atguigu.demorector.entity.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

//用户操作接口
public interface UserService {
    //一个元素用Mono，多个元素用Flux
//根据id查询用户
    Mono<User> getUserById(int id);
    //查询所有用户
    Flux<User> getAllUser();

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

}

创建接口实现类

package com.atguigu.demorector.service.Impl;

import com.atguigu.demorector.entity.User;
import com.atguigu.demorector.service.UserService;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.HashMap;
import java.util.Map;

public class UserServiceImpl implements UserService {
    //创建map集合存储数据
    private final Map<Integer,User> users=new HashMap<>();
    public UserServiceImpl(){
        this.users.put(1,new User("lucy","男",20));
        this.users.put(2,new User("mary","女",30));
        this.users.put(3,new User("jack","女",50));
    }
    //根据id查询用户
    @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->{
            //向map集合中放值
           int id= users.size()+1;
           users.put(id,person);
        }).thenEmpty(Mono.empty());//终止信号
    }
}

创建controller

package com.atguigu.demorector.controller;

import com.atguigu.demorector.entity.User;
import com.atguigu.demorector.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
public class UserController {
    //注入service
    @Autowired
    private UserService userService;
    //Id查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserById(@PathVariable int id){
       return userService.getUserById(id);
    }

    //查询所有
    @GetMapping("/user")
    public Flux<User> getUsers(){
        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+Temcat

SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty

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

（1）在使用函数式编程模型操作的时候，需要自己初始化服务器

（2）基于函数式编程模型时候，有两个核心接口：RouterFunction（实现路由功能，请求转发给对应的handler）和HandlerFunction(处理请求生成响应的函数)。核心人物定义两个函数式接口的实现并且启动需要的服务器。

（3）SpringWebflux请求和响应不再是ServletRequest和ServletResponse,而是ServerRequest和ServerResponse

第一步创建上述注解方式所需的entity和service

第二部 创建Handler（具体实现方法）