十九、Spring5 WebFlux

最新推荐文章于 2024-07-22 20:19:23 发布

逗比小猫

最新推荐文章于 2024-07-22 20:19:23 发布

阅读量488

点赞数 1

分类专栏： Spring 文章标签： springflux spring

本文链接：https://blog.csdn.net/m0_38044453/article/details/122239105

版权

Spring 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

1. SpringWebFlux 介绍

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

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

3. 什么是异步非阻塞

1> 异步和同步

2> 非阻塞和阻塞

上面针对的对象不一样

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

2>如果发送请求之后不等着对方回应就去做其他事情就是异步。

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

4.WebFlux特点

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

第二函数式编程：Spring5 框架基于java8，WebFlux使用java8函数式编程方式实现路由

5. 比较SpringMVC和SpringFlux

第一，两个框架都可以使用注解方式，都运行在tomcat中

第二，SpringMVC采用命令式编程，WebFlux采用异步响应式编程

2.响应式编程

1. 什么是响应式编程

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

2. Java8 及其之前版本

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

package com.study.webflux.reactor8;

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

第一步，引入Reactor

<!-- https://mvnrepository.com/artifact/io.projectreactor/reactor-core -->
		<dependency>
		    <groupId>io.projectreactor</groupId>
		    <artifactId>reactor-core</artifactId>
		    <version>3.4.13</version>
		</dependency>

第二步

package com.study.webflux.reactor8;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

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

}

5. 三种信号特点

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

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

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

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

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

7.操作符

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

第一 map 元素映射为新元素

把一个元素经过处理变为另一个元素

第二 flatMap 元素映射为流

把每个元素转为一个流，然后把转换的流合为一个大流。

3.WebFlux执行流程和核心API

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

SpringWebFlux 基于Reactor，默认容器是netty，Netty是高性能，NIO框架，异步非阻塞框架。

1. Netty

BIO，阻塞方式

NIO，非阻塞

2.SpringWebFlux 执行过程和SpringMVC相似的

SpringWebFlux 核心控制器 DispatchHandler,实现接口 WebHandler。

3.SpringWebFlux 里面DispatcherHandler，负责请求的处理

HanderMapping :请求查询到处理的方法

HanderAdapter：真正负责请求处理

HanderResultHander；响应处理结果

4. SpringWebFlux 实现函数式编程，两个接口：RouuterFunction（路由处理）和HandlerFunction（具体函数，方法）

5.SpringWebFlux(基于注解编程模型)

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

第一步，创建Springboot，引入WebFlux相关依赖

完整如下

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.6.2</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>
	<groupId>com.study</groupId>
	<artifactId>study</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>study</name>
	<description>Demo project for Spring Boot</description>
	<properties>
		<java.version>1.8</java.version>
	</properties>
	<dependencies>
		
		<!-- https://mvnrepository.com/artifact/io.projectreactor/reactor-core -->
		<dependency>
		    <groupId>io.projectreactor</groupId>
		    <artifactId>reactor-core</artifactId>
		    <version>3.4.13</version>
		</dependency>
		
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-webflux</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

第二步，配置启动的端口号

第三步，创建包和相关类

package com.study.webflux.demo.entity;

public class User {
	
	private String name;
	
	private String gender;
	
	private Integer age;

	public User() {
		super();
	}

	public User(String name, String gender, Integer age) {
		super();
		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 + "]";
	}
	
	
	

}

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

package com.study.webflux.demo.service;

import com.study.webflux.demo.entity.User;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface UserService {
	
	Mono<User> getUserById(int id);
	
	Flux<User> getAllUser();
	
	Mono<Void> saveUserInfo(Mono<User> user);

}

实现方法

package com.study.webflux.demo.service.impl;

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

import com.study.webflux.demo.entity.User;
import com.study.webflux.demo.service.UserService;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * 
 * @author Administrator
 *
 */
public class UserServiceImpl implements UserService {

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

	public UserServiceImpl() {
		this.users.put(1, new User("zhangsan", "nan", 18));
		this.users.put(2, new User("lisi", "nan", 19));
		this.users.put(3, new User("wanwu", "nan", 27));
	}

	@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> user) {
		return user.doOnNext(person -> {
			// 向map 集合里面放值
			int id = users.size() + 1;
			users.put(id, person);
		}).thenEmpty(Mono.empty());
	}

}

编写controller

package com.study.webflux.demo.controller;

import javax.annotation.Resource;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

import com.study.webflux.demo.entity.User;
import com.study.webflux.demo.service.UserService;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
public class UserController {
	
	@Resource
	private UserService userService;
	
	@GetMapping("/user/{id}")
	public Mono<User> getUserById(@PathVariable int id) {
		return userService.getUserById(id);
	}
	
	@GetMapping("/user/all")
	public Flux<User> getAllUsers() {
		return userService.getAllUser();
	}
	
	@PostMapping("/user/save")
	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

6. SpringWebFlux(基于函数式编程模型)

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

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

3.SpringWebFlux 请求和响应不再是ServetRequest和ServletResponse，而是ServerRequest和ServerResponse

第一步，之前的service和entity不需要改变，创建handler

package com.study.webflux.demo.handler;

import org.springframework.boot.ApplicationArguments;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;

import com.study.webflux.demo.entity.User;
import com.study.webflux.demo.service.UserService;

import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public class UserHandler {

	private UserService userService;
	
	public UserHandler(UserService userService) {
		this.userService = userService;	
	}
	
	
	/**
	 * 根据id查询用户
	 * @param serverRequest
	 * @return
	 */
	public Mono<ServerResponse> getUserById(ServerRequest serverRequest){
		int userId = Integer.parseInt(serverRequest.pathVariable("id"));
		 Mono<User> userMono = userService.getUserById(userId);
		 
		 // 使用Reactor操作符flatmap转为流
		 return userMono
				 .flatMap(person ->
			 ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(person).switchIfEmpty(ServerResponse.notFound().build())
		 );
	}
	
	/**
	 * 查询所有用户
	 * @return
	 */
	public Mono<ServerResponse> getAllUsers(){
		Flux<User> users = userService.getAllUser();
		return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users, User.class);
	}
	
	/**
	 * 添加对象
	 * @param serverRequest
	 * @return
	 */
	public Mono<ServerResponse> saveUser(ServerRequest serverRequest) {
		
		// 得到user
		Mono<User> userMono = serverRequest.bodyToMono(User.class);
		return ServerResponse.ok().build(userService.saveUserInfo(userMono));
		
	}
	
}

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

package com.study.webflux.demo.server;

import org.springframework.http.MediaType;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
import org.springframework.objenesis.instantiator.android.Android10Instantiator;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;

import com.study.webflux.demo.handler.UserHandler;
import com.study.webflux.demo.service.UserService;
import com.study.webflux.demo.service.impl.UserServiceImpl;

import reactor.netty.http.server.HttpServer;

import static org.springframework.web.reactive.function.server.RequestPredicates.*;
import static org.springframework.web.reactive.function.server.RouterFunctions.toHttpHandler;

public class UserServer {

	public RouterFunction<ServerResponse> routerFunction() {
		UserService userService = new UserServiceImpl();
		UserHandler userHandler = new UserHandler(userService);
		
		return RouterFunctions
		.route(GET("/user/{id}").and(accept(MediaType.APPLICATION_JSON)), userHandler::getUserById)
		.andRoute(GET("/users/all").and(accept(MediaType.APPLICATION_JSON)), userHandler::getAllUsers)
		.andRoute(POST("/user/add"), userHandler::saveUser);
	}
	
	/**
	 * 创建服务器完成适配
	 */
	public void createReactorServer() {

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

}

测试方法

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

4. 使用webclient

package com.study.webflux.demo.client;

import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.WebClient;

import com.study.webflux.demo.entity.User;

import reactor.core.publisher.Flux;

public class UserClient {

	public static void main(String[] args) {
		// 指定调用服务器地址
		WebClient webClient = WebClient.create("http://127.0.0.1:64372");
		
		// 根据id查询1
		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> usFlux = webClient.get().uri("/users/all").accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
		
		usFlux.map(User::getName).buffer().doOnNext(System.out::println).blockFirst();
		
	}
}

逗比小猫

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
十九、Spring5 WebFlux

1. SpringWebFlux 介绍1.是Spring5 添加新的模块，用于web开发的，功能Springmvc类似的，WebFlux使用当前一种比较流行的响应式编程出现的框架。2.使用传统的web框架，比如SpringMVC,这些基于Servlet容器，WebFlux 是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。3. 什么是异步非阻塞1> 异步和同步2> 非阻塞和阻塞...
复制链接

扫一扫