《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性
《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性《Spring Boot 2.0 极简教程》附录 I : Spring 5.0 新特性
《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 <T> List<T> query(String sql, RowMapper<T> rowMapper) throws DataAccessException {
return result(query(sql, new RowMapperResultSetExtractor<>(rowMapper)));
}这个查询方法的第二个参数需要RowMapper接口的一个实例。在Java 8中我们可以写一个lambda表达式作为第二个参数的值传进去。 没有 Lambda 表达式之前，我们通常会把代码写成这样：
jdbcTemplate.query("select * from product", new RowMapper<Product>(){
@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.support
import org.springframework.beans.factory.config.BeanDefinitionCustomizer
import org.springframework.beans.factory.support.AbstractBeanDefinition
import org.springframework.context.ApplicationContextInitializer
import org.springframework.core.env.ConfigurableEnvironment
import java.util.function.Supplier
fun beans(init: BeanDefinitionDsl.() -> Unit): BeanDefinitionDsl {
val beans = BeanDefinitionDsl()
beans.init()
return beans
}
open class BeanDefinitionDsl(private val condition: (ConfigurableEnvironment) -> Boolean = { true })
: ApplicationContextInitializer<GenericApplicationContext> {
@PublishedApi
internal val registrations = arrayListOf<(GenericApplicationContext) -> Unit>()
@PublishedApi
internal val children = arrayListOf<BeanDefinitionDsl>()
enum class Scope {
SINGLETON,
PROTOTYPE
}
enum class Autowire {
NO,
BY_NAME,
BY_TYPE,
CONSTRUCTOR
}
inner class BeanDefinitionContext(@PublishedApi internal val context: GenericApplicationContext) {
inline fun <reified T : Any> 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 <reified T : Any> 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 <reified T : Any> 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<UserHandler>()
bean<Routes>()
bean<WebHandler>("webHandler") {
RouterFunctions.toWebHandler(
ref<Routes>().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<Foo>()
}
}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 表达式
@Test
void 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目前支持以下升级库的版本 ：
Jackson 2.6+ EhCache 2.10+ / 3.0 GA Hibernate 5.0+ JDBC 4.0+ XmlUnit 2.x+ OkHttp 3.x+ Netty 4.1+
Spring 5.0 详细的新特性可参考Github wiki：https://github.com/spring-projects/spring-framework/wiki/What's-New-in-Spring-Framework-5.x