spring webflux基本使用案例

最新推荐文章于 2024-09-20 14:32:03 发布
最新推荐文章于 2024-09-20 14:32:03 发布
阅读量2.1k 收藏 8
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41063141/article/details/108272347
版权

文章目录

使用案例

引入依赖

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

controller层应用方式

  @RequestMapping("/getAll")
    public Mono<Response> getAll() {
        return Mono.justOrEmpty(Response.success("ok"));
    }
//或者如下（webflux在某些地方兼容springmvc）
@RequestMapping("/getAll")
    public Response getAll() {
        return Response.success("ok");
    }

对于某些文件上传需要这样按下面写，（因为webflux没有MultipartFile，MultipartFile是阻塞式的，webflux是非阻塞式的，二者必然不兼容）

 @PostMapping("/base/file/add")
    public Mono<ServerResponse> uploadDefault(ServerRequest serverRequest) {
        return serverRequest
                .body(BodyExtractors.toMultipartData())
                .log()
                .flatMap(parts -> {
                    return Mono.just((FilePart) 
///*文件上传表单字段名*/
//    String UPLOAD_FILE_FORM_FIELD_NAME = "file"; 
                   parts.toSingleValueMap().get(UPLOAD_FILE_FORM_FIELD_NAME));
                })
                .flatMap(filePart -> {
                  // filePart是 FilePart的对象，它装载着二进制文件
                    return fileService.upload(参数1，2，3);
                });
    }

然后再程序启动时就构造的bean中加入：

  @Bean
    public RouterFunction<ServerResponse> routes(FileController fileController) {
        return   nest(
                path("/base/file"),
                route(POST("/add/{type}"), fileController::upload)
                .andRoute(POST("/add"), fileController::uploadDefault)
                .andRoute(POST("/initMultipartUpload/{type}"), fileController::initMultipartUpload)
                .andRoute(POST("/completeMultipartUpload/{type}"), fileController::completeMultipartUpload)
                .andRoute(POST("/downloadPart"), fileController::downloadPart)
        );
    }

其请求之前的全局拦截器编写如下：

@Slf4j
@Component
public class RequestInfoInjectionFilter implements WebFilter {

    @Autowired
    private FileConfigEntity defaultFileConfigEntity;

    @Autowired
    private FileConfigRepository fileConfigRepository;

    @Value("${auth.header-name}")
    private String authHeaderName;

    @Value("${application.header-name}")
    private String appCodeHeader;


    @Autowired
    private DataBufferWriter dataBufferWriter;

    private final AntPathMatcher antPathMatcher = new AntPathMatcher();


    @SneakyThrows
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        String requestUrl = exchange.getRequest().getURI().toString();
        String reqPath = exchange.getRequest().getPath().toString();
        //解决线上生成日志过大问题
        if (reqPath.equals("/")||reqPath.equals("/favicon.ico")){
           return exchange.getResponse().writeWith(Mono.justOrEmpty(null));
        }
        //只对非健康的检测的请求做拦截处理
        if (!antPathMatcher.match("**/actuator/health", requestUrl)) {
            log.info("requestPath:{}",reqPath);
            HttpHeaders httpHeaders = exchange.getRequest().getHeaders();
            String userId = Optional.ofNullable(httpHeaders
                    .getFirst(authHeaderName)).orElse("");
            RequestUtil.setCurrentUser(User.builder().userId(userId).build());
            String accessFlag = Optional.ofNullable(httpHeaders
                    .getFirst("access-flag")).orElse("1");
            RequestUtil.setCurrentAccessFlag(Integer.parseInt(accessFlag));
            log.warn("inject auth info: current user:{}.",
                    RequestUtil.getCurrentUser());
            String curAppCode = Optional.ofNullable(httpHeaders.getFirst(appCodeHeader))
                    .orElse("default");
            RequestUtil.setCurrentAppCode(curAppCode);
            log.warn("inject auth info: current appCode:{}.",
                    RequestUtil.getCurrentAppCode());
            Long requestBodyEstimateSize = httpHeaders.getContentLength();
            RequestUtil.setCurrentRequestBodySize(requestBodyEstimateSize);
            log.warn("ingect request body size info: estimate value{}.",
                    requestBodyEstimateSize);
            if (!RequestUtil.getCurrentAppCode().equals("default")){
                defaultFileConfigEntity=fileConfigRepository.findByAppCode(curAppCode);
                if (defaultFileConfigEntity==null) throw new OutOfBusinessException("error app-code:"+curAppCode);
            }
            RequestUtil.setCurrenFileConfig(defaultFileConfigEntity);
            Integer allowAnonymousDownload = defaultFileConfigEntity.getAnonDown();
            Integer allowAnonymousUpload = defaultFileConfigEntity.getAnonUpload();
            if (antPathMatcher.match(DOWNLOAD_URL_PATTERN, requestUrl)
                    && !(allowAnonymousDownload==1) && StringUtils.isEmpty(userId)) {
                log.warn("capture un-auth download request{} from{}.", requestUrl,
                        exchange.getRequest().getRemoteAddress());
                return dataBufferWriter.write(exchange.getResponse(), AUTH_FAILED_RESPONSE);
            }

            if (antPathMatcher.match(UPLOAD_URL_PATTERN, requestUrl)
                    && !(allowAnonymousUpload==1)
                    && StringUtils.isEmpty(userId)) {
                log.warn("capture un-auth upload request,{}.", requestUrl);
                return dataBufferWriter.write(exchange.getResponse(), AUTH_FAILED_RESPONSE);
            }
            return chain.filter(exchange).doFinally(signalType -> {
                RequestUtil.clearCurrentUser();
                log.warn("clear auth info.");
                RequestUtil.clearCurrentRequestBodySize();
                log.warn("clear request body size info.");
                RequestUtil.clearCurrenFileConfig();
                log.warn("clear current fileConfig info.");
            });
        }
        return chain.filter(exchange).doFinally(signalType -> {});
    }
}

其他

Spring WebFlux 多次读取 DataBuffer 类型的请求内容
方法一：基于内存缓存 —— 构造新的 DataBuffer 对象

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        final ServerHttpRequest request = exchange.getRequest(); 
        long contentLength = request.getHeaders().getContentLength();

        if (contentLength <= 0) {
            return chain.filter(exchange);
        }

        return DataBufferUtils.join(request.getBody()).map(dataBuffer -> {
            exchange.getAttributes().put("cachedRequestBody", dataBuffer);

            ServerHttpRequest decorator = new ServerHttpRequestDecorator(request) {
                @Override
                public Flux<DataBuffer> getBody() {
                    return Mono.<DataBuffer>fromSupplier(() -> {
                        if (exchange.getAttributeOrDefault("cachedRequestBody", null) == null) {
                            // probably == downstream closed
                            return null;
                        }

                        // reset position
                        dataBuffer.readPosition(0);

                        // deal with Netty
                        NettyDataBuffer pdb = (NettyDataBuffer) dataBuffer;
                        return pdb.factory().wrap(pdb.getNativeBuffer().retainedSlice());
                    }).flux();
                }
            };

            // TODO 消费 dataBuffer，例如计算 dataBuffer 的哈希值并验证
            // ...

            return decorator

        })
        .switchIfEmpty(Mono.just(request))
        .flatMap(req -> chain.filter(exchange.mutate().request(req).build()))
        .doFinally(s -> {
            DataBuffer dataBuffer = exchange.getAttributeOrDefault("cachedRequestBody", null);
            if (dataBuffer != null) {
                DataBufferUtils.release(dataBuffer);
            }
        });
    }

方法二：基于内存缓存 —— byte[]

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        final ServerHttpRequest request = exchange.getRequest(); 
        long contentLength = request.getHeaders().getContentLength();

        if (contentLength <= 0) {
            return chain.filter(exchange);
        }

        final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

        return Mono.create(sink -> {
             DataBufferUtils.write(request.getBody(), outputStream).subscribe(DataBufferUtils::release, sink::error, sink::success);
        })
        .then(Mono.just(request))
        .flatMap(req -> {
            log.debug("缓存大小：{}", outputStream.size());
            final ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(req) {
                @Override
                public Flux<DataBuffer> getBody() {
                    return DataBufferUtils.read(new ByteArrayResource(outputStream.toByteArray()), exchange.getResponse().bufferFactory(), 1024 * 8);
                }
            };

            // TODO 对缓存的 ByteArrayOutputStream 进行处理，例如计算 ByteArrayOutputStream 中 byte[] 的哈希值并验证
            // ...

            return chain.filter(exchange.mutate().request(decorator).build());
        });
    }

方法三：基于文件缓存 —— Path

  @Override
    public Mono<Void> filter(ServerWebExchange exchange, WebFilterChain chain) {
        final ServerHttpRequest request = exchange.getRequest(); 
        long contentLength = request.getHeaders().getContentLength();

        if (contentLength <= 0) {
            return chain.filter(exchange);
        }

        try {
            final Path tempFile = Files.createTempFile("HttpRequest", ".bin");

            return DataBufferUtils.write(request.getBody(), tempFile)
                .then(Mono.just(request))
                .flatMap(req -> {
                    final ServerHttpRequestDecorator decorator = new ServerHttpRequestDecorator(req) {
                        @Override
                        public Flux<DataBuffer> getBody() {
                            return DataBufferUtils.read(tempFile, exchange.getResponse().bufferFactory(), 1024 * 8, StandardOpenOption.READ);
                        }
                    };

                    // TODO 对缓存的 tempFile 进行处理，例如计算 tempFile 的哈希值并验证
                    // ...

                    return chain.filter(exchange.mutate().request(decorator).build());
                })
                .doFinally(s -> {
                    try {
                        Files.deleteIfExists(tempFile);
                    } catch (IOException e) {
                        throw new IllegalStateException(e);
                    }
                });

        } catch (IOException e) {
            throw new IllegalStateException(e);
        }
    }

注：

在请求 body 比较大的情况的测试中，发现调用 DataBufferUtils#join() 方法（方法一）会占用较大的内存，并且请求完毕时可能不会立刻释放，在下一次 GC 时可释放。调用 DataBufferUtils#write() 方法直接写到 OutputStream （方法二）或者临时文件（方法三）时，则不会占用过多内存。

webflux实战增删查改=====视频讲解的是非常好的。

实例文章：写的很好
https://segmentfault.com/q/1010000018526503
在这里插入图片描述
接受json数据还是按照mvc那一套就好了
返回json可以返回对象。
但是对于这种mono的处理方式还有待研究

restfor风格的传参
在这里插入图片描述
数据量很大，建议使用json参数

Mono file.flatMap(s -> {
Flux content = s.content();
// return content;
// 因为它的类型是flux，然而 Mono file.flatMap()的返回类型是mono，
// 所以会报如下错误： no instance(s) of type variable(s) R exist so that flux conforms to mono<? extends R>
// 不存在类型变量R的实例，以至于flux不符合mono<？extends R> 就是当前你返回的值的类型和该函数要求的值的返回类型不兼容
return null;
});


 AtomicInteger a= new AtomicInteger();
      Mono<FilePart> file.flatMap(s -> {
            Flux<DataBuffer> content = s.content();
            content.flatMap(aa->{
                InputStream inputStream = aa.asInputStream();
                System.out.println("hahhaha"); 
                a.set(10);
                  return null;
            });
            return null;
        });
        System.out.println(a.get()+"==============");  //打印结果为0

System.out.println(“hahhaha”);
a.set(10);

  • 这两条语句虽然执行了，但是不会产生任何作用：即不会改变a的值，也不会输出“haha”,因为他们是流里面的中间操作，除非你返回结果，流会将计算结果存入返回值。否则将会丢弃一切计算。
千篇不一律
关注
Spring WebFlux框架 - 简单实例
TyuIn的博客
01-11 1351
下面我们先通过一个简单的 WebFlux 的使用案例，对比正常的 String 返回，Mono<String> 返回 以及 Flux<String> 返回的区别。 首先创建一个简单的 springboot 项目，导入对应的 webflux 依赖，当然为了方便也导入 lombok 的依赖。 <dependency> <groupId>org.springframework.boot</groupId> <artifactId&g
【微服务】spring webflux响应式编程使用详解
congge
10-18 6065
webflux使用详解
三、Spring-WebFlux实战案例-流式
平凡之路无尽路的博客
08-03 1219
为了使用 WebClient 实现流式响应，我们需要在。
Spring WebFlux 案例
m0_37941483的博客
10-23 1068
Spring WebFlux 案例 这个工程是基于Spring Boot + Spring WebFlux实现的完整案例。 我们将有两个子项目： stock-quotes is a functional WebFlux app which streams stock quotes trading-service is an annotation-based WebFlux app using a...
WebFlux入门详解
最新发布
weixin_36873225的博客
09-20 1895
N （）的数据序列。是一个用于 JVM 的完全非阻塞的响应式编程框架，具备高效的需求管理，可以很好的处理 “backpressure”。nest 方法的第二个参数就是 RouterFunction 实例了，每一个 RouterFunction 实例通过 RouterFunctions.route 方法来构建，它的第一个参数就是请求的 URL 地址（注意这个时候配置的地址都是有一个共同的前缀），第二个参数我们通过方法引用的方式配置了一个 HandlerFunction，这个就是当前请求的处理器了。
SpringWebflux的简单Demo
ZULJ131的博客
04-02 1101
webflux 简单demo
spring webflux demo
07-24
体验spring webflux，数据库采用mongodb，写了一个小demo，完成基础的CRUD，包括一些like，between查询，多表查询目前尚不完善有待进一步改进。
Spring WebFlux 介绍与效果演示示例
oscar999的专栏
07-21 307
响应式编程Spring WebFlux 使用响应式编程的理念，其中数据流和异步操作是核心概念。这种编程范式适用于高并发、高吞吐量的场景，允许应用程序以非阻塞的方式处理请求，并有效地利用服务器资源。它使用 Reactor 框架作为响应式编程的核心库，通过事件驱动和异步操作来处理请求和数据流。非阻塞和异步处理Spring WebFlux 支持异步和非阻塞的处理方式，这使得它能够处理高负载的情况，如即时通讯、实时数据推送等。
使用Spring WebFlux和Spring Cloud的反应式微服务
JavaMonsterr的博客
06-29 1094
在Spring5正式发布之后，值得一看它的当前版本。此外，我们将尝试将我们的反应式微服务放在Spring云生态系统中，该生态系统包含诸如Eureka的服务发现、Spring Cloud Commons@LoadBalanced的负载平衡以及使用Spring Cloud gateway的API gateway（也基于WebFlux和Netty）等元素。我们还将通过SpringDatareactiveMongo项目的示例来检查Spring对NoSQL数据库的响应式支持。下图展示了示例系统的体系结构，该体系结构由
Spring WebFlux 框架 - RouterFunction 案例
TyuIn的博客
01-12 1746
在之前的博客，我向大家简单展示了 WebFlux 框架的简单使用，算是有了一个基本的认识，上一次的案例我们使用的是基于注解开发的模式，而其实 WebFlux 还有另外一种写法，基于功能性的模式。其实两种方式都比较接近，下面我们通过编写代码来感受一下。 首先，创建一个简单的 spring boot 项目，导入 WebFlux 依赖以及 为了方便导入 Lombok 依赖，如下： <dependency> <groupId>org.springframework.boot</g
SpringBoot WebFlux系列（一）：使用示例
u013244613的博客
04-10 2471
Why use reactive processing? 关于SpringBoot WebFlux，Spring官网有如下解释很能说明问题： One of the main reasons developers move from blocking to non-blocking code is efficiency. Reactive code does more work with fewer resources. Project Reactor and Spring WebFlux let de
Spring5.0 WebFlux入门及实战示例
SkydivingWang的博客
01-30 1043
什么是 Spring WebFlux WebFlux是Spring推出响应式编程的一部分(web端) 响应式编程是异步非阻塞的(是一种基于数据流（data stream）和变化传递（propagation of change）的声明式（declarative）的编程范式) Spring MVC 构建于 Servlet API 之上，使用的是同步阻塞式 I/O 模型，什么是同步阻塞式 I/O 模型呢？就是说，每一个请求对应一个线程去处理。 Spring WebFlux 是一个异步非阻塞式的 Web 框架，它
springboot webflux 使用示例（注解）
weixin_43931625的博客
06-18 797
springbootwebflux使用示例
SpringBoot 2.0 Webflux 介绍 和Demo示例
热门推荐
carlos 程序员里最丑的
07-26 2万+
 Spring WebFlux  1.1 WebFlux 简介 Spring WebFlux是Spring Framework 5.0中引入的新的反应式Web框架。与Spring MVC不同，它不需要Servlet API，完全异步且无阻塞，并 通过Reactor项目实现Reactive Streams规范。 Spring WebFlux有两种版本：基于功能和注释。基于注释的注释非常接近S...
WebFlux 学习 —— 使用示例
weixin_33938733的博客
12-01 231
为什么80%的码农都做不了架构师？>>> ...
Spring5 WebFlux响应式编程应用场景示例
老码农的博客
12-27 1713
Spring5中重要的变化是把响应式编程的思想应用到了框架的各个方面如Spring WebFlux, Spring Data和Spring Cloud Gateway。Spring5 的响应式编程默认以Reactor库为基础。Reactor内部提供了Flux和Mono两个代表异步数据系列的核心组件，它使开发人员能够方便快捷的构建异步非阻塞的应用程序。
spring webflux r2dbc使用mysql项目样例
shengzi101的专栏
05-28 958
响应式编程，一定要丢弃命令式编程的习惯，要进行思想转变，按照相应式、流的方式来思考实现步骤。并且，在响应式项目中，一定不要使用阻塞式方法，否则就失去了响应式编程的优点。
Spring Boot WebFlux增删改查样例
成长需要沉淀。
01-09 713
Spring Boot WebFlux增删改查样例 1、依赖 1.1、pom文件 <?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
Spring Boot结合WebFlux的详细使用教程及代码示例
资源摘要信息:"Spring WebFlux 使用详细代码" 在现代的Web开发中，响应式编程（Reactive Programming）逐渐成为了构建可伸缩、高并发应用程序的首选。Spring WebFlux是Spring 5的一部分，它提供了一种新的响应式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值