SpringBoot2使用WebFlux函數(shù)式編程的方法

更新時間：2018年08月08日 14:02:29 作者：大老楊

這篇文章主要介紹了SpringBoot2使用WebFlux函數(shù)式編程的方法,小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧

本文只是簡單使用SpringBoot2使用WebFlux的函數(shù)式編程簡單使用，后續(xù)會繼續(xù)寫關于Webflux相關的文章。

最近一直在研究WebFlux，后續(xù)會陸續(xù)出一些相關的文章。

首先看一下Srping官網上的一張圖，對比一下SpringMvc和Spring WebFlux，如圖：

在查看一下WebFlux的官方文檔:https://docs.spring.io/spring/docs/current/spring-framework-reference/web-reactive.html，WebFlux提供了函數(shù)式編程，本文簡單介紹一下WebFlux函數(shù)式編程簡單使用。

新建項目

創(chuàng)建一個項目，pom文件中引入webflux依賴，完整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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>

  <groupId>com.dalaoyang</groupId>
  <artifactId>springboot2_webflux</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>springboot2_webflux</name>
  <description>springboot2_webflux</description>

  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.3.RELEASE</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
  </properties>

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

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

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

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


</project>

首先試試引入WebFlux依賴之后，SpringMvc方式是否還能使用，新建一個HelloController，完整代碼如下，執(zhí)行后發(fā)現(xiàn)，是可以正常執(zhí)行訪問的，這其實就是我們所說的注解式編程。

package com.dalaoyang.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author dalaoyang
 * @project springboot_learn
 * @package com.dalaoyang.controller
 * @email yangyang@dalaoyang.cn
 * @date 2018/7/30
 */
@RestController
public class HelloController {

  @GetMapping("hello")
  public String Hello(){
    return "Hello this is SpringWebFlux";
  }
}

結果如圖：

接下來使用函數(shù)式編程，首先查閱一下官方文檔，如圖：

我們需要創(chuàng)建一個HandlerFunction返回值為Mono，新建一個HiHandler，里面寫一個方法Hi，完整代碼如下：

package com.dalaoyang.handler;
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;


/**
 * @author dalaoyang
 * @project springboot_learn
 * @package com.dalaoyang.handler
 * @email yangyang@dalaoyang.cn
 * @date 2018/7/30
 */
@Component
public class HiHandler {


  public Mono<ServerResponse> Hi(ServerRequest request) {
    return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
        .body(BodyInserters.fromObject("Hi , this is SpringWebFlux"));
  }
}

其中ServerResponse是相應的封裝對象，下面是它的源碼，其中包含了響應狀態(tài)，響應頭等等，代碼如下：

package org.springframework.web.reactive.function.server;

import java.net.URI;
import java.time.ZonedDateTime;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.Consumer;
import org.reactivestreams.Publisher;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.CacheControl;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseCookie;
import org.springframework.http.codec.HttpMessageWriter;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.util.MultiValueMap;
import org.springframework.web.reactive.function.BodyInserter;
import org.springframework.web.reactive.result.view.ViewResolver;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

public interface ServerResponse {
  HttpStatus statusCode();

  HttpHeaders headers();

  MultiValueMap<String, ResponseCookie> cookies();

  Mono<Void> writeTo(ServerWebExchange var1, ServerResponse.Context var2);

  static ServerResponse.BodyBuilder from(ServerResponse other) {
    return new DefaultServerResponseBuilder(other);
  }

  static ServerResponse.BodyBuilder status(HttpStatus status) {
    return new DefaultServerResponseBuilder(status);
  }

  static ServerResponse.BodyBuilder status(int status) {
    return new DefaultServerResponseBuilder(status);
  }

  static ServerResponse.BodyBuilder ok() {
    return status(HttpStatus.OK);
  }

  static ServerResponse.BodyBuilder created(URI location) {
    ServerResponse.BodyBuilder builder = status(HttpStatus.CREATED);
    return (ServerResponse.BodyBuilder)builder.location(location);
  }

  static ServerResponse.BodyBuilder accepted() {
    return status(HttpStatus.ACCEPTED);
  }

  static ServerResponse.HeadersBuilder<?> noContent() {
    return status(HttpStatus.NO_CONTENT);
  }

  static ServerResponse.BodyBuilder seeOther(URI location) {
    ServerResponse.BodyBuilder builder = status(HttpStatus.SEE_OTHER);
    return (ServerResponse.BodyBuilder)builder.location(location);
  }

  static ServerResponse.BodyBuilder temporaryRedirect(URI location) {
    ServerResponse.BodyBuilder builder = status(HttpStatus.TEMPORARY_REDIRECT);
    return (ServerResponse.BodyBuilder)builder.location(location);
  }

  static ServerResponse.BodyBuilder permanentRedirect(URI location) {
    ServerResponse.BodyBuilder builder = status(HttpStatus.PERMANENT_REDIRECT);
    return (ServerResponse.BodyBuilder)builder.location(location);
  }

  static ServerResponse.BodyBuilder badRequest() {
    return status(HttpStatus.BAD_REQUEST);
  }

  static ServerResponse.HeadersBuilder<?> notFound() {
    return status(HttpStatus.NOT_FOUND);
  }

  static ServerResponse.BodyBuilder unprocessableEntity() {
    return status(HttpStatus.UNPROCESSABLE_ENTITY);
  }

  public interface Context {
    List<HttpMessageWriter<?>> messageWriters();

    List<ViewResolver> viewResolvers();
  }

  public interface BodyBuilder extends ServerResponse.HeadersBuilder<ServerResponse.BodyBuilder> {
    ServerResponse.BodyBuilder contentLength(long var1);

    ServerResponse.BodyBuilder contentType(MediaType var1);

    ServerResponse.BodyBuilder hint(String var1, Object var2);

    <T, P extends Publisher<T>> Mono<ServerResponse> body(P var1, Class<T> var2);

    <T, P extends Publisher<T>> Mono<ServerResponse> body(P var1, ParameterizedTypeReference<T> var2);

    Mono<ServerResponse> syncBody(Object var1);

    Mono<ServerResponse> body(BodyInserter<?, ? super ServerHttpResponse> var1);

    Mono<ServerResponse> render(String var1, Object... var2);

    Mono<ServerResponse> render(String var1, Map<String, ?> var2);
  }

  public interface HeadersBuilder<B extends ServerResponse.HeadersBuilder<B>> {
    B header(String var1, String... var2);

    B headers(Consumer<HttpHeaders> var1);

    B cookie(ResponseCookie var1);

    B cookies(Consumer<MultiValueMap<String, ResponseCookie>> var1);

    B allow(HttpMethod... var1);

    B allow(Set<HttpMethod> var1);

    B eTag(String var1);

    B lastModified(ZonedDateTime var1);

    B location(URI var1);

    B cacheControl(CacheControl var1);

    B varyBy(String... var1);

    Mono<ServerResponse> build();

    Mono<ServerResponse> build(Publisher<Void> var1);

    Mono<ServerResponse> build(BiFunction<ServerWebExchange, ServerResponse.Context, Mono<Void>> var1);
  }
}

在回過頭了看上面官方文檔的圖片，還需要配置一個路由來類似@RequestMapping的功能，通過RouterFunctions.route(RequestPredicate, HandlerFunction)提供了一個路由器函數(shù)默認實現(xiàn)，新建一個HiRouter，代碼如下：

package com.dalaoyang.router;

import com.dalaoyang.handler.HiHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;
/**
 * @author dalaoyang
 * @project springboot_learn
 * @package com.dalaoyang.router
 * @email yangyang@dalaoyang.cn
 * @date 2018/7/30
 */
@Configuration
public class HiRouter {
  @Bean
  public RouterFunction<ServerResponse> routeCity(HiHandler hiHandler) {
    return RouterFunctions
        .route(RequestPredicates.GET("/hi")
                .and(RequestPredicates.accept(MediaType.APPLICATION_JSON)),
            hiHandler::Hi);
  }
}

啟動項目，通過控制臺可以看到，兩種方式的映射都被打印出來了，如圖所示：