【Spring5-07】Spring5新功能-Webflux

注：这一章节仅仅机械的实现了一遍流程，并不能理解其内部原理

一、Webflux基本概念

1. SpringWebflux介绍
   （1）是Spring5添加的新模块，用于web开发的，功能SpringMVC类似的，Webflux使用当前一种比较流行的响应式编程实现的框架。
   （2）使用传统web框架，比如SpringMVC，这些基于servlet容器，Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现。
   （3）什么是异步非阻塞？
   \quad 异步同步： 针对调用者，调用者发送请求，如果等着对方回应之后才去做其它事情就是同步；如果发送请求之后不等着对方回应就去做其他事情就是异步。
   \quad 非阻塞和阻塞： 针对被调用者，被调用者收到请求之后，做完请求之后才给出反馈就是阻塞，收到请求之后马上给出反馈然后再去做事情就是非阻塞。
   注：上面都是针对对象不一样
   （4）Webflux特点：
   第一、非阻塞式：可以在有限的资源下提高系统吞吐量和伸缩性（即能处理更多请求），以Reactor为基础实现响应式编程。
   第二、函数式编程：Spring5框架基于java8,Webflux使用Java8函数式编程方式实现路由请求。
   （5）比较SpringMVC
   
   第一：上面这两个框架都可以使用注解方式，都运行在Tomcat等容器中
   第二：SpringMVC采用命令式编程，Webflux采用异步响应式编程

二、 响应式编程

1. 什么是响应式编程？
   响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。
   举例：
   电子表格程序就是响应式编程的一个例子。单元格可以包含字面值或类似“=B1+C1"的公式，而包含公式的单元格的值会依据其它单元格的值的变化而变化。
2. Java8及其之前版本
   （1）提供的观察者模式的两个类Observer和Observable
   SpringBoot工程下实现，未自己动手！

public class ObserverDemo extends 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(); //通知
	 }
}

3. Java9之后响应式编程Flow类（这里讲的不明白可能需要SpringMVC、springboot等基础知识？后面章节也有同样问题，所以并没有进行后续实现，后续补充，先挖个坑）

三、 响应式编程（Reactor实现）

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

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

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

4. 代码演示Flux和Mono
   （1）第一步、引入依赖

<dependency>
 <groupId>io.projectreactor</groupId>
 <artifactId>reactor-core</artifactId>
 <version>3.1.5.RELEASE</version>
</dependency>

\quad\quad （2）第二步、编程代码

public static void main(String[] args) {
 //just 方法直接声明
 Flux.just(1,2,3,4);
 Mono.just(1);
 //其他的方法
 Integer[] array = {1,2,3,4};
 Flux.fromArray(array);
 
 List<Integer> list = Arrays.asList(array);
 Flux.fromIterable(list);
 Stream<Integer> stream = list.stream();
 Flux.fromStream(stream);
}

5. 三种信号特点:

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

6. 调用 just 或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生的。
   
7. 操作符
   对数据流进行一道道操作，成为操作符，比如工厂流水线
   （1）第一 map 元素映射未新元素
   

\quad\quad （2）第二 flatMap 元素映射为流
\quad\quad 把每个元素转换流，把转换之后多个流合并大的流（原本的三个值不就是一个大的数据流吗？为什么要分别转换成三个数据流再合并成一个大的数据流？）

四、Webflux执行流程（原理）和核心API

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

1. Netty
   （1）BIO（阻塞方式）
   
   \quad （2）NIO（非阻塞方式）
   
2. SpringWebflux 执行过程和 SpringMVC 相似的
   SpringWebflux核心心控制器 DispatchHandler，实现接口 WebHandler接口WebHandler有一个方法
   
   
3. SpringWebflux 里面 DispatcherHandler，负责请求的处理

• HandlerMapping： 请求查询到处理的方法
• HandlerAdapter： 真正负责请求处理
• HandlerResultHandler： 响应结果处理

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

五、 SpringWebflux（基于注解编程模型）

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

1. 第一步，创建SpringBoot工程，引入Webflux相关依赖

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

第一次创建是springboot工程，这里报错，原因库里没有spring-boot-starter-webflux，选择maven自动导包或者手动下载都可以。

2. 配置启动端口号
   
3. 创建包和相关类
   （1）创建实体类（entity）

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;
    }
}

\quad\quad （2）创建操作接口和实现方法（service)

//用户操作接口
public interface UserService {
    //根据id查询用户
    Mono<User> getUserById(int id);
    
    //查询所有用户
    Flux<User> getAllUser();
    
    //添加用户
    Mono<Void> saveUserInfo(Mono<User> user);
}

//接口实现类
public class UserServiceImpl implements UserService {
    
    //创建map集合存储数据
    private final Map<Integer, User> users = new HashMap();

    public UserServiceImpl() {
        this.users.put(1,new User("lucy","nan",20));
        this.users.put(2,new User("mary","nv",30));
        this.users.put(3,new User("jack","nv",10));
    }

    //根据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()); //终止、结束数据流
    }
}

\quad\quad （3）创建controller（controller)

@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);
    }
}

\quad\quad （4）测试
spring自动配置运行的容器，运行自带的Webfluxdemo1Application类，在浏览器中输入localhost:…地址即可。

@SpringBootApplication
public class Webfluxdemo1Application {

    public static void main(String[] args) {
        SpringApplication.run(Webfluxdemo1Application.class, args);
    }

}

注：编写UserController类时注入接口报错，原因是没有设置注解，只需要要在其实现类添加注解@Repository即可。

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

六、SpringWebflux（基于函数式编程模型）

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

public class UserHandler {

    private final UserService userService;

    public UserHandler(UserService userService) {
        this.userService = userService;
    }

    //根据id查询
    public Mono<ServerResponse> getUserById(ServerRequest request){
        //获取id值
        int userId = Integer.valueOf(request.pathVariable("id"));
        //空值处理
        Mono<ServerResponse> notFound = ServerResponse.notFound().build();
        //调用service方法得到数据
        Mono<User> userMono = this.userService.getUserById(userId);
        //把userMono进行转换返回
        //使用Reactor操作符flatMap(转为流)
        return
                userMono.flatMap(person->ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                        .body(fromObject(person))).switchIfEmpty(notFound);
    }
    
    //查询所有用户
    public Mono<ServerResponse> getAllUsers() {
        //调用 service 得到结果
        Flux<User> users = this.userService.getAllUser();
        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.saveUserInfo(userMono));
    }
}

\quad\quad （3）初始化服务器，编写Router
创建路由的方法：

    //1 创建Router路由
    public RouterFunction<ServerResponse> routingFunction(){
        UserService userService = new UserServiceImpl();
        UserHandler handler = new UserHandler(userService);

        return RouterFunctions.route(
                GET("/users/{id}").and(accept(APPLICATION_JSON)),handler::getUserById)
                .andRoute(GET("/users").and(accept(APPLICATION_JSON)),handler::getAllUsers);
    }

创建服务器完成适配:

    //2 创建服务器完成适配
    public void createReactorServer() {
        //路由和 handler 适配
        RouterFunction<ServerResponse> route = routingFunction();
        HttpHandler httpHandler = toHttpHandler(route);
        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();
    }

5. 使用 WebClient 调用（不用到网页输入地址进行调用）

public class Client {
    public static void main(String[] args) {

        //调用服务器地址
        WebClient webClient = WebClient.create("http://127.0.0.1:53867");

        //根据 id 查询
        String id = "1";
        User userresult = webClient.get().uri("/users/{id}", id)
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class).block();
        System.out.println(userresult.getName());

        //查询所有
        Flux<User> results = webClient.get().uri("/users")
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
        results.map(stu -> stu.getName()).buffer().doOnNext(System.out::println).blockFirst();

    }
}

参考：本篇内容主要为尚硅谷Spring5听课笔记