安科网

Spring WebFlux 入门

方志朋

方志朋

2020-03-27

关注 关注

1. WebFlux介绍

Spring WebFlux 是 Spring Framework 5.0中引入的新的响应式web框架。与Spring MVC不同，它不需要Servlet API，是完全异步且非阻塞的，并且通过Reactor项目实现了Reactive Streams规范。

Spring WebFlux 用于创建基于事件循环执行模型的完全异步且非阻塞的应用程序。

（PS：所谓异步非阻塞是针对服务端而言的，是说服务端可以充分利用CPU资源去做更多事情，这与客户端无关，客户端该怎么请求还是怎么请求。）

Reactive Streams是一套用于构建高吞吐量、低延迟应用的规范。而Reactor项目是基于这套规范的实现，它是一个完全非阻塞的基础，且支持背压。Spring WebFlux基于Reactor实现了完全异步非阻塞的一套web框架，是一套响应式堆栈。

【spring-webmvc + Servlet + Tomcat】响应式的、异步非阻塞的

【spring-webflux + Reactor + Netty】命令式的、同步阻塞的

Spring WebFlux 入门

2. Spring WebFlux Framework

Spring WebFlux有两种风格：功能性和基于注释的。基于注释的与Spring MVC非常相近。例如：

@RestController
@RequestMapping("/users")
public class MyRestController {

    @GetMapping("/{user}")
    public Mono<User> getUser(@PathVariable Long user) {
    // ...
    }

    @GetMapping("/{user}/customers")
    public Flux<Customer> getUserCustomers(@PathVariable Long user) {
    // ...
    }
    
    @DeleteMapping("/{user}")
    public Mono<User> deleteUser(@PathVariable Long user) {
    // ...
    }
} 

与之等价，也可以这样写：

@Configuration
public class RoutingConfiguration {
    @Bean
    public RouterFunction<ServerResponse> monoRouterFunction(UserHandler userHandler) {
        return route(GET("/{user}").and(accept(APPLICATION_JSON)), userHandler::getUser)
            .andRoute(GET("/{user}/customers").and(accept(APPLICATION_JSON)), userHandler::getUserCustomers)
            .andRoute(DELETE("/{user}").and(accept(APPLICATION_JSON)), userHandler::deleteUser);
    }
}

@Component
public class UserHandler {
    public Mono<ServerResponse> getUser(ServerRequest request) {
    // ...
    }
    public Mono<ServerResponse> getUserCustomers(ServerRequest request) {
    // ...
    }
    public Mono<ServerResponse> deleteUser(ServerRequest request) {
    // ...
    }
}

如果你同时添加了spring-boot-starter-web和spring-boot-starter-webflux依赖，那么Spring Boot会自动配置Spring MVC，而不是WebFlux。你当然可以强制指定应用类型，通过SpringApplication.setWebApplicationType(WebApplicationType.REACTIVE) 

3. Hello WebFlux

pom.xml

<?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.2.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cjs.example</groupId>
    <artifactId>cjs-reactive-rest-service</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cjs-reactive-rest-service</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <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>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-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>

GreetingHandler.java 

package com.cjs.example.restservice.hello;

import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import java.util.concurrent.atomic.AtomicLong;

/**
 * @author ChengJianSheng
 * @date 2020-03-25
 */
@Component
public class GreetingHandler {

    private final AtomicLong counter = new AtomicLong();

    /**
     * A handler to handle the request and create a response
     */
    public Mono<ServerResponse> hello(ServerRequest request) {
        return ServerResponse.ok().contentType(MediaType.TEXT_PLAIN)
                .body(BodyInserters.fromValue("Hello, Spring!"));

    }
}

GreetingRouter.java

package com.cjs.example.restservice.hello;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.*;

/**
 * @author ChengJianSheng
 * @date 2020-03-25
 */
@Configuration
public class GreetingRouter {

    /**
     * The router listens for traffic on the /hello path and returns the value provided by our reactive handler class.
     */
    @Bean
    public RouterFunction<ServerResponse> route(GreetingHandler greetingHandler) {
        return RouterFunctions.route(RequestPredicates.GET("/hello").and(RequestPredicates.accept(MediaType.TEXT_PLAIN)), greetingHandler::hello);
    }
}

GreetingWebClient.java

package com.cjs.example.restservice.hello;

import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.client.ClientResponse;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

/**
 * @author ChengJianSheng
 * @date 2020-03-25
 */
public class GreetingWebClient {

    /**
     * For reactive applications, Spring offers the WebClient class, which is non-blocking.
     *
     * WebClient can be used to communicate with non-reactive, blocking services, too.
     */
    private WebClient client = WebClient.create("http://localhost:8080");

    private Mono<ClientResponse> result = client.get()
            .uri("/hello")
            .accept(MediaType.TEXT_PLAIN)
            .exchange();

    public String getResult() {
        return ">> result = " + result.flatMap(res -> res.bodyToMono(String.class)).block();
    }
}

Application.java

package com.cjs.example.restservice;

import com.cjs.example.restservice.hello.GreetingWebClient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/**
 * @author ChengJianSheng
 * @date 2020-03-25
 */
@SpringBootApplication
public class CjsReactiveRestServiceApplication {

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

        GreetingWebClient gwc = new GreetingWebClient();
        System.out.println(gwc.getResult());
    }

} 

可以直接在浏览器中访问 http://localhost:8080/hello  

GreetingRouterTest.java

package com.cjs.example.restservice;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.context.junit.jupiter.SpringExtension;
import org.springframework.test.web.reactive.server.WebTestClient;

@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class GreetingRouterTest {

    @Autowired
    private WebTestClient webTestClient;

    /**
     * Create a GET request to test an endpoint
     */
    @Test
    public void testHello() {
        webTestClient.get()
                .uri("/hello")
                .accept(MediaType.TEXT_PLAIN)
                .exchange()
                .expectStatus().isOk()
                .expectBody(String.class).isEqualTo("Hello, Spring!");
    }

}

4. Reactor 核心特性

Mono: implements Publisher and returns 0 or 1 elements

Flux: implements Publisher and returns N elements

Spring WebFlux 入门 

Spring WebFlux 入门 

Spring WebFlux 入门 

5. Spring Data Redis

pom.xml

<?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.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.cjs.example</groupId>
    <artifactId>cjs-webflux-hello</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>cjs-webflux-hello</name>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.8.0</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.67</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>io.projectreactor</groupId>
            <artifactId>reactor-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>

UserController.java

package com.cjs.example.webflux.controller;

import com.alibaba.fastjson.JSON;
import com.cjs.example.webflux.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveHashOperations;
import org.springframework.data.redis.core.ReactiveStringRedisTemplate;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Mono;

/**
 * @author ChengJianSheng
 * @date 2020-03-27
 */
@RestController
@RequestMapping("/users")
public class UserController {


    @Autowired
    private ReactiveStringRedisTemplate reactiveStringRedisTemplate;

    @GetMapping("/hello")
    public Mono<String> hello() {
        return Mono.just("Hello, Reactive");
    }

    @PostMapping("/save")
    public Mono<Boolean> saveUser(@RequestBody User user) {
        ReactiveHashOperations hashOperations = reactiveStringRedisTemplate.opsForHash();
        return hashOperations.put("USER_HS", String.valueOf(user.getId()), JSON.toJSONString(user));
    }

    @GetMapping("/info/{id}")
    public Mono<User> info(@PathVariable Integer id) {
        ReactiveHashOperations reactiveHashOperations = reactiveStringRedisTemplate.opsForHash();
        Mono<String> hval = reactiveHashOperations.get("USER_HS", String.valueOf(id));
        return hval.map(e->JSON.parseObject(e, User.class));
    }

}

CoffeeController.java

package com.cjs.example.webflux.controller;

import com.cjs.example.webflux.domain.Coffee;
import org.springframework.data.redis.core.*;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * Spring WebFlux is the new reactive web framework introduced in Spring Framework 5.0.
 * Unlike Spring MVC, it does not require the Servlet API, is fully asynchronous and non-blocking,
 * and implements the Reactive Streams specification through the Reactor project.
 *
 * @author ChengJianSheng
 * @date 2020-03-27
 */
@RestController
@RequestMapping("/coffees")
public class CoffeeController {

    private final ReactiveRedisOperations<String, Coffee> coffeeOps;

    public CoffeeController(ReactiveRedisOperations<String, Coffee> coffeeOps) {
        this.coffeeOps = coffeeOps;
    }

    @GetMapping("/getAll")
    public Flux<Coffee> getAll() {
        return coffeeOps.keys("*").flatMap(coffeeOps.opsForValue()::get);
    }

    @GetMapping("/info/{id}")
    public Mono<Coffee> info(@PathVariable String id) {
        ReactiveValueOperations valueOperations = coffeeOps.opsForValue();
        return valueOperations.get(id);
    }
} 

最后，也是非常重要的一点：异步非阻塞并不会使程序运行得更快。WebFlux 并不能使接口的响应时间缩短，它仅仅能够提升吞吐量和伸缩性。

Spring WebFlux 是一个异步非阻塞的 Web 框架，所以，它特别适合应用在 IO 密集型的服务中，比如微服务网关这样的应用中。

Reactive and non-blocking generally do not make applications run faster.

6. Docs

https://spring.io/ 

https://spring.io/reactive 

https://projectreactor.io/docs/core/release/reference/index.html

https://projectreactor.io/docs/core/release/reference/index.html#core-features 

https://docs.spring.io/spring/docs/

https://docs.spring.io/spring/docs/5.1.7.RELEASE/spring-framework-reference/index.html

https://docs.spring.io/spring/docs/5.1.7.RELEASE/spring-framework-reference/web-reactive.html#webflux

https://docs.spring.io/spring/docs/5.1.7.RELEASE/spring-framework-reference/web-reactive.html#webflux-reactive-spring-web

https://www.cnblogs.com/diegodu/p/8794857.html

spring框架

方志朋

方志朋

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

关于使用IDEA的springboot框架往Redis里写入数据乱码问题

解决方法：在你RedisUtil类里加入下图红框的的代码，

vapaad 2020-10-22

一个90后女孩的第一个 Spring Boot 应用

本文转载自微信公众号「小明菜市场 」，作者小明菜市场。Spring Boot的出现，主要是用来解决 Spring 过去的一些问题，提出了约定优于配置的思想，默认对很多方法进行了设置，使得开发者可以快速的构建项目，集成第三方的内容。使得开发效率大大提升。S

与卿画眉共浮生 2020-11-13

Spring Batch真是个优秀的批处理框架，用完爱不释手！

Spring Batch是一个轻量级的、完善的批处理框架，作为Spring体系中的一员，它拥有灵活、方便、生产可用的特点。在应对高效处理大量信息、定时处理大量数据等场景十分简便。结合调度框架能更大地发挥Spring Batch的作用。Batch Core核

smalllove 2020-11-03

详解 | Spring Boot 核心的 3 个注解详解

本文转载自微信公众号「小明菜市场」，作者小明菜市场 。Spring Boot 最大的特点是无需 XML 配置文件，能够实现自动装配，并进行全自动化的jar包配置。Spring Boot 是微服务的核心，其Spring Cloud 是基于Spring Bo

hellowordmonkey 2020-11-02

SpringBoot Web 应用源码解析：综合实战和整体总结

关于 Web 方面的配置比较多，值得庆幸的是，Spring Boot 已经帮我们预置初始化了很多基础组件。但在实践的过程中，某些基础的组件并不能满足我们的实际需求,这时就需要我们重新初始化相应组件，甚至在某些极端的情况下需要完全接管 Spring Boot

丽丽 2020-10-30

Spring和SpringBoot最核心的3大区别，详解！

对于 Spring和 SpringBoot到底有什么区别，我听到了很多答案，刚开始迈入学习 SpringBoot的我当时也是一头雾水，随着经验的积累、我慢慢理解了这两个框架到底有什么区别，相信对于用了 SpringBoot很久的同学来说，还不是很理解 Sp

周太郎 2020-10-28

Java开发人员必知的常用类库，这些你都知道吗？

作为一名程序员，我们要避免重复发明轮子，尽可能使用一些成熟、优秀、稳定的的第三方库，站在巨人的肩膀上搭建可靠、稳定的系统。Spring框架为现代基于Java的企业应用程序提供了一个全面的编程和配置模型，使用开发基于Java语言的应用更加简单、便捷。Spri

greensomnuss 2020-10-27

Spring框架里注解@Autowired的工作原理

Suppose I have a bean named HelloWorld which has a member attribute points to another bean User.With annotation @Autowired, as l

职业炮灰 2020-10-16

一个快速找到Spring框架是在哪里找到XML配置文件并解析Beans定义的小技巧

The line 399 where exception is raised will be automatically located. The core logic to load xml file is just near the exception

与卿画眉共浮生 2020-10-14

Java程序员不能错过的7个基本框架

现在IT开发人员面对的较大挑战就是复杂性，构建的应用越来越复杂。今天给大家列出Java程序员不能错过的7个基本框架，或许会对你有帮助哦。Hibernate是优秀的Java持久性框架，是一个开放源代码的对象关系映射框架，它对 JDBC 进行轻量级的对象封装，

feinifi 2020-10-14

Java开发人员应该学习的5个基本框架

Spring，Hibernate，Spring Boot，Spring Security和Spring Cloud是最重要的Java框架。Java开发人员，您好，如果您正在考虑应该学习哪种框架以成为完整的开发人员，那么您来对地方了。尽管有数十种Java框架

feinifi 2020-10-13

SpringBoot的设计理念和目标、整体架构你有深入了解吗

读者可根据日常习惯，选择熟悉的代码阅读 I 具，比如 Intellij IDEA、Spring Tool Suite、Eclipse、 MyEclipse 等。阅读 Spring Boot 源代码之前，我们还需搭建基础阅读环境。Spring Boot 对

yangjinpingc 2020-10-09

聊一下简易版的“Spring Boot”写的咋样了

昨天早上，6 点多一点就起来写代码了，前天晚上和朋友一起吃晚饭回来之后也搞到很晚，有时候想尽快把某些东西写完的时候确实是会这样。但是，说实话效率会降低很多，不推荐这样做。像我之前写guide-rpc-framework[1] 的时候，经常周末不出门，一坐

davis 2020-09-29

摊牌了！我要手写一个“Spring Boot”

本文转载自微信公众号「JavaGuide」，作者Guide哥。我们经常会对自己早期写的代码感觉恶心，这是导致很多项目烂尾的很重要的一个原因之一。自己沉淀的知识更多，对于某个知识点的理解更加深刻。所以，最近几个月我一直抽空对 JavaGuide 上早期的一些

RickyIT 2020-09-27

Spring Boot：企业常用的Starter以及实现

Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Boot致力于在蓬勃发展的快速应用开发领域成为

lisongchuang 2020-09-27

烂了大街的 Spring 循环依赖问题，你以为自己就真会了吗

初学 Spring 的时候，我们就知道 IOC，控制反转么，它将原本在程序中手动创建对象的控制权，交由 Spring 框架来管理，不需要我们手动去各种 new XXX。所谓的循环依赖是指，A 依赖 B，B 又依赖 A，它们之间形成了循环依赖。在 Spri

tangxiong0 2020-09-03

最火热的极速开发框架Spring Boot-蛙课网

Spring Boot请添加链接描述是Spring家族中的一个全新的框架，它用来简化Spring应用程序的创建和开发过程，也可以说Spring Boot能简化我们之前采用Spring mvc + Spring + MyBatis 框架进行开发的过程；在以往

meleto 2020-08-17

Spring Boot 2.x基础教程：使用集中式缓存Redis

之前我们介绍了两种进程内缓存的用法，包括Spring Boot默认使用的ConcurrentMap缓存以及缓存框架EhCache。虽然EhCache已经能够适用很多应用场景，但是由于EhCache是进程内的缓存框架，在集群模式下时，各应用服务器之间的缓存都

幸运小侯子 2020-08-14

Java最全面试题之Spring篇

大家好，我是Java最全面试题库的提裤姐，今天这篇是JavaEE面试题系列的第三篇，主要总结了Spring相关的问题，在后续，会沿着第一篇开篇的知识线路一直总结下去，做到日更！如果我能做到百日百更，希望你也可以跟着百日百刷，一百天养成一个好习惯。谈谈你对

YangHuiLiang 2020-08-06

Spring Cloud Gateway 网关尝鲜

Spring Cloud Gateway是Spring官方基于Spring 5.0，Spring Boot 2.0和Project Reactor等技术开发的网关，Spring Cloud Gateway旨在为微服务架构提供一种简单而有效的统一的API路由

zmysna 2020-08-03
方志朋

方志朋

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号