《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性

阅读量：255 次

发布时间：2019-03-01

本文共 19570 字，大约阅读时间需要 65 分钟。

《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性

因为Spring Boot 2.0 是基于Spring Framework 5.0而开发的，所以我们这里对 Spring 5.0的新功能特性做一个简单的介绍。

Spring Framework 项目的领导人 Juergen Hoeller 于 2016 年 7 月 28 日宣布了第一个 Spring Framework 5.0 里程碑版本(5.0 M1)。2017 年 9 月正式发行了Spring Framework 5.0 GA 版本。

Spring Framework 5.0 的亮点绝对是响应式编程，这是一个重要的范式转变。Spring Framework 5新引入的反应式（Reactor）编程框架WebFlux将会取代传统的基于Servlet API的阻塞模型。

虽然响应式编程是 Spring Framework 5.0 中的闪光点，但它不会在任何地方得到支持。下游技术需要提供响应式支持。你会看到未来将要发布的 Spring Data、Spring Security、Spring Integration 等版本所提供的响应式编程功能。Spring Data 团队已经为 MongoDB 和 Redis 实现了响应式支持。使用 JDBC 获取响应式支持还为时过早。JDBC 规范本身就是阻塞的，在传统的 JDBC 数据库中看到响应式编程的还需要一段时间。

随着响应式编程越来越受欢迎，我们可以期待越来越多的技术将实现响应式解决方案。 Reactive Stack 在整个 Spring 5.0生态中的位置如下图所示

Spring 5 于 2017 年 9 月发布了通用版本 (GA)，它标志着自 2013 年 12 月以来第一个主要 Spring Framework 版本。Spring 5 兼容 Java™8 和 JDK 9，它集成了反应式流 ( Reactive Stream )，提供一种颠覆性方法来实现Web 应用程序开发。

Spring WebFlux 是 Spring 5 的反应式编程的核心，它为开发人员提供了两种Spring Web编程模型：

 一种基于注解的模型

 Functional Web Framework (WebFlux.fn)

基于注解的模型是 Spring WebMVC 的现代替代方案，该模型基于反应式构建，而 Functional Web Framework 是传统的基于 @Controller 注解的编程模型的替代方案。

Spring Framework 5.0 的新特性如下：

基于JDK 8+ 和Java EE 7+
使用泛型类型推断、Lambda 表达式等提升代码可读性。
基于Java EE 7 API 支持：Servlet 3.1, Bean Validation 1.1, JPA 2.1, JMS 2.0
基于Web 服务器版本：Tomcat 8.5+, Jetty 9.4+, WildFly 10+
完全兼容JDK 9。
运行时兼容Java EE 8 API，Servlet 4.0, Bean Validation 2.0, JPA 2.2, JSON Binding API 1.0。
针对Tomcat 9.0, Hibernate Validator 6.0, Apache Johnzon 1.1进行测试。
在这里，我们举一个 Spring 5.0中使用 Java 8中Lambda 表达式的例子。在Java 8里，任何函数式接口作为方法的参数传入或者作为方法返回值的场合，都可以用Lambda表达式代替。例如，Spring的JdbcTemplate类里有一个方法定义如下：

public 
    
      List
     
       query(String sql, RowMapper
      
        rowMapper) throws DataAccessException {    return result(query(sql, new RowMapperResultSetExtractor<>(rowMapper)));}

这个查询方法的第二个参数需要RowMapper接口的一个实例。在Java 8中我们可以写一个lambda表达式作为第二个参数的值传进去。

没有 Lambda 表达式之前，我们通常会把代码写成这样：

jdbcTemplate.query("select * from product", new RowMapper
    
     (){  @Override  public Product mapRow(ResultSet rs, int rowNum) throws SQLException {    Integer id = rs.getInt("id");    String description = rs.getString("description");    Integer quantity = rs.getInt("quantity");    BigDecimal price = rs.getBigDecimal("price");    Product product = new Product();    product.setId(id);    product.setDescription(description);    product.setQuantity(quantity);    product.setPrice(price);    return product;  }});

而在 Java 8中，我们可以这么写：

jdbcTemplate.query("select * from product", (rs, rowNum) -> {    Integer id = rs.getInt("id");    String description = rs.getString("description");    Integer quantity = rs.getInt("quantity");    BigDecimal price = rs.getBigDecimal("price");    Product product = new Product();    product.setId(id);    product.setDescription(description);    product.setQuantity(quantity);    product.setPrice(price);    return product;});

我们注意到Java 8中这段代码使用了lambda表达式，这比之前的版本中使用匿名内部类的方式紧凑、简洁得多。

移除的Packages, Classes 和Methods
移除包beans.factory.access (BeanFactoryLocator 机制).
移除包jdbc.support.nativejdbc (NativeJdbcExtractor 机制).
移除包mock.staticmock 从 spring-aspects 模块中移除。
移除包web.view.tiles2 和orm.hibernate3/hibernate4 .现在最低版本要求: Tiles 3 和Hibernate 5.
不再支持 AnnotationDrivenStaticEntityMockingControl

不再支持： Portlet, Velocity, JasperReports, XMLBeans, JDO, Guava.

建议: 如果上面的功能您仍需要使用，建议使用Spring Framework 4.3.x 。

通用基础包

基于JDK 8+ 的功能增强

兼容JDK 9

在包级别声明Non-null API：

可以显式使用 @Nullable 注解标注可空参数, 成员变量和返回值。

主要使用 IntelliJ IDEA 和Kotlin开发, 同时还有 Eclipse 与FindBugs.

一些Spring APIs 直接摒弃使用 null 值(e.g. StringUtils类)。

Resource 接口中readableChannel 的资源访问类基于 NIO实现。

文件系统的访问类不再使用FileInput/OutputStream ，而是采用NIO.2 流。

Spring Framework 5.0 提供了自己的spring-jcl日志模块替代标准 Commons Logging，它还可以自动检测Log4j 2.x, SLF4J, JUL (java.util.logging)，自带开箱即用的 Commons Logging 桥接器。Spring Logging 还提升了性能。

通过资源抽象支持防御性编程，为 getFile 访问提供了 isFile 指示器。

spring-core 模块中的修改字节码的功能包基于ASM 6.0。接下来会基于CGLIB 3.2.5 和Objenesis 2.6。

核心容器

支持 @Nullable 注解标注的optional injection points.
支持GenericApplicationContext和AnnotationConfigApplicationContext类的函数式风格编程。
在使用 CGLIB 代理下，对接口方法的事务、缓存和异步注释进行一致性检测。
将 XML 配置命名空间简化为无版本化的模式。
始终使用最新的 xsd 文件;不再支持已弃用的功能。
仍然支持声明特定版本, 但针对最新的schema进行了验证。
支持候选组件的索引 (作为类路径扫描的替代解决方案)。Spring Framework 5 改进了扫描和识别组件的方法，使大型项目的性能得到提升。目前，扫描是在编译时执行的，而且向 META-INF/spring.components 文件中的索引文件添加了组件坐标。该索引是通过一个为项目定义的特定平台应用的构建任务来生成的。标有来自 javax 包的注解的组件会添加到索引中，任何带 @Index 注解的类或接口都会添加到索引中。
从索引读取实体而不是全量扫描类路径，在性能上，对于小于 200 个类的小型项目可能没有明显差异，但对大型项目影响较大：加载组件索引开销更低。加载组件索引的耗费是廉价的。因此当类的数量不断增长，加上构建索引的启动时间仍然可以维持一个常数; 而对于组件扫描而言，启动时间则会有明显的增长。这个对于我们处于大型 Spring 项目的开发者所意味着的，是应用程序的启动时间将被大大缩减。虽然 20 或者 30 秒钟看似没什么，但如果每天要这样登上好几百次，加起来就够你受的了。使用了组件索引能帮助您更加快速地启动 Spring 应用，节省了宝贵的时间。
Spring 的传统类路径扫描方式没有删除，而是保留为一种后备选择。

Spring Web MVC

在 Spring 提供的过滤器接口 Filter实现中完整支持Servlet 3.1。
支持 Spring MVC 控制器方法中的 Servlet 4.0 PushBuilder 参数。
MaxUploadSizeExceededException 共用服务器上的 Servlet 3.0 多部分解析。
通过 MediaTypeFactory 委派统一支持公共媒体类型。
取代使用 Java Activation框架。
与不可变对象的数据绑定 (Kotlin / Lombok / @ConstructorProperties)
支持 JSON 绑定 API (使用 Eclipse Yasson 或 Apache Johnzon 作为Jackson和 GSON 的替代品)。
支持Jackson 2.9。
支持 Protobuf 3。
支持Reactor 3.1 Flux 和 Mono 以及 RxJava 1.3/2.1 作为spring mvc 控制器的方法返回值, 目标是在Spring MVC controllers中使用新的reactive WebClient 或Spring Data Reactive Repositories。
新的 ParsingPathMatcher 替代 AntPathMatcher, 具有更高效的解析和扩展语法。
@ExceptionHandler 方法允许传入 RedirectAttributes 参数。
支持 ResponseStatusException 作为 @ResponseStatus 的可选替代方案。
不需要再去实现Invocable 接口来创建脚本执行引擎, 可以直接使用 ScriptEngine#eval(String, Bindings) 来执行脚本, 并通过再在 ScriptTemplateView中传递 RenderingContext参数来实现 i18n 国际化和嵌套模板。
·Spring's FreeMarker宏（macros）spring.ftl 现在使用 HTML 输出格式 (需要 FreeMarker 2.3. 24 + 版本支持)。

Spring WebFlux

Spring 5.0的一个激动人心的特性就是新的响应式 Web框架 WebFlux，它是完全响应式且非阻塞的。Reactive Streams 是来自于 Netflix, Pivotal, Typesafe, Red Hat, Oracle, Twitter 以及 Spray.io 的工程师们特地开发的API框架。它为响应式编程实现的实现提供了一个公共的 API。就好比是实现JPA接口的Hibernate 框架。这里 JPA 就是这个Reactive Streams API, 而 Hibernate 就是其具体实现。Reactive Streams API 是 Java 9 的官方版本的一部分。在 Java 8 中, 需要专门引入依赖来使用 Reactive Streams API。

Spring Framework 5.0 中拥有一个新的 spring-webflux 模块，支持响应式 HTTP 和 WebSocket 客户端。Spring Framework 5.0 还提供了对于运行于服务器之上，包含了 REST, HTML, 以及 WebSocket 风格交互的响应式 Web应用程序的支持。

在 spring-webflux 中包含了两种独立的服务端编程模型：

(1)基于注解：使用到了@Controller 以及 Spring MVC 的其它一些注解；

(2)使用 Java 8 lambda 表达式的函数式风格的路由和处理。

有了 Spring Webflux, 现在可以创建出响应式且非阻塞的WebClient作为 RestTemplate 的一个替代方案。

下面是一个使用 Spring 5.0 的 REST 端点的 WebClient 实现示例：

WebClient webClient = WebClient.create();Mono person = webClient.get().uri("http://localhost:8080/movie/42").accept(MediaType.APPLICATION_JSON).exchange().then(response -> response.bodyToMono(Movie.class));WebClient webClient = WebClient.create();Mono person = webClient.get().uri("http://localhost:8080/movie/42").accept(MediaType.APPLICATION_JSON).exchange().then(response -> response.bodyToMono(Movie.class));

尽管新的 WebFlux 模块给我么带来了激动人心的新能力，传统的 Spring MVC 在 Spring Framework 5.0 仍然得到了完整的支持。

使用 Kotlin 进行函数式编程

Spring Framework 5.0 引入了对 JetBrains Kotlin 语言的支持。同时，Spring 5.0中也在使用 Kotlin 语言进行开发 API。我们可以到spring-framework源码工程目录下面去看一下 Kotlin 的代码列表：

spring-framework$ find . -name *.kt./spring-beans/src/main/kotlin/org/springframework/beans/factory/BeanFactoryExtensions.kt./spring-beans/src/main/kotlin/org/springframework/beans/factory/ListableBeanFactoryExtensions.kt./spring-beans/src/test/kotlin/org/springframework/beans/BeanUtilsKotlinTests.kt./spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt./spring-beans/src/test/kotlin/org/springframework/beans/factory/BeanFactoryExtensionsTests.kt./spring-beans/src/test/kotlin/org/springframework/beans/factory/ListableBeanFactoryExtensionsTests.kt./spring-context/src/main/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensions.kt./spring-context/src/main/kotlin/org/springframework/context/support/BeanDefinitionDsl.kt./spring-context/src/main/kotlin/org/springframework/context/support/GenericApplicationContextExtensions.kt./spring-context/src/main/kotlin/org/springframework/ui/ModelExtensions.kt./spring-context/src/main/kotlin/org/springframework/ui/ModelMapExtensions.kt./spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt./spring-context/src/test/kotlin/org/springframework/context/annotation/Spr16022Tests.kt./spring-context/src/test/kotlin/org/springframework/context/support/BeanDefinitionDslTests.kt./spring-context/src/test/kotlin/org/springframework/context/support/GenericApplicationContextExtensionsTests.kt./spring-context/src/test/kotlin/org/springframework/ui/ModelExtensionsTests.kt./spring-context/src/test/kotlin/org/springframework/ui/ModelMapExtensionsTests.kt./spring-core/src/main/kotlin/PropertyResolverExtensions.kt./spring-core/src/test/kotlin/org/springframework/core/env/PropertyResolverExtensionsTests.kt./spring-core/src/test/kotlin/org/springframework/core/KotlinMethodParameterTests.kt./spring-core/src/test/kotlin/org/springframework/core/KotlinReflectionParameterNameDiscovererTests.kt./spring-jdbc/src/main/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensions.kt./spring-jdbc/src/main/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensions.kt./spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt./spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/namedparam/MapSqlParameterSourceExtensionsTests.kt./spring-messaging/src/test/kotlin/org/springframework/messaging/simp/annotation/support/SimpAnnotationMethodMessageHandlerKotlinTests.kt./spring-test/src/main/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensions.kt./spring-test/src/test/kotlin/org/springframework/test/web/reactive/server/WebTestClientExtensionsTests.kt./spring-web/src/main/kotlin/org/springframework/web/client/RestOperationsExtensions.kt./spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt./spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt./spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensions.kt./spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/client/WebClientExtensions.kt./spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDsl.kt./spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensions.kt./spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensions.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/RouterFunctionDslTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt./spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/view/script/ScriptTemplateWithBindingsExtensions.kt./spring-webmvc/src/test/kotlin/org/springframework/web/servlet/mvc/method/annotation/ServletAnnotationControllerHandlerMethodKotlinTests.kt./spring-webmvc/src/test/kotlin/org/springframework/web/servlet/view/script/ScriptTemplateWithBindingsExtensions.kt

我们可以来阅读以下下面这个类的代码，来看看 Spring 框架是怎样使用 Kotlin 中的 DSL 实现极简化的编程风格的。

spring-context/src/main/kotlin/org/springframework/context/support/BeanDefinitionDsl.kt

这个类的代码如下：

package org.springframework.context.supportimport org.springframework.beans.factory.config.BeanDefinitionCustomizerimport org.springframework.beans.factory.support.AbstractBeanDefinitionimport org.springframework.context.ApplicationContextInitializerimport org.springframework.core.env.ConfigurableEnvironmentimport java.util.function.Supplierfun beans(init: BeanDefinitionDsl.() -> Unit): BeanDefinitionDsl {    val beans = BeanDefinitionDsl()    beans.init()    return beans}open class BeanDefinitionDsl(private val condition: (ConfigurableEnvironment) -> Boolean = { true })    : ApplicationContextInitializer
    
      {    @PublishedApi    internal val registrations = arrayListOf<(GenericApplicationContext) -> Unit>()    @PublishedApi    internal val children = arrayListOf
     
      ()    enum class Scope {        SINGLETON,        PROTOTYPE    }    enum class Autowire {        NO,        BY_NAME,        BY_TYPE,        CONSTRUCTOR    }    inner class BeanDefinitionContext(@PublishedApi internal val context: GenericApplicationContext) {        inline fun 
      
        ref(name: String? = null): T = when (name) {            null -> context.getBean(T::class.java)            else -> context.getBean(name, T::class.java)        }        val env: ConfigurableEnvironment            get() = context.environment    }    inline fun 
       
         bean(name: String? = null,                                      scope: Scope? = null,                                      isLazyInit: Boolean? = null,                                      isPrimary: Boolean? = null,                                      autowireMode: Autowire = Autowire.CONSTRUCTOR,                                      isAutowireCandidate: Boolean? = null) {        registrations.add {            val customizer = BeanDefinitionCustomizer { bd ->                scope?.let { bd.scope = scope.name.toLowerCase() }                isLazyInit?.let { bd.isLazyInit = isLazyInit }                isPrimary?.let { bd.isPrimary = isPrimary }                isAutowireCandidate?.let { bd.isAutowireCandidate = isAutowireCandidate }                if (bd is AbstractBeanDefinition) {                    bd.autowireMode = autowireMode.ordinal                }            }            when (name) {                null -> it.registerBean(T::class.java, customizer)                else -> it.registerBean(name, T::class.java, customizer)            }        }    }    inline fun 
        
          bean(name: String? = null,                                      scope: Scope? = null,                                      isLazyInit: Boolean? = null,                                      isPrimary: Boolean? = null,                                      autowireMode: Autowire = Autowire.NO,                                      isAutowireCandidate: Boolean? = null,                                      crossinline function: BeanDefinitionContext.() -> T) {        val customizer = BeanDefinitionCustomizer { bd ->            scope?.let { bd.scope = scope.name.toLowerCase() }            isLazyInit?.let { bd.isLazyInit = isLazyInit }            isPrimary?.let { bd.isPrimary = isPrimary }            isAutowireCandidate?.let { bd.isAutowireCandidate = isAutowireCandidate }            if (bd is AbstractBeanDefinition) {                bd.autowireMode = autowireMode.ordinal            }        }        registrations.add {            val beanContext = BeanDefinitionContext(it)            when (name) {                null -> it.registerBean(T::class.java,                        Supplier { function.invoke(beanContext) }, customizer)                else -> it.registerBean(name, T::class.java,                        Supplier { function.invoke(beanContext) }, customizer)            }        }    }    fun profile(profile: String, init: BeanDefinitionDsl.() -> Unit): BeanDefinitionDsl {        val beans = BeanDefinitionDsl({ it.activeProfiles.contains(profile) })        beans.init()        children.add(beans)        return beans    }    fun environment(condition: ConfigurableEnvironment.() -> Boolean,                    init: BeanDefinitionDsl.() -> Unit): BeanDefinitionDsl {        val beans = BeanDefinitionDsl(condition::invoke)        beans.init()        children.add(beans)        return beans    }    override fun initialize(context: GenericApplicationContext) {        for (registration in registrations) {            if (condition.invoke(context.environment)) {                registration.invoke(context)            }        }        for (child in children) {            child.initialize(context)        }    }}

其中的

fun beans(init: BeanDefinitionDsl.() -> Unit): BeanDefinitionDsl {    val beans = BeanDefinitionDsl()    beans.init()    return beans}

这段代码就是 Kotlin 中实现DSL的典型例子。关于 Kotlin DSL 的相关内容可以参考《Kotlin 极简教程》一书。

有了这个扩展类，我们就可以使用Kotlin DSL 风格的函数式Bean 定义

beans {    bean
    
     ()    bean
     
      ()    bean
      
       ("webHandler") {    RouterFunctions.toWebHandler(        ref
       
        ().router(),        HandlerStrategies.builder().viewResolver(ref()).build())    }    bean("messageSource") {        ReloadableResourceBundleMessageSource().apply {            setBasename("messages")            setDefaultEncoding("UTF-8")        }    }    bean {        val prefix = "classpath:/templates/"        val suffix = ".mustache"        val loader = MustacheResourceTemplateLoader(prefix, suffix)        MustacheViewResolver(Mustache.compiler().withLoader(loader)).apply {            setPrefix(prefix)            setSuffix(suffix)        }    }    profile("foo") {        bean
        
         ()    } }

Kotlin 是一种支持函数式编程编程风格的面向对象语言。Kotlin 运行在 JVM 之上，但运行环境并不限于 JVM。有了对 Kotlin 的支持，开发者可以进行深度的函数式 Spring 编程，特别是在函数式 Web 端点以及 Bean 注册这些方面。

在 Spring Framework 5.0 中, 可以为 WEB 的函数式 API 编写干净极简而且相当“地道”的 Kotlin 代码，就像下面这样：

{("/movie" and accept(TEXT_HTML)).nest {GET("/", movieHandler::findAllView)GET("/{card}", movieHandler::findOneView)}("/api/movie" and accept(APPLICATION_JSON)).nest {GET("/", movieApiHandler::findAll)GET("/{id}", movieApiHandler::findOne)}}

对于 Bean 的注册，作为 XML 或者 @Configuration 以及 @Bean 的替代办法, 现在你可以使用 Kotlin 来注册 Spring Bean了，就像下面这样：

val context = GenericApplicationContext {registerBean()registerBean { Cinema(it.getBean()) }}

测试方面的提升

Spring Framework 5.0 完全支持 JUnit 5 Jupiter，所以可以使用 JUnit 5 来编写测试以及扩展。此外还提供了一个编程以及扩展模型，Jupiter 子项目提供了一个测试引擎来在 Spring 上运行基于 Jupiter 的测试。另外，Spring Framework 5 还提供了在 Spring TestContext Framework 中进行并行测试的扩展。

现在可以在您的单元测试中利用 Java 8 中提供的函数式编程特性。下面的代码清单演示了这一支持：

代码清单 JUnit 5 全面使用了 Java 8 流和 Lambda 表达式

@Testvoid givenStreamOfInts_SumShouldBeMoreThan_100() {    assertTrue(Stream.of(10, 50, 50)      .stream()      .mapToInt(i -> i)      .sum() > 110, () -> "序列之和大于 100");}

Spring 5 继承了 JUnit 5，在 Spring TestContext Framework 内实现了多个扩展的 API。针对响应式编程模型， spring-test 现在还引入了支持 Spring WebFlux 的 WebTestClient 集成测试的支持，类似于 MockMvc，并不需要一个运行着的服务端。使用一个模拟的请求或者响应， WebTestClient 就可以直接绑定到 WebFlux 服务端设施。

WebTestClient 可绑定到真实的服务器，或者使用控制器或函数。在下面的代码清单中，WebTestClient 被绑定到 localhost：

代码清单. 绑定到 localhost 的 WebTestClient

WebTestClient testClient = WebTestClient  .bindToServer()  .baseUrl("http://localhost:8080")  .build();

在下面的代码清单中，测试了 RouterFunction：

代码清单. 将 WebTestClient 绑定到 RouterFunction

RouterFunction bookRouter = RouterFunctions.route(  RequestPredicates.GET("/books"),  request -> ServerResponse.ok().build());  WebTestClient  .bindToRouterFunction(bookRouter)  .build().get().uri("/books")  .exchange()  .expectStatus().isOk()  .expectBody().isEmpty();

当然， Spring Framework 5.0 仍然支持我们的老朋友 Junit。JUnit 5 现在是GA 版本。对于 JUnit4， Spring Framework 在未来还是要支持一段时间的。

库支持

Spring Framework 5.0目前支持以下升级库的版本：