程序员社区

Spring5---新特性(WebFlux)

2022-03-09 分类：未分类 阅读(280)

WebFlux

  • SpringWebflux介绍
  • Webflux特点
  • SpringMvc和Webflux进行比较
  • 响应式编程
    • JAVA代码演示
  • 响应式编程(Reactor实现)
    • 代码演示Flux和Mono
    • 三种信号特点:
    • 调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅后才会触发数据流，不订阅什么都不会发生
    • 操作符
      • map 元素映射为新元素
      • flatmap元素映射为流，每个元素转换为流，把转换之后的多个流合并为一个大流返回
  • SpringWebFlux执行流程和核心API
    • SpringWebflux与SpringWebMvc是相似的
      • 引入webflux对应的启动器
      • SpringWebflux核心控制器DispatchHandler,实现接口WebHandler
      • SpingWebflux实现函数式编程，两个接口： RouterFunction(路由的处理)和HandlerFunction（处理函数）
  • SpringWebflux(基于注解编程模型)
    • 步骤1 ：创建springboot项目，引入上面给出的webflux启动器
    • 步骤2：配置启动端口号
    • 步骤3：创建实体类(Lombok插件)
    • 步骤4：创建service接口
    • 步骤5： 创建service接口的实现类
    • 步骤6：创建controller层
    • 步骤7：测试
    • 说明:
  • SpringWebflux(基于函数式编程模型)
    • 步骤1 : 将上面注解版本的项目复制一份，并删除注解版本里面的controller层
    • 步骤2：controller层替换为Handler层(具体操作)
    • 步骤3：初始化服务器，编写Router
      • 创建路由
      • 创建服务器完成适配
      • 最终调用
      • 完整的服务器类代码
      • 测试:
  • 使用WebCilent进行调用

SpringWebflux介绍

Spring WebFlux是随Spring 5推出的响应式Web框架。

传统的web框架，比如springmvc，这些是基于servlet容器，webflux是一种异步非阻塞的框架，异步非阻塞的框架是在servlet 3.1 以后才支持的，核心是基于Reactor的相关API实现的

在这里插入图片描述

Webflux特点

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

函数式编程,spring5框架基于java8,Webflux使用java8函数式编程方式实现路由请求
在这里插入图片描述

SpringMvc和Webflux进行比较

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

SpringMvc采用命令式编程，WebFlux采用异步响应式编程

响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。对于响应式框架，是基于响应式宣言的理念所产生的编程方式。响应式宣言分为4大理念：

  • 灵敏的：可以快速响应的，只要有任何可能，系统都应该能够尽可能快地做出响应。
  • 可恢复的：系统在运行中可能出现问题，但是能够有很强大的容错机制和修复机制保持响应性。
  • 可伸缩的：在任何负载下，响应式编程都可以根据自身压力变化，请求少时，通过减少资源释放服务器压力，负载大时能够通过扩展算法和软硬件的方式扩展服务压力，以经济实惠的方式实现可伸缩性
  • 消息驱动的：响应式编程存在异步消息机制，事件之间的协作是通过消息进行连接的。

基于这些理念，响应式编程提出了各种模型来满足响应式编程的理念，其中著名的有Reactor和RxJava，Spring5就是基于它们构建WebFlux，而默认情况下它会使用Reactor。

JAVA代码演示

Java8及其之前版本，提供的观察者模式的两个类:Observer和Observerable

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

在这里插入图片描述

响应式编程(Reactor实现)

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

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

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

代码演示Flux和Mono

首先导入Reactor核心包的依赖:

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

编写代码:

        //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);

三种信号特点:

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

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

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

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

        //just方法直接声明相关元素
        //subscribe(Consumer<? super T> consumer)
        //可以实现该函数式接口
     Flux.just(1,2,3,4).subscribe(System.out::println);//订阅
     Mono.just(1).subscribe(System.out::println);

在这里插入图片描述

操作符

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

map 元素映射为新元素

在这里插入图片描述

flatmap元素映射为流，每个元素转换为流，把转换之后的多个流合并为一个大流返回

在这里插入图片描述

SpringWebFlux执行流程和核心API

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

(1)Netty

BIO:阻塞方式

在这里插入图片描述
NIO：
在这里插入图片描述

SpringWebflux与SpringWebMvc是相似的

引入webflux对应的启动器

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

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

在这里插入图片描述
DispatchHandler负责请求的派发

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

HandlerAdapter:真正负责请求处理

handleResultHandler:响应结果处理

SpingWebflux实现函数式编程，两个接口： RouterFunction(路由的处理)和HandlerFunction（处理函数）

SpringWebflux(基于注解编程模型)

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

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

步骤1 ：创建springboot项目，引入上面给出的webflux启动器

步骤2：配置启动端口号

server.port=8081

步骤3：创建实体类(Lombok插件)

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User
{
    String name;
    Integer age;
}

步骤4：创建service接口

UserService：

//用户操作接口
public interface UserService
{
 //根据id查询用户
    //Mono返回0个或1个元素
    public Mono<User>  getUserById(Integer id);
    //查询所有用户
    public Flux<User> getAll();
    //添加用户
    public  Mono<Void> saveUserInfo( Mono<User> userMono);
}

步骤5： 创建service接口的实现类

@Repository
public class UserServiceImpi implements UserService
{
    //创建map集合存储数据---模拟数据库操作
    private  final Map<Integer,User> users=new HashMap<>();

    UserServiceImpi()
    {
     users.put(1,new User("大忽悠1", 18));
     users.put(2,new User("大忽悠2", 19));
     users.put(3,new User("大忽悠3", 20));
    }
    //根据id查询
    @Override
    public Mono<User> getUserById(Integer id) {
        return Mono.justOrEmpty(users.get(id));
    }

    @Override
    public Flux<User> getAll() {
        //返回一个集合
        return Flux.fromIterable(users.values());
    }

    //模拟保存用户到数据库
    @Override
    public Mono<Void> saveUserInfo(Mono<User> userMono) {
       //这里提供一个Consumer函数式接口，即提供给我们一个User类的对象，我们可以对该对象进行消费处理
        return userMono.doOnNext(u->{
          //往map集合里面放值
            int id=users.size()+1;
            users.put(id,u);
      }).thenEmpty(Mono.empty());//结束数据流(终止信号)
    }
}

步骤6：创建controller层

@RestController
public class UserController
{
    //注入service
    @Autowired
    private UserService userService;

    //id查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserById(@PathVariable Integer id)
    {
        return userService.getUserById(id);
    }
    //查询所有
    @GetMapping("/user")
            public Flux<User> getUsers()
    {
        return userService.getAll();
    }
    //添加
    @PostMapping("/saveuser")
    //@RequestBody:将前端的json字符串封装为指定对象
    public Mono<Void> saveUser(@RequestBody User user)
    {
           Mono<User> userMono=Mono.just(user);
           return userService.saveUserInfo(userMono);
    }
}

步骤7：测试

在这里插入图片描述
在这里插入图片描述

说明:

SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat

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

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

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

2.基于函数式编程模式的时候，有两个核心接口

RouterFunction(实现路由功能，请求转发给对应的handler)

HandlerFunction(处理请求生成响应的函数)

核心任务定义两个函数式接口的实现并且启动需要的服务器

3.SpringWebflux请求和响应不在是ServletRequest和ServletResponse

而是ServerRequest和ServerResponse

在这里插入图片描述

步骤1 : 将上面注解版本的项目复制一份，并删除注解版本里面的controller层

步骤2：controller层替换为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(ServerRequest request)
    {
        //调用service得到结果
        Flux<User> users = 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.saveUserInfo(userMono));
    }
}

步骤3：初始化服务器，编写Router

创建路由

public class Server
{
    //1.创建router路由
    public RouterFunction<ServerResponse> responseRouterFunction()
    {
        //创建handler对象
        UserService userService = new UserServiceImpi();
        UserHandler handler = new UserHandler(userService);
        //设置路由
        return RouterFunctions.
                route(GET("/user/{id}").
                        and(accept(APPLICATION_JSON)), handler::getUserById).
                andRoute(GET("/user").and(accept(APPLICATION_JSON)), handler::getAllUsers);
    }
}

创建服务器完成适配

    //创建服务器完成适配
    public void createReactorServer()
    {
        //路由和Hander适配
        RouterFunction<ServerResponse> route=responseRouterFunction();
        HttpHandler httpHandler=  toHttpHandler(route);
        ReactorHttpHandlerAdapter adapter=new ReactorHttpHandlerAdapter
                (httpHandler);

        //创建服务器
        HttpServer httpServer=HttpServer.create();
        httpServer.handle(adapter).bindNow();
    }

最终调用

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

完整的服务器类代码

public class Server
{
    public static void main(String[] args) throws IOException {
        Server server=new Server();
        server.createReactorServer();
        System.out.println("enter to exit");
        System.in.read();
    }
    //1.创建router路由
    public RouterFunction<ServerResponse> responseRouterFunction()
    {
        //创建handler对象
        UserService userService = new UserServiceImpi();
        UserHandler handler = new UserHandler(userService);
        //设置路由
        return RouterFunctions.
                route(GET("/user/{id}").
                        and(accept(APPLICATION_JSON)), handler::getUserById).
                andRoute(GET("/user").and(accept(APPLICATION_JSON)), handler::getAllUsers);
    }
    //创建服务器完成适配
    public void createReactorServer()
    {
        //路由和Hander适配
        RouterFunction<ServerResponse> route=responseRouterFunction();
        HttpHandler httpHandler=  toHttpHandler(route);
        ReactorHttpHandlerAdapter adapter=new ReactorHttpHandlerAdapter
                (httpHandler);

        //创建服务器
        HttpServer httpServer=HttpServer.create();
        httpServer.handle(adapter).bindNow();
    }
}

测试:

在这里插入图片描述

在这里插入图片描述

使用WebCilent进行调用

public class Cilent
{
    public static void main(String[] args) {
        //调用服务器之前，对应服务器要先启动起来，因为默认使用随机的端口号，因此我们每一次启动对应的服务器
        //下次再连接时，都需要对端口号进行修改
        //调用服务器的地址
        WebClient webClient = WebClient.create("http://localhost:61546");
        //根据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("/user").accept(MediaType.APPLICATION_JSON).
                retrieve().bodyToFlux(User.class);
        userFlux.map(s->s.getName()).buffer().doOnNext(System.out::println).blockFirst();
    }
}

在这里插入图片描述

赞(0) 打赏
未经允许不得转载：IDEA激活码 » Spring5---新特性(WebFlux)

相关推荐

  • 暂无文章

IDEA永久激活破解教程,IDEA激活码

pycharm激活破解教程,pycharm激活码

Java视频资源

Java电子书

DataGrip激活教程 Docker Git教程 IntellIJ idea IntelliJ IDEA激活码 Java Java IO Java基础 Java基础面试题 Java集合面试题 Java面试题 JVM JVM面试题 Linux MySQL MySQL面试题 Nginx PyCharm PyCharm激活 redis Redis SpringBoot SpringBoot SpringBoot面试题 Web开发 剑指Offer系列 多线程 多线程并发面试题 字符串面试题 数据库 数据库 数据结构与算法 未分类 爬虫 电子书 软件下载

一个分享Java & Python知识的社区