Web
1. Servlet Web 应用程序
如果您想构建基于 servlet 的 Web 应用程序，您可以利用 Spring Boot 对 Spring MVC 或 Jersey 的自动配置。
1.1. “Spring Web MVC 框架”
Spring Web MVC 框架（通常称为“Spring MVC”）是一个丰富的“模型视图控制器”Web 框架。
Spring MVC 允许您创建特殊的@Controller或@RestControllerbean 来处理传入的 HTTP 请求。
控制器中的方法通过使用@RequestMapping附注。
以下代码显示了一个典型的@RestController，它提供 JSON 数据：
@RestController
@RequestMapping("/users")
public class MyRestController {
private final UserRepository userRepository;
private final CustomerRepository customerRepository;
public MyRestController(UserRepository userRepository, CustomerRepository customerRepository) {
this.userRepository = userRepository;
this.customerRepository = customerRepository;
}
@GetMapping("/{userId}")
public User getUser(@PathVariable Long userId) {
return this.userRepository.findById(userId).get();
}
@GetMapping("/{userId}/customers")
public List<Customer> getUserCustomers(@PathVariable Long userId) {
return this.userRepository.findById(userId).map(this.customerRepository::findByUser).get();
}
@DeleteMapping("/{userId}")
public void deleteUser(@PathVariable Long userId) {
this.userRepository.deleteById(userId);
}
}
@RestController
@RequestMapping("/users")
class MyRestController(private val userRepository: UserRepository, private val customerRepository: CustomerRepository) {
@GetMapping("/{userId}")
fun getUser(@PathVariable userId: Long): User {
return userRepository.findById(userId).get()
}
@GetMapping("/{userId}/customers")
fun getUserCustomers(@PathVariable userId: Long): List<Customer> {
return userRepository.findById(userId).map(customerRepository::findByUser).get()
}
@DeleteMapping("/{userId}")
fun deleteUser(@PathVariable userId: Long) {
userRepository.deleteById(userId)
}
}
“WebMvc.fn”是功能变体，它将路由配置与请求的实际处理分开，如以下示例所示：
@Configuration(proxyBeanMethods = false)
public class MyRoutingConfiguration {
private static final RequestPredicate ACCEPT_JSON = accept(MediaType.APPLICATION_JSON);
@Bean
public RouterFunction<ServerResponse> routerFunction(MyUserHandler userHandler) {
return route()
.GET("/{user}", ACCEPT_JSON, userHandler::getUser)
.GET("/{user}/customers", ACCEPT_JSON, userHandler::getUserCustomers)
.DELETE("/{user}", ACCEPT_JSON, userHandler::deleteUser)
.build();
}
}
@Configuration(proxyBeanMethods = false)
class MyRoutingConfiguration {
@Bean
fun routerFunction(userHandler: MyUserHandler): RouterFunction<ServerResponse> {
return RouterFunctions.route()
.GET("/{user}", ACCEPT_JSON, userHandler::getUser)
.GET("/{user}/customers", ACCEPT_JSON, userHandler::getUserCustomers)
.DELETE("/{user}", ACCEPT_JSON, userHandler::deleteUser)
.build()
}
companion object {
private val ACCEPT_JSON = accept(MediaType.APPLICATION_JSON)
}
}
@Component
public class MyUserHandler {
public ServerResponse getUser(ServerRequest request) {
...
return ServerResponse.ok().build();
}
public ServerResponse getUserCustomers(ServerRequest request) {
...
return ServerResponse.ok().build();
}
public ServerResponse deleteUser(ServerRequest request) {
...
return ServerResponse.ok().build();
}
}
@Component
class MyUserHandler {
fun getUser(request: ServerRequest?): ServerResponse {
return ServerResponse.ok().build()
}
fun getUserCustomers(request: ServerRequest?): ServerResponse {
return ServerResponse.ok().build()
}
fun deleteUser(request: ServerRequest?): ServerResponse {
return ServerResponse.ok().build()
}
}
Spring MVC 是核心 Spring Framework 的一部分，详细信息可在参考文档中找到。 spring.io/guides 上还提供了几个涵盖 Spring MVC 的指南。
您可以定义任意数量的RouterFunctionbean 来模块化路由器的定义。
如果需要应用优先级，则可以对 bean 进行排序。 |
1.1.1. Spring MVC 自动配置
Spring Boot 为 Spring MVC 提供了自动配置，适用于大多数应用程序。
它取代了对@EnableWebMvc并且两者不能一起使用。
除了 Spring MVC 的默认值之外，自动配置还提供以下功能：
如果你想保留这些 Spring Boot MVC 自定义并进行更多的 MVC 自定义（拦截器、格式化程序、视图控制器和其他功能），你可以添加自己的@Configurationtype 类WebMvcConfigurer但没有 @EnableWebMvc.
如果要提供RequestMappingHandlerMapping,RequestMappingHandlerAdapter或ExceptionHandlerExceptionResolver，并且仍然保留 Spring Boot MVC 自定义，则可以声明一个WebMvcRegistrations并使用它来提供这些组件的自定义实例。
自定义实例将受 Spring MVC 的进一步初始化和配置的约束。
要参与并在需要时覆盖该后续处理，需要一个WebMvcConfigurer应该使用。
如果您不想使用自动配置并希望完全控制 Spring MVC，请添加您自己的@Configuration注解@EnableWebMvc.
或者，添加您自己的@Configuration-注释DelegatingWebMvcConfiguration如 Javadoc 中所述@EnableWebMvc.
1.1.2. Spring MVC 转换服务
Spring MVC 使用不同的ConversionService转换为用于将值从application.properties或application.yaml文件。
这意味着Period,Duration和DataSize转换器不可用，并且@DurationUnit和@DataSizeUnit注释将被忽略。
如果要自定义ConversionService由 Spring MVC 使用，您可以提供WebMvcConfigurer带有addFormatters方法。
通过此方法，您可以注册您喜欢的任何转换器，也可以委托给ApplicationConversionService.
转换也可以使用spring.mvc.format.*configuration 属性。
如果未配置，则使用以下默认值：
| 财产 | DateTimeFormatter |
|---|---|
|
|
|
|
|
|
1.1.3. HttpMessage转换器
Spring MVC 使用HttpMessageConverter接口来转换 HTTP 请求和响应。
合理的默认值是开箱即用的。
例如，对象可以自动转换为 JSON（通过使用 Jackson 库）或 XML（通过使用 Jackson XML 扩展，如果可用，或者通过使用 JAXB，如果 Jackson XML 扩展不可用）。
默认情况下，字符串以UTF-8.
任何HttpMessageConverter将 Bean 添加到转换器列表中。
您也可以以相同的方式覆盖默认转换器。
如果需要添加或自定义转换器，可以使用 Spring Boot 的HttpMessageConverters类，如下面的清单所示：
@Configuration(proxyBeanMethods = false)
public class MyHttpMessageConvertersConfiguration {
@Bean
public HttpMessageConverters customConverters() {
HttpMessageConverter<?> additional = new AdditionalHttpMessageConverter();
HttpMessageConverter<?> another = new AnotherHttpMessageConverter();
return new HttpMessageConverters(additional, another);
}
}
@Configuration(proxyBeanMethods = false)
class MyHttpMessageConvertersConfiguration {
@Bean
fun customConverters(): HttpMessageConverters {
val additional: HttpMessageConverter<*> = AdditionalHttpMessageConverter()
val another: HttpMessageConverter<*> = AnotherHttpMessageConverter()
return HttpMessageConverters(additional, another)
}
}
为了进一步控制，您还可以将 sub-classHttpMessageConverters并覆盖其postProcessConverters和/或postProcessPartConverters方法。
当您想要重新排序或删除 Spring MVC 默认配置的某些转换器时，这可能很有用。
1.1.4. MessageCodes解析器
Spring MVC 有一个生成错误代码的策略，用于呈现来自绑定错误的错误消息：MessageCodesResolver.
如果将spring.mvc.message-codes-resolver-format财产PREFIX_ERROR_CODE或POSTFIX_ERROR_CODE，Spring Boot 会为您创建一个（请参阅DefaultMessageCodesResolver.Format).
1.1.5. 静态内容
默认情况下， Spring Boot 从名为/static（或/public或/resources或/META-INF/resources） 或从ServletContext.
它使用ResourceHttpRequestHandler从 Spring MVC，以便您可以通过添加自己的WebMvcConfigurer并覆盖addResourceHandlers方法。
在独立的 Web 应用程序中，未启用容器中的默认 Servlet。
可以使用server.servlet.register-default-servlet财产。
默认 Servlet 充当后备，从ServletContext如果 Spring 决定不处理它。
大多数情况下，这不会发生（除非你修改了默认的 MVC 配置），因为 Spring 总是可以通过DispatcherServlet.
默认情况下，资源映射在 上，但您可以使用/**spring.mvc.static-path-pattern财产。
例如，将所有资源重新定位到/resources/**可以按如下方式实现：
spring.mvc.static-path-pattern=/resources/**spring:
mvc:
static-path-pattern: "/resources/**"您还可以使用spring.web.resources.static-locations属性（将默认值替换为目录位置列表）。
根 Servlet 上下文路径 也会自动添加为位置。"/"
除了前面提到的“标准”静态资源位置之外，Webjars 内容还有一个特殊情况。
默认情况下，路径为/webjars/**如果 jar 文件以 Webjars 格式打包，则从 jar 文件中提供。
可以使用spring.mvc.webjars-path-pattern财产。
请勿使用src/main/webapp目录（如果您的应用程序打包为 jar）。
虽然这个目录是一个通用标准，但它仅适用于 war 打包，如果你生成一个 jar，大多数构建工具都会默默地忽略它。 |
Spring Boot 还支持 Spring MVC 提供的高级资源处理功能，允许使用诸如缓存清除静态资源或对 Webjar 使用与版本无关的 URL 等用例。
要对 Webjar 使用与版本无关的 URL，请添加webjars-locator-coreDependency。
然后声明您的 Webjar。
以 jQuery 为例，添加"/webjars/jquery/jquery.min.js"结果"/webjars/jquery/x.y.z/jquery.min.js"哪里x.y.z是 Webjar 版本。
如果您使用 JBoss，则需要声明webjars-locator-jboss-vfsdependency 而不是webjars-locator-core.
否则，所有 Webjar 都会解析为404. |
要使用缓存清除，以下配置为所有静态资源配置缓存清除解决方案，从而有效地添加内容哈希，例如<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>，在 URL 中：
spring.web.resources.chain.strategy.content.enabled=true
spring.web.resources.chain.strategy.content.paths=/**spring:
web:
resources:
chain:
strategy:
content:
enabled: true
paths: "/**"指向资源的链接在运行时在模板中重写，这要归功于ResourceUrlEncodingFilter这是为 Thymeleaf 和 FreeMarker 自动配置的。
使用 JSP 时，应手动声明此过滤器。
其他模板引擎目前不自动支持，但可以使用自定义模板宏/帮助程序并使用ResourceUrlProvider. |
例如，使用 JavaScript 模块加载器动态加载资源时，重命名文件不是一个选项。 这就是为什么还支持其他策略并且可以组合的原因。 “fixed” 策略在 URL 中添加静态版本字符串，而不更改文件名，如以下示例所示：
spring.web.resources.chain.strategy.content.enabled=true
spring.web.resources.chain.strategy.content.paths=/**
spring.web.resources.chain.strategy.fixed.enabled=true
spring.web.resources.chain.strategy.fixed.paths=/js/lib/
spring.web.resources.chain.strategy.fixed.version=v12spring:
web:
resources:
chain:
strategy:
content:
enabled: true
paths: "/**"
fixed:
enabled: true
paths: "/js/lib/"
version: "v12"使用此配置，位于"/js/lib/"使用固定版本控制策略 （"/v12/js/lib/mymodule.js"），而其他资源仍然使用内容 （<link href="/css/spring-2a2d595e6ed9a0b24f027f2b63b134d6.css"/>).
看WebProperties.Resources以获取更多支持的选项。
1.1.6. 欢迎页面
Spring Boot 支持静态和模板化欢迎页面。
它首先查找index.html文件。
如果未找到，则查找index模板。
如果找到任何一个，它将自动用作应用程序的欢迎页面。
1.1.8. 路径匹配和内容协商
Spring MVC 可以通过查看请求路径并将其与应用程序中定义的 Map（例如，@GetMappingController 方法上的注释）。
Spring Boot 默认选择禁用后缀模式匹配，这意味着像"GET /projects/spring-boot.json"将不匹配到@GetMapping("/projects/spring-boot")映射。
这被认为是 Spring MVC 应用程序的最佳实践。
此功能在过去主要对没有发送正确的 “Accept” 请求标头的 HTTP 客户端有用;我们需要确保将正确的 Content Type 发送给客户端。
如今，Content Negotiation 更加可靠。
还有其他方法可以处理 HTTP 客户端，这些客户端不能始终如一地发送正确的 “Accept” 请求标头。
我们可以使用 query 参数来确保像"GET /projects/spring-boot?format=json"将映射到@GetMapping("/projects/spring-boot"):
spring.mvc.contentnegotiation.favor-parameter=truespring:
mvc:
contentnegotiation:
favor-parameter: true或者，如果您更喜欢使用不同的参数名称：
spring.mvc.contentnegotiation.favor-parameter=true
spring.mvc.contentnegotiation.parameter-name=myparamspring:
mvc:
contentnegotiation:
favor-parameter: true
parameter-name: "myparam"大多数标准媒体类型都是开箱即用的，但您也可以定义新的媒体类型：
spring.mvc.contentnegotiation.media-types.markdown=text/markdownspring:
mvc:
contentnegotiation:
media-types:
markdown: "text/markdown"从 Spring Framework 5.3 开始， Spring MVC 支持两种将请求路径与控制器匹配的策略。
默认情况下，Spring Boot 使用PathPatternParser策略。PathPatternParser是一种优化的实现，但与AntPathMatcher策略。PathPatternParser限制某些路径模式变体的使用。
它也与配置DispatcherServlet使用路径前缀 （spring.mvc.servlet.path).
该策略可以使用spring.mvc.pathmatch.matching-strategyconfiguration 属性，如以下示例所示：
spring.mvc.pathmatch.matching-strategy=ant-path-matcherspring:
mvc:
pathmatch:
matching-strategy: "ant-path-matcher"默认情况下，如果找不到请求的处理程序， Spring MVC 将发送 404 Not Found 错误响应。
要有一个NoHandlerFoundException而是将 configprop：spring.mvc.throw-exception-if-no-handler-found 设置为true.
请注意，默认情况下，静态内容的提供会映射到所有请求，因此会为所有请求提供处理程序。
对于/**NoHandlerFoundException要被抛出，您还必须设置spring.mvc.static-path-pattern设置为更具体的值，例如/resources/**或设置spring.web.resources.add-mappings自false以完全禁用静态内容的提供。
1.1.9. 可配置的 WebBindingInitializer
Spring MVC 使用WebBindingInitializer要初始化WebDataBinder对于特定请求。
如果您创建自己的ConfigurableWebBindingInitializer @Bean，Spring Boot 会自动配置 Spring MVC 以使用它。
1.1.10. 模板引擎
除了 REST Web 服务之外，您还可以使用 Spring MVC 来提供动态 HTML 内容。 Spring MVC 支持多种模板技术，包括 Thymeleaf、FreeMarker 和 JSP。 此外，许多其他模板引擎包括他们自己的 Spring MVC 集成。
Spring Boot 包括对以下模板引擎的自动配置支持：
| 如果可能，应避免使用 JSP。 将它们与嵌入式 servlet 容器一起使用时，存在几个已知的限制。 |
当您使用具有默认配置的模板引擎之一时，您的模板会自动从src/main/resources/templates.
| 根据您运行应用程序的方式，IDE 可能会以不同的方式对 Classpath 进行排序。 在 IDE 中，从 main 方法运行应用程序时，与使用 Maven 或 Gradle 或从其打包的 jar 运行应用程序时的顺序不同。 这可能会导致 Spring Boot 无法找到预期的模板。 如果遇到此问题，可以在 IDE 中对 Classpath 重新排序，以便将模块的类和资源放在最前面。 |
1.1.11. 错误处理
默认情况下， Spring Boot 提供了一个/error映射，它以合理的方式处理所有错误，并在 servlet 容器中注册为“全局”错误页。
对于计算机客户端，它会生成一个 JSON 响应，其中包含错误、HTTP 状态和异常消息的详细信息。
对于浏览器客户端，有一个 “whitelabel” 错误视图，它以 HTML 格式呈现相同的数据（要对其进行自定义，请添加View解析为error).
有许多server.error属性，如果要自定义默认错误处理行为，则可以设置这些属性。
请参阅附录的 “Server Properties” 部分。
要完全替换默认行为，您可以实现ErrorController并注册该类型的 bean 定义或添加ErrorAttributes以使用现有机制，但替换内容。
这BasicErrorController可用作自定义ErrorController.
如果要为新的内容类型添加处理程序（默认为 handletext/html具体来说，并为其他所有内容提供回退）。
为此，请扩展BasicErrorController中，添加一个带有@RequestMapping具有produces属性，并创建一个新类型的 bean。 |
从 Spring Framework 6.0 开始，支持 RFC 7807 问题详细信息。
Spring MVC 可以使用application/problem+jsonmedia 类型，例如：
{
"type": "https://example.org/problems/unknown-project",
"title": "Unknown project",
"status": 404,
"detail": "No project found for id 'spring-unknown'",
"instance": "/projects/spring-unknown"
}可以通过设置spring.mvc.problemdetails.enabled自true.
您还可以定义一个带有@ControllerAdvice自定义 JSON 文档以返回特定控制器和/或异常类型，如以下示例所示：
@ControllerAdvice(basePackageClasses = SomeController.class)
public class MyControllerAdvice extends ResponseEntityExceptionHandler {
@ResponseBody
@ExceptionHandler(MyException.class)
public ResponseEntity<?> handleControllerException(HttpServletRequest request, Throwable ex) {
HttpStatus status = getStatus(request);
return new ResponseEntity<>(new MyErrorBody(status.value(), ex.getMessage()), status);
}
private HttpStatus getStatus(HttpServletRequest request) {
Integer code = (Integer) request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);
HttpStatus status = HttpStatus.resolve(code);
return (status != null) ? status : HttpStatus.INTERNAL_SERVER_ERROR;
}
}
@ControllerAdvice(basePackageClasses = [SomeController::class])
class MyControllerAdvice : ResponseEntityExceptionHandler() {
@ResponseBody
@ExceptionHandler(MyException::class)
fun handleControllerException(request: HttpServletRequest, ex: Throwable): ResponseEntity<*> {
val status = getStatus(request)
return ResponseEntity(MyErrorBody(status.value(), ex.message), status)
}
private fun getStatus(request: HttpServletRequest): HttpStatus {
val code = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE) as Int
val status = HttpStatus.resolve(code)
return status ?: HttpStatus.INTERNAL_SERVER_ERROR
}
}
在前面的示例中，如果MyException由定义在SomeController，则MyErrorBody使用 POJO 而不是ErrorAttributes表示法。
在某些情况下，指标基础设施不会记录在控制器级别处理的错误。 应用程序可以通过将 handled 异常设置为 request 属性来确保此类异常与请求指标一起记录：
@Controller
public class MyController {
@ExceptionHandler(CustomException.class)
String handleCustomException(HttpServletRequest request, CustomException ex) {
request.setAttribute(ErrorAttributes.ERROR_ATTRIBUTE, ex);
return "errorView";
}
}
@Controller
class MyController {
@ExceptionHandler(CustomException::class)
fun handleCustomException(request: HttpServletRequest, ex: CustomException?): String {
request.setAttribute(ErrorAttributes.ERROR_ATTRIBUTE, ex)
return "errorView"
}
}
自定义错误页面
如果要为给定状态代码显示自定义 HTML 错误页面，可以将文件添加到/error目录。
错误页面可以是静态 HTML（即，添加到任何静态资源目录下），也可以使用模板构建。
文件名应为确切的状态代码或系列掩码。
例如，要将404转换为静态 HTML 文件，则您的目录结构将如下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- public/
+- error/
| +- 404.html
+- <other public assets>
要映射所有5xx错误，则您的目录结构将如下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- templates/
+- error/
| +- 5xx.ftlh
+- <other templates>
对于更复杂的映射，您还可以添加实现ErrorViewResolver接口，如以下示例所示：
public class MyErrorViewResolver implements ErrorViewResolver {
@Override
public ModelAndView resolveErrorView(HttpServletRequest request, HttpStatus status, Map<String, Object> model) {
// Use the request or status to optionally return a ModelAndView
if (status == HttpStatus.INSUFFICIENT_STORAGE) {
// We could add custom model values here
new ModelAndView("myview");
}
return null;
}
}
class MyErrorViewResolver : ErrorViewResolver {
override fun resolveErrorView(request: HttpServletRequest, status: HttpStatus,
model: Map<String, Any>): ModelAndView? {
// Use the request or status to optionally return a ModelAndView
if (status == HttpStatus.INSUFFICIENT_STORAGE) {
// We could add custom model values here
return ModelAndView("myview")
}
return null
}
}
您还可以使用常规的 Spring MVC 功能，例如@ExceptionHandler方法和@ControllerAdvice.
这ErrorController然后选取任何未经处理的异常。
在 Spring MVC 之外映射错误页面
对于不使用 Spring MVC 的应用程序，您可以使用ErrorPageRegistrar直接注册的接口ErrorPages.
这种抽象直接与底层嵌入式 servlet 容器一起工作，即使你没有 Spring MVC，也可以工作DispatcherServlet.
@Configuration(proxyBeanMethods = false)
public class MyErrorPagesConfiguration {
@Bean
public ErrorPageRegistrar errorPageRegistrar() {
return this::registerErrorPages;
}
private void registerErrorPages(ErrorPageRegistry registry) {
registry.addErrorPages(new ErrorPage(HttpStatus.BAD_REQUEST, "/400"));
}
}
@Configuration(proxyBeanMethods = false)
class MyErrorPagesConfiguration {
@Bean
fun errorPageRegistrar(): ErrorPageRegistrar {
return ErrorPageRegistrar { registry: ErrorPageRegistry -> registerErrorPages(registry) }
}
private fun registerErrorPages(registry: ErrorPageRegistry) {
registry.addErrorPages(ErrorPage(HttpStatus.BAD_REQUEST, "/400"))
}
}
如果您注册了ErrorPage路径最终由Filter（这在一些非 Spring Web 框架中很常见，比如 Jersey 和 Wicket），那么Filter必须显式注册为ERRORDispatcher，如以下示例所示： |
@Configuration(proxyBeanMethods = false)
public class MyFilterConfiguration {
@Bean
public FilterRegistrationBean<MyFilter> myFilter() {
FilterRegistrationBean<MyFilter> registration = new FilterRegistrationBean<>(new MyFilter());
// ...
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType.class));
return registration;
}
}
@Configuration(proxyBeanMethods = false)
class MyFilterConfiguration {
@Bean
fun myFilter(): FilterRegistrationBean<MyFilter> {
val registration = FilterRegistrationBean(MyFilter())
// ...
registration.setDispatcherTypes(EnumSet.allOf(DispatcherType::class.java))
return registration
}
}
请注意，默认的FilterRegistrationBean不包括ERRORDispatcher 类型。
WAR 部署中的错误处理
当部署到 servlet 容器时， Spring Boot 使用其错误页面过滤器将具有错误状态的请求转发到相应的错误页面。 这是必需的，因为 servlet 规范没有提供用于注册错误页面的 API。 根据要将 war 文件部署到的容器和应用程序使用的技术，可能需要一些额外的配置。
如果尚未提交响应，则错误页面过滤器只能将请求转发到正确的错误页面。
默认情况下，WebSphere Application Server 8.0 及更高版本在成功完成 servlet 的服务方法后提交响应。
您应该通过设置com.ibm.ws.webcontainer.invokeFlushAfterService自false.
1.1.12. CORS 支持
从版本 4.2 开始，Spring MVC 支持 CORS。
使用控制器方法 CORS 配置与@CrossOriginSpring Boot 应用程序中的注释不需要任何特定的配置。全局 CORS 配置可以通过注册WebMvcConfigurerbean 替换为自定义的addCorsMappings(CorsRegistry)方法，如以下示例所示：
@Configuration(proxyBeanMethods = false)
public class MyCorsConfiguration {
@Bean
public WebMvcConfigurer corsConfigurer() {
return new WebMvcConfigurer() {
@Override
public void addCorsMappings(CorsRegistry registry) {
registry.addMapping("/api/**");
}
};
}
}
@Configuration(proxyBeanMethods = false)
class MyCorsConfiguration {
@Bean
fun corsConfigurer(): WebMvcConfigurer {
return object : WebMvcConfigurer {
override fun addCorsMappings(registry: CorsRegistry) {
registry.addMapping("/api/**")
}
}
}
}
1.2. JAX-RS 和Jersey
如果您更喜欢 REST 端点的 JAX-RS 编程模型，则可以使用其中一个可用的实现，而不是 Spring MVC。Jersey 和 Apache CXF 开箱即用。
CXF 要求您注册其Servlet或Filter作为@Bean在您的应用程序上下文中。
Jersey 有一些原生的 Spring 支持，因此我们还在 Spring Boot 中提供了对它的自动配置支持，以及一个Starters。
要开始使用 Jersey，请包括spring-boot-starter-jersey作为依赖项，然后您需要一个@Bean的类型ResourceConfig，您可以在其中注册所有终端节点，如以下示例所示：
@Component
public class MyJerseyConfig extends ResourceConfig {
public MyJerseyConfig() {
register(MyEndpoint.class);
}
}
Jersey 对扫描可执行档案的支持相当有限。
例如，它无法扫描在完全可执行的 jar 文件或WEB-INF/classes运行可执行 war 文件时。
为避免此限制，packages方法，并且应使用register方法，如前面的示例所示。 |
对于更高级的自定义，您还可以注册任意数量的 bean 来实现ResourceConfigCustomizer.
所有已注册的端点都应该是@Components使用 HTTP 资源注释 （@GET和其他），如以下示例所示：
@Component
@Path("/hello")
public class MyEndpoint {
@GET
public String message() {
return "Hello";
}
}
由于Endpoint是 Spring@Component，则其生命周期由 Spring 管理，您可以使用@Autowired注解注入依赖项并使用@Value注解注入外部配置。
默认情况下，Jersey Servlet 已注册并映射到 。
您可以通过添加/*@ApplicationPath发送到您的ResourceConfig.
默认情况下，Jersey 在@Bean的类型ServletRegistrationBean叫jerseyServletRegistration.
默认情况下，Servlet 是延迟初始化的，但您可以通过设置spring.jersey.servlet.load-on-startup.
您可以通过创建一个具有相同名称的 bean 来禁用或覆盖该 bean。
您还可以使用过滤器而不是 servlet，方法是将spring.jersey.type=filter（在这种情况下，@Bean替换或覆盖是jerseyFilterRegistration).
该过滤器具有@Order，您可以使用spring.jersey.filter.order.
当使用 Jersey 作为过滤器时，必须存在一个 Servlet，该 Servlet 将处理 Jersey 未拦截的任何请求。
如果您的应用程序不包含这样的 Servlet，则可能需要通过设置server.servlet.register-default-servlet自true.
Servlet 和过滤器注册都可以通过使用spring.jersey.init.*以指定属性的映射。
1.3. 嵌入式 Servlet 容器支持
对于 servlet 应用程序，Spring Boot 包括对嵌入式 Tomcat、Jetty 和 Undertow 服务器的支持。
大多数开发人员使用适当的 “Starter” 来获取完全配置的实例。
默认情况下，嵌入式服务器在端口8080.
1.3.1. Servlet、过滤器和侦听器
使用嵌入式 servlet 容器时，您可以注册 servlet、过滤器和所有侦听器（例如HttpSessionListener），通过使用 Spring Bean 或扫描 servlet 组件。
将 Servlet、过滤器和侦听器注册为 Spring Bean
任何Servlet,Filter或 Servlet*Listener实例，即 Spring Bean 注册到嵌入式容器中。
如果您想引用application.properties在配置期间。
默认情况下，如果上下文仅包含单个 Servlet，则会将其映射到 。
在多个 servlet bean 的情况下，bean 名称用作路径前缀。
筛选器映射到 。//*
如果基于约定的映射不够灵活，您可以使用ServletRegistrationBean,FilterRegistrationBean和ServletListenerRegistrationBean类以实现完全控制。
通常，将 filter bean 保持无序状态是安全的。
如果需要特定顺序，则应注释Filter跟@Order或使其实现Ordered.
您无法配置Filter通过使用@Order.
如果无法更改Filter类来添加@Order或实施Ordered中，您必须定义一个FilterRegistrationBean对于Filter并使用setOrder(int)方法。
避免配置一个过滤器，该过滤器在Ordered.HIGHEST_PRECEDENCE，因为它可能违背应用程序的字符编码配置。
如果 servlet 过滤器包装了请求，则应将其配置为小于或等于OrderedFilter.REQUEST_WRAPPER_FILTER_MAX_ORDER.
要查看每个Filter在您的应用程序中，为web 日志记录组 (logging.level.web=debug).
然后，将在启动时记录已注册过滤器的详细信息，包括它们的顺序和 URL 模式。 |
注册时要小心Filterbean，因为它们在应用程序生命周期的早期就被初始化了。
如果您需要注册Filter，请考虑使用DelegatingFilterProxyRegistrationBean相反。 |
1.3.2. Servlet 上下文初始化
嵌入式 servlet 容器不会直接执行jakarta.servlet.ServletContainerInitializerinterface 或 Spring 的org.springframework.web.WebApplicationInitializer接口。
这是一个有意的设计决策，旨在降低设计为在 war 中运行的第三方库可能会破坏 Spring Boot 应用程序的风险。
如果需要在 Spring Boot 应用程序中执行 servlet 上下文初始化，则应注册一个实现org.springframework.boot.web.servlet.ServletContextInitializer接口。
单onStartupmethod 提供对ServletContext并且，如有必要，可以很容易地用作现有WebApplicationInitializer.
1.3.3. ServletWebServerApplicationContext
在后台，Spring Boot 使用不同类型的ApplicationContext，了解嵌入式 servlet 容器支持。
这ServletWebServerApplicationContext是一种特殊类型的WebApplicationContext它通过搜索单个ServletWebServerFactory豆。
通常为TomcatServletWebServerFactory,JettyServletWebServerFactory或UndertowServletWebServerFactory已自动配置。
您通常不需要了解这些 implementation classes。
大多数应用程序都是自动配置的，并且适当的ApplicationContext和ServletWebServerFactory是代表您创建的。 |
在嵌入式容器设置中，ServletContext设置为服务器启动的一部分，该启动发生在应用程序上下文初始化期间。
由于这个 bean 在ApplicationContext不能使用ServletContext.
解决这个问题的一种方法是注射ApplicationContext作为 Bean 的依赖项，并访问ServletContext仅在需要时。
另一种方法是在服务器启动后使用回调。
这可以使用ApplicationListener它监听ApplicationStartedEvent如下：
public class MyDemoBean implements ApplicationListener<ApplicationStartedEvent> {
private ServletContext servletContext;
@Override
public void onApplicationEvent(ApplicationStartedEvent event) {
ApplicationContext applicationContext = event.getApplicationContext();
this.servletContext = ((WebApplicationContext) applicationContext).getServletContext();
}
}
1.3.4. 自定义嵌入式 Servlet 容器
可以使用 Spring 配置常见的 servlet 容器设置Environment性能。
通常，您会在application.properties或application.yaml文件。
常见的服务器设置包括：
-
网络设置：传入 HTTP 请求的侦听端口 （
server.port）、要绑定到的接口地址server.address等。 -
Session settings：会话是否持久 （
server.servlet.session.persistent）、会话超时 （server.servlet.session.timeout）、会话数据的位置 （server.servlet.session.store-dir） 和 session-cookie 配置 （server.servlet.session.cookie.*). -
错误管理：错误页面的位置 （
server.error.path） 等。
Spring Boot 会尽可能多地公开公共设置，但这并不总是可能的。
对于这些情况，专用命名空间提供特定于服务器的自定义（请参阅server.tomcat和server.undertow).
例如，可以使用嵌入式 servlet 容器的特定功能配置访问日志。
请参阅ServerProperties类以获取完整列表。 |
SameSite Cookie
这SameSiteWeb 浏览器可以使用 cookie 属性来控制是否以及如何在跨站点请求中提交 cookie。
该属性与现代 Web 浏览器尤其相关，这些浏览器已开始更改在缺少该属性时使用的默认值。
如果要更改SameSite属性，您可以使用server.servlet.session.cookie.same-site财产。
自动配置的 Tomcat、Jetty 和 Undertow 服务器支持此属性。
它还用于配置基于 Spring Session servletSessionRepository豆。
例如，如果您希望会话 Cookie 具有SameSite属性None中，您可以将以下内容添加到application.properties或application.yaml文件：
server.servlet.session.cookie.same-site=noneserver:
servlet:
session:
cookie:
same-site: "none"如果要更改SameSite添加到其他 Cookie 的属性HttpServletResponse，您可以使用CookieSameSiteSupplier.
这CookieSameSiteSupplier将传递一个Cookie，并且可能会返回SameSitevalue 或null.
您可以使用许多方便的 Factory 和 Filter 方法来快速匹配特定的 Cookie。
例如，添加以下 bean 将自动应用SameSite之Lax对于名称与正则表达式匹配的所有 Cookiemyapp.*.
@Configuration(proxyBeanMethods = false)
public class MySameSiteConfiguration {
@Bean
public CookieSameSiteSupplier applicationCookieSameSiteSupplier() {
return CookieSameSiteSupplier.ofLax().whenHasNameMatching("myapp.*");
}
}
@Configuration(proxyBeanMethods = false)
class MySameSiteConfiguration {
@Bean
fun applicationCookieSameSiteSupplier(): CookieSameSiteSupplier {
return CookieSameSiteSupplier.ofLax().whenHasNameMatching("myapp.*")
}
}
字符编码
用于请求和响应处理的嵌入式 servlet 容器的字符编码行为可以使用server.servlet.encoding.*configuration 属性。
当请求的Accept-Languageheader 表示请求的语言环境，它将被 servlet 容器自动映射到字符集。
每个容器提供程序都默认区域设置到 charset 映射，您应该验证它们是否满足应用程序的需求。
如果它们不这样做，请使用server.servlet.encoding.mappingconfiguration 属性来自定义映射，如以下示例所示：
server.servlet.encoding.mapping.ko=UTF-8server:
servlet:
encoding:
mapping:
ko: "UTF-8"在前面的示例中，ko（韩语） locale 已映射到UTF-8.
这相当于<locale-encoding-mapping-list>条目web.xml文件。
编程自定义
如果需要以编程方式配置嵌入式 servlet 容器，可以注册一个实现WebServerFactoryCustomizer接口。WebServerFactoryCustomizer提供对ConfigurableServletWebServerFactory，其中包括许多自定义 setter 方法。
以下示例显示了以编程方式设置端口：
@Component
public class MyWebServerFactoryCustomizer implements WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
@Override
public void customize(ConfigurableServletWebServerFactory server) {
server.setPort(9000);
}
}
@Component
class MyWebServerFactoryCustomizer : WebServerFactoryCustomizer<ConfigurableServletWebServerFactory> {
override fun customize(server: ConfigurableServletWebServerFactory) {
server.setPort(9000)
}
}
TomcatServletWebServerFactory,JettyServletWebServerFactory和UndertowServletWebServerFactory是 的专用变体ConfigurableServletWebServerFactory分别具有 Tomcat、Jetty 和 Undertow 的其他自定义 setter 方法。
以下示例显示如何自定义TomcatServletWebServerFactory，提供对特定于 Tomcat 的配置选项的访问：
@Component
public class MyTomcatWebServerFactoryCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
@Override
public void customize(TomcatServletWebServerFactory server) {
server.addConnectorCustomizers((connector) -> connector.setAsyncTimeout(Duration.ofSeconds(20).toMillis()));
}
}
@Component
class MyTomcatWebServerFactoryCustomizer : WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
override fun customize(server: TomcatServletWebServerFactory) {
server.addConnectorCustomizers({ connector -> connector.asyncTimeout = Duration.ofSeconds(20).toMillis() })
}
}
直接自定义ConfigurableServletWebServerFactory
对于需要您从ServletWebServerFactory，您可以自己公开此类 bean。
为许多配置选项提供了 setter。 如果你需要做一些更奇特的事情，还提供了几个受保护的方法 “钩子”。 有关详细信息，请参阅源代码文档。
| 自动配置的定制器仍应用于您的自定义工厂，因此请谨慎使用该选项。 |
2. 反应式 Web 应用程序
Spring Boot 通过为 Spring Webflux 提供自动配置来简化反应式 Web 应用程序的开发。
2.1. “Spring WebFlux 框架”
Spring WebFlux 是 Spring Framework 5.0 中引入的新反应式 Web 框架。 与 Spring MVC 不同，它不需要 servlet API，是完全异步和非阻塞的，并通过 Reactor 项目实现反应流规范。
Spring WebFlux 有两种风格：函数式和基于 Comments 的。 基于 Comments 的模型与 Spring MVC 模型非常接近，如以下示例所示：
@RestController
@RequestMapping("/users")
public class MyRestController {
private final UserRepository userRepository;
private final CustomerRepository customerRepository;
public MyRestController(UserRepository userRepository, CustomerRepository customerRepository) {
this.userRepository = userRepository;
this.customerRepository = customerRepository;
}
@GetMapping("/{userId}")
public Mono<User> getUser(@PathVariable Long userId) {
return this.userRepository.findById(userId);
}
@GetMapping("/{userId}/customers")
public Flux<Customer> getUserCustomers(@PathVariable Long userId) {
return this.userRepository.findById(userId).flatMapMany(this.customerRepository::findByUser);
}
@DeleteMapping("/{userId}")
public Mono<Void> deleteUser(@PathVariable Long userId) {
return this.userRepository.deleteById(userId);
}
}
@RestController
@RequestMapping("/users")
class MyRestController(private val userRepository: UserRepository, private val customerRepository: CustomerRepository) {
@GetMapping("/{userId}")
fun getUser(@PathVariable userId: Long): Mono<User?> {
return userRepository.findById(userId)
}
@GetMapping("/{userId}/customers")
fun getUserCustomers(@PathVariable userId: Long): Flux<Customer> {
return userRepository.findById(userId).flatMapMany { user: User? ->
customerRepository.findByUser(user)
}
}
@DeleteMapping("/{userId}")
fun deleteUser(@PathVariable userId: Long): Mono<Void> {
return userRepository.deleteById(userId)
}
}
WebFlux 是 Spring Framework 的一部分，其参考文档中提供了详细信息。
“WebFlux.fn”是功能变体，它将路由配置与请求的实际处理分开，如以下示例所示：
@Configuration(proxyBeanMethods = false)
public class MyRoutingConfiguration {
private static final RequestPredicate ACCEPT_JSON = accept(MediaType.APPLICATION_JSON);
@Bean
public RouterFunction<ServerResponse> monoRouterFunction(MyUserHandler userHandler) {
return route()
.GET("/{user}", ACCEPT_JSON, userHandler::getUser)
.GET("/{user}/customers", ACCEPT_JSON, userHandler::getUserCustomers)
.DELETE("/{user}", ACCEPT_JSON, userHandler::deleteUser)
.build();
}
}
@Configuration(proxyBeanMethods = false)
class MyRoutingConfiguration {
@Bean
fun monoRouterFunction(userHandler: MyUserHandler): RouterFunction<ServerResponse> {
return RouterFunctions.route(
GET("/{user}").and(ACCEPT_JSON), userHandler::getUser).andRoute(
GET("/{user}/customers").and(ACCEPT_JSON), userHandler::getUserCustomers).andRoute(
DELETE("/{user}").and(ACCEPT_JSON), userHandler::deleteUser)
}
companion object {
private val ACCEPT_JSON = accept(MediaType.APPLICATION_JSON)
}
}
@Component
public class MyUserHandler {
public Mono<ServerResponse> getUser(ServerRequest request) {
...
}
public Mono<ServerResponse> getUserCustomers(ServerRequest request) {
...
}
public Mono<ServerResponse> deleteUser(ServerRequest request) {
...
}
}
@Component
class MyUserHandler {
fun getUser(request: ServerRequest?): Mono<ServerResponse> {
return ServerResponse.ok().build()
}
fun getUserCustomers(request: ServerRequest?): Mono<ServerResponse> {
return ServerResponse.ok().build()
}
fun deleteUser(request: ServerRequest?): Mono<ServerResponse> {
return ServerResponse.ok().build()
}
}
“WebFlux.fn” 是 Spring Framework 的一部分，详细信息可在其参考文档中找到。
您可以定义任意数量的RouterFunctionbean 来模块化路由器的定义。
如果需要应用优先级，则可以对 bean 进行排序。 |
要开始使用，请添加spring-boot-starter-webflux模块添加到您的应用程序。
将两者相加spring-boot-starter-web和spring-boot-starter-webfluxmodules 会导致 Spring Boot 自动配置 Spring MVC，而不是 WebFlux。
之所以选择这种行为，是因为许多 Spring 开发人员在spring-boot-starter-webflux到他们的 Spring MVC 应用程序以使用响应式WebClient.
您仍然可以通过将所选应用程序类型设置为SpringApplication.setWebApplicationType(WebApplicationType.REACTIVE). |
2.1.1. Spring WebFlux 自动配置
Spring Boot 为 Spring WebFlux 提供了自动配置，适用于大多数应用程序。
自动配置在 Spring 的默认值之上添加了以下功能：
如果要保留 Spring Boot WebFlux 功能，并且想要添加其他 WebFlux 配置，则可以添加自己的@Configurationtype 类WebFluxConfigurer但没有 @EnableWebFlux.
如果您想完全控制 Spring WebFlux，您可以添加自己的@Configuration注解@EnableWebFlux.
2.1.2. Spring WebFlux 转换服务
如果要自定义ConversionService由 Spring WebFlux 使用，您可以提供WebFluxConfigurer带有addFormatters方法。
转换也可以使用spring.webflux.format.*configuration 属性。
如果未配置，则使用以下默认值：
| 财产 | DateTimeFormatter |
|---|---|
|
|
|
|
|
|
2.1.3. 使用 HttpMessageReaders 和 HttpMessageWriters 的 HTTP 编解码器
Spring WebFlux 使用HttpMessageReader和HttpMessageWriter接口来转换 HTTP 请求和响应。
它们配置了CodecConfigurer通过查看 Classpath 中可用的库来获得合理的默认值。
Spring Boot 为编解码器提供了专用的配置属性，spring.codec.*.
它还通过使用CodecCustomizer实例。
例如spring.jackson.*配置键应用于 Jackson 编解码器。
如果需要添加或自定义编解码器，可以创建自定义CodecCustomizer组件，如以下示例所示：
@Configuration(proxyBeanMethods = false)
public class MyCodecsConfiguration {
@Bean
public CodecCustomizer myCodecCustomizer() {
return (configurer) -> {
configurer.registerDefaults(false);
configurer.customCodecs().register(new ServerSentEventHttpMessageReader());
// ...
};
}
}
class MyCodecsConfiguration {
@Bean
fun myCodecCustomizer(): CodecCustomizer {
return CodecCustomizer { configurer: CodecConfigurer ->
configurer.registerDefaults(false)
configurer.customCodecs().register(ServerSentEventHttpMessageReader())
}
}
}
您还可以利用 Boot 的自定义 JSON 序列化器和反序列化器。
2.1.4. 静态内容
默认情况下， Spring Boot 从名为/static（或/public或/resources或/META-INF/resources） 中。
它使用ResourceWebHandler从 Spring WebFlux，以便您可以通过添加自己的WebFluxConfigurer并覆盖addResourceHandlers方法。
默认情况下，资源映射在 上，但您可以通过设置/**spring.webflux.static-path-pattern财产。
例如，将所有资源重新定位到/resources/**可以按如下方式实现：
spring.webflux.static-path-pattern=/resources/**spring:
webflux:
static-path-pattern: "/resources/**"您还可以使用spring.web.resources.static-locations.
这样做会将默认值替换为目录位置列表。
如果这样做，默认的欢迎页面检测将切换到您的自定义位置。
因此，如果存在index.html在启动时的任何位置，它都是应用程序的主页。
除了前面列出的“标准”静态资源位置之外，Webjars 内容还有一个特殊情况。
默认情况下，路径为/webjars/**如果 jar 文件以 Webjars 格式打包，则从 jar 文件中提供。
可以使用spring.webflux.webjars-path-pattern财产。
Spring WebFlux 应用程序并不严格依赖于 servlet API，因此它们不能部署为 war 文件，也不使用src/main/webapp目录。 |
2.1.5. 欢迎页面
Spring Boot 支持静态和模板化欢迎页面。
它首先查找index.html文件。
如果未找到，则查找index模板。
如果找到任何一个，它将自动用作应用程序的欢迎页面。
2.1.6. 模板引擎
除了 REST Web 服务之外，您还可以使用 Spring WebFlux 来提供动态 HTML 内容。 Spring WebFlux 支持多种模板技术，包括 Thymeleaf、FreeMarker 和 Mustache。
Spring Boot 包括对以下模板引擎的自动配置支持：
当您使用具有默认配置的模板引擎之一时，您的模板会自动从src/main/resources/templates.
2.1.7. 错误处理
Spring Boot 提供了一个WebExceptionHandler它以合理的方式处理所有错误。
它在处理顺序中的位置紧接在 WebFlux 提供的处理程序之前，这些处理程序被视为最后。
对于计算机客户端，它会生成一个 JSON 响应，其中包含错误、HTTP 状态和异常消息的详细信息。
对于浏览器客户端，有一个 “whitelabel” 错误处理程序，它以 HTML 格式呈现相同的数据。
您还可以提供自己的 HTML 模板来显示错误（请参阅下一节）。
在直接在 Spring Boot 中自定义错误处理之前，您可以利用 Spring WebFlux 中的 RFC 7807 问题详细信息支持。
Spring WebFlux 可以使用application/problem+jsonmedia 类型，例如：
{
"type": "https://example.org/problems/unknown-project",
"title": "Unknown project",
"status": 404,
"detail": "No project found for id 'spring-unknown'",
"instance": "/projects/spring-unknown"
}可以通过设置spring.webflux.problemdetails.enabled自true.
自定义此功能的第一步通常涉及使用现有机制，但替换或扩充错误内容。
为此，您可以添加ErrorAttributes.
要更改错误处理行为，您可以实现ErrorWebExceptionHandler并注册该类型的 bean 定义。
因为ErrorWebExceptionHandler相当底层，Spring Boot 还提供了一个方便的AbstractErrorWebExceptionHandler让你以 WebFlux 功能方式处理错误，如以下示例所示：
@Component
public class MyErrorWebExceptionHandler extends AbstractErrorWebExceptionHandler {
public MyErrorWebExceptionHandler(ErrorAttributes errorAttributes, WebProperties webProperties,
ApplicationContext applicationContext, ServerCodecConfigurer serverCodecConfigurer) {
super(errorAttributes, webProperties.getResources(), applicationContext);
setMessageReaders(serverCodecConfigurer.getReaders());
setMessageWriters(serverCodecConfigurer.getWriters());
}
@Override
protected RouterFunction<ServerResponse> getRoutingFunction(ErrorAttributes errorAttributes) {
return RouterFunctions.route(this::acceptsXml, this::handleErrorAsXml);
}
private boolean acceptsXml(ServerRequest request) {
return request.headers().accept().contains(MediaType.APPLICATION_XML);
}
public Mono<ServerResponse> handleErrorAsXml(ServerRequest request) {
BodyBuilder builder = ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR);
// ... additional builder calls
return builder.build();
}
}
@Component
class MyErrorWebExceptionHandler(
errorAttributes: ErrorAttributes, webProperties: WebProperties,
applicationContext: ApplicationContext, serverCodecConfigurer: ServerCodecConfigurer
) : AbstractErrorWebExceptionHandler(errorAttributes, webProperties.resources, applicationContext) {
init {
setMessageReaders(serverCodecConfigurer.readers)
setMessageWriters(serverCodecConfigurer.writers)
}
override fun getRoutingFunction(errorAttributes: ErrorAttributes): RouterFunction<ServerResponse> {
return RouterFunctions.route(this::acceptsXml, this::handleErrorAsXml)
}
private fun acceptsXml(request: ServerRequest): Boolean {
return request.headers().accept().contains(MediaType.APPLICATION_XML)
}
fun handleErrorAsXml(request: ServerRequest): Mono<ServerResponse> {
val builder = ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR)
// ... additional builder calls
return builder.build()
}
}
为了获得更完整的图片，您还可以子类化DefaultErrorWebExceptionHandler直接并覆盖特定方法。
在某些情况下，指标基础设施不会记录在控制器或处理程序函数级别处理的错误。 应用程序可以通过将 handled 异常设置为 request 属性来确保此类异常与请求指标一起记录：
@Controller
public class MyExceptionHandlingController {
@GetMapping("/profile")
public Rendering userProfile() {
// ...
throw new IllegalStateException();
}
@ExceptionHandler(IllegalStateException.class)
public Rendering handleIllegalState(ServerWebExchange exchange, IllegalStateException exc) {
exchange.getAttributes().putIfAbsent(ErrorAttributes.ERROR_ATTRIBUTE, exc);
return Rendering.view("errorView").modelAttribute("message", exc.getMessage()).build();
}
}
@Controller
class MyExceptionHandlingController {
@GetMapping("/profile")
fun userProfile(): Rendering {
// ...
throw IllegalStateException()
}
@ExceptionHandler(IllegalStateException::class)
fun handleIllegalState(exchange: ServerWebExchange, exc: IllegalStateException): Rendering {
exchange.attributes.putIfAbsent(ErrorAttributes.ERROR_ATTRIBUTE, exc)
return Rendering.view("errorView").modelAttribute("message", exc.message ?: "").build()
}
}
自定义错误页面
如果要显示给定状态代码的自定义 HTML 错误页面，可以添加从error/*，例如，通过将文件添加到/error目录。
错误页面可以是静态 HTML（即，添加到任何静态资源目录下），也可以是用模板构建的。
文件名应为确切的状态代码、状态代码系列掩码，或error，如果没有其他匹配项，则为 default。
请注意，默认错误视图的路径是error/error，而使用 Spring MVC 时，默认错误视图为error.
例如，要将404转换为静态 HTML 文件，则您的目录结构将如下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- public/
+- error/
| +- 404.html
+- <other public assets>要映射所有5xx错误，您的目录结构将如下所示：
src/
+- main/
+- java/
| + <source code>
+- resources/
+- templates/
+- error/
| +- 5xx.mustache
+- <other templates>2.1.8. Web 过滤器
Spring WebFlux 提供了一个WebFilter接口，该接口可以实现以过滤 HTTP 请求-响应交换。WebFilter在应用程序上下文中找到的 bean 将自动用于过滤每个交换。
如果过滤器的顺序很重要，他们可以实施Ordered或带有@Order.
Spring Boot 自动配置可以为您配置 Web 过滤器。
执行此作时，将使用下表中显示的订单：
| Web 过滤器 | 次序 |
|---|---|
|
|
|
|
|
|
2.2. 嵌入式反应式服务器支持
Spring Boot 包括对以下嵌入式反应式 Web 服务器的支持：Reactor Netty、Tomcat、Jetty 和 Undertow。 大多数开发人员使用适当的 “Starter” 来获取完全配置的实例。 默认情况下，嵌入式服务器在端口 8080 上侦听 HTTP 请求。
2.2.1. 自定义反应式服务器
常见的反应式 Web 服务器设置可以使用 Spring 进行配置Environment性能。
通常，您会在application.properties或application.yaml文件。
常见的服务器设置包括：
Spring Boot 会尽可能多地公开通用设置，但这并不总是可能的。
在这些情况下，专用命名空间（例如server.netty.*提供特定于服务器的自定义设置。
请参阅ServerProperties类以获取完整列表。 |
编程自定义
如果需要以编程方式配置反应式 Web 服务器，可以注册一个实现WebServerFactoryCustomizer接口。WebServerFactoryCustomizer提供对ConfigurableReactiveWebServerFactory，其中包括许多自定义 setter 方法。
以下示例显示了以编程方式设置端口：
@Component
public class MyWebServerFactoryCustomizer implements WebServerFactoryCustomizer<ConfigurableReactiveWebServerFactory> {
@Override
public void customize(ConfigurableReactiveWebServerFactory server) {
server.setPort(9000);
}
}
@Component
class MyWebServerFactoryCustomizer : WebServerFactoryCustomizer<ConfigurableReactiveWebServerFactory> {
override fun customize(server: ConfigurableReactiveWebServerFactory) {
server.setPort(9000)
}
}
JettyReactiveWebServerFactory,NettyReactiveWebServerFactory,TomcatReactiveWebServerFactory和UndertowServletWebServerFactory是 的专用变体ConfigurableReactiveWebServerFactory分别具有 Jetty、Reactor Netty、Tomcat 和 Undertow 的其他自定义 setter 方法。
以下示例显示如何自定义NettyReactiveWebServerFactory，提供对 Reactor Netty 特定的配置选项的访问：
@Component
public class MyNettyWebServerFactoryCustomizer implements WebServerFactoryCustomizer<NettyReactiveWebServerFactory> {
@Override
public void customize(NettyReactiveWebServerFactory factory) {
factory.addServerCustomizers((server) -> server.idleTimeout(Duration.ofSeconds(20)));
}
}
@Component
class MyNettyWebServerFactoryCustomizer : WebServerFactoryCustomizer<NettyReactiveWebServerFactory> {
override fun customize(factory: NettyReactiveWebServerFactory) {
factory.addServerCustomizers({ server -> server.idleTimeout(Duration.ofSeconds(20)) })
}
}
直接自定义 ConfigurableReactiveWebServerFactory
对于需要您从ReactiveWebServerFactory，您可以自己公开此类 bean。
为许多配置选项提供了 setter。 如果你需要做一些更奇特的事情，还提供了几个受保护的方法 “钩子”。 有关详细信息，请参阅源代码文档。
| 自动配置的定制器仍应用于您的自定义工厂，因此请谨慎使用该选项。 |
2.3. 反应式服务器资源配置
在自动配置 Reactor Netty 或 Jetty 服务器时， Spring Boot 将创建特定的 bean，这些 bean 将向服务器实例提供 HTTP 资源：ReactorResourceFactory或JettyResourceFactory.
默认情况下，这些资源也将与 Reactor Netty 和 Jetty 客户端共享，以获得最佳性能，前提是：
-
相同的技术用于 Server 和 Client 端
-
客户端实例是使用
WebClient.Builder由 Spring Boot 自动配置的 bean
开发人员可以通过提供自定义ReactorResourceFactory或JettyResourceFactorybean - 这将应用于客户端和服务器。
您可以在 WebClient 运行时 部分了解有关客户端资源配置的更多信息。
3. 优雅关机
所有四个嵌入式 Web 服务器（Jetty、Reactor Netty、Tomcat 和 Undertow）以及反应式和基于 servlet 的 Web 应用程序都支持正常关闭。
它是作为关闭应用程序上下文的一部分发生的，并在停止的最早阶段执行SmartLifecycle豆。
此停止处理使用超时，该超时提供宽限期，在此期间将允许完成现有请求，但不允许新请求。
不允许新请求的确切方式因所使用的 Web 服务器而异。 实现可能会在网络层停止接受请求，或者它们可能会返回具有特定 HTTP 状态代码或 HTTP 标头的响应。 使用持久连接还可以更改停止接受请求的方式。
要了解有关 Web 服务器使用的特定方法的更多信息，请参阅shutDownGracefully适用于 TomcatWebServer、NettyWebServer、JettyWebServer 或 UndertowWebServer 的 javadoc。 |
Jetty、Reactor Netty 和 Tomcat 将停止在网络层接受新请求。 Undertow 将接受新连接，但会立即响应服务不可用 （503） 响应。
| 使用 Tomcat 正常关闭需要 Tomcat 9.0.33 或更高版本。 |
要启用正常关闭，请配置server.shutdown属性，如以下示例所示：
server.shutdown=gracefulserver:
shutdown: "graceful"要配置超时时间，请配置spring.lifecycle.timeout-per-shutdown-phase属性，如以下示例所示：
spring.lifecycle.timeout-per-shutdown-phase=20sspring:
lifecycle:
timeout-per-shutdown-phase: "20s"如果 IDE 没有发送正确的SIGTERM信号。
有关更多详细信息，请参阅 IDE 的文档。 |
4. Spring Security
如果 Spring Security 在 Classpath 上，则默认情况下 Web 应用程序是安全的。
Spring Boot 依靠 Spring Security 的内容协商策略来确定是否使用httpBasic或formLogin.
要向 Web 应用程序添加方法级安全性，您还可以添加@EnableGlobalMethodSecurity替换为所需的设置。
其他信息可以在 Spring Security Reference Guide 中找到。
默认的UserDetailsService具有单个用户。
用户名为user，并且密码是随机的，并且在应用程序启动时以 WARN 级别打印，如以下示例所示：
Using generated security password: 78fa095d-3f4c-48b1-ad50-e24c31d5cf35 This generated password is for development use only. Your security configuration must be updated before running your application in production.
如果您微调日志记录配置，请确保org.springframework.boot.autoconfigure.securitycategory 设置为 logWARN-level 消息。
否则，不会打印默认密码。 |
您可以通过提供spring.security.user.name和spring.security.user.password.
默认情况下，您在 Web 应用程序中获得的基本功能包括：
-
一个
UserDetailsService（或ReactiveUserDetailsService如果是 WebFlux 应用程序），则具有内存存储和具有生成密码的单个用户（参见SecurityProperties.User对于用户的属性）。 -
基于表单的登录或 HTTP Basic 安全性（取决于
Accept标头）对于整个应用程序（如果 Actuator 在 Classpath 上，则包括 Actuator 端点）。 -
一个
DefaultAuthenticationEventPublisher用于发布身份验证事件。
您可以提供不同的AuthenticationEventPublisher通过为其添加 Bean 来获取。
4.1. MVC 安全性
默认安全配置在SecurityAutoConfiguration和UserDetailsServiceAutoConfiguration.SecurityAutoConfiguration进口SpringBootWebSecurityConfiguration用于 Web 安全，以及UserDetailsServiceAutoConfiguration配置身份验证，这在非 Web 应用程序中也相关。
要完全关闭默认的 Web 应用程序安全配置或组合多个 Spring Security 组件（例如 OAuth2 客户端和资源服务器），请添加SecurityFilterChain（这样做不会禁用UserDetailsServiceconfiguration 或 Actuator 的安全性）。
要同时关闭UserDetailsServiceconfiguration 中，您可以添加UserDetailsService,AuthenticationProvider或AuthenticationManager.
可以通过添加自定义SecurityFilterChain豆。
Spring Boot 提供了方便的方法，可用于覆盖 actuator endpoints 和 static 资源的访问规则。EndpointRequest可用于创建RequestMatcher基于management.endpoints.web.base-path财产。PathRequest可用于创建RequestMatcher以获取常用位置中的资源。
4.2. WebFlux 安全
与 Spring MVC 应用程序类似，您可以通过添加spring-boot-starter-securityDependency。
默认安全配置在ReactiveSecurityAutoConfiguration和UserDetailsServiceAutoConfiguration.ReactiveSecurityAutoConfiguration进口WebFluxSecurityConfiguration用于 Web 安全，以及UserDetailsServiceAutoConfiguration配置身份验证，这在非 Web 应用程序中也相关。
要完全关闭默认的 Web 应用程序安全性配置，可以添加WebFilterChainProxy（这样做不会禁用UserDetailsServiceconfiguration 或 Actuator 的安全性）。
要同时关闭UserDetailsServiceconfiguration 中，您可以添加ReactiveUserDetailsService或ReactiveAuthenticationManager.
访问规则和多个 Spring Security 组件（如 OAuth 2 客户端和资源服务器）的使用可以通过添加自定义SecurityWebFilterChain豆。
Spring Boot 提供了方便的方法，可用于覆盖 actuator endpoints 和 static 资源的访问规则。EndpointRequest可用于创建ServerWebExchangeMatcher基于management.endpoints.web.base-path财产。
PathRequest可用于创建ServerWebExchangeMatcher以获取常用位置中的资源。
例如，您可以通过添加如下内容来自定义您的安全配置：
@Configuration(proxyBeanMethods = false)
public class MyWebFluxSecurityConfiguration {
@Bean
public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
http.authorizeExchange((exchange) -> {
exchange.matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll();
exchange.pathMatchers("/foo", "/bar").authenticated();
});
http.formLogin(withDefaults());
return http.build();
}
}
@Configuration(proxyBeanMethods = false)
class MyWebFluxSecurityConfiguration {
@Bean
fun springSecurityFilterChain(http: ServerHttpSecurity): SecurityWebFilterChain {
http.authorizeExchange { spec ->
spec.matchers(PathRequest.toStaticResources().atCommonLocations()).permitAll()
spec.pathMatchers("/foo", "/bar").authenticated()
}
http.formLogin(withDefaults())
return http.build()
}
}
4.3. OAuth2
OAuth2 是 Spring 支持的广泛使用的授权框架。
4.3.1. 客户端
如果你有spring-security-oauth2-client在您的 Classpath 上，您可以利用一些自动配置来设置 OAuth2/Open ID Connect 客户端。
此配置使用OAuth2ClientProperties.
相同的属性适用于 servlet 和 reactive 应用程序。
您可以在spring.security.oauth2.clientprefix，如以下示例所示：
spring.security.oauth2.client.registration.my-login-client.client-id=abcd
spring.security.oauth2.client.registration.my-login-client.client-secret=password
spring.security.oauth2.client.registration.my-login-client.client-name=Client for OpenID Connect
spring.security.oauth2.client.registration.my-login-client.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-login-client.scope=openid,profile,email,phone,address
spring.security.oauth2.client.registration.my-login-client.redirect-uri={baseUrl}/login/oauth2/code/{registrationId}
spring.security.oauth2.client.registration.my-login-client.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-login-client.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.my-client-1.client-id=abcd
spring.security.oauth2.client.registration.my-client-1.client-secret=password
spring.security.oauth2.client.registration.my-client-1.client-name=Client for user scope
spring.security.oauth2.client.registration.my-client-1.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-client-1.scope=user
spring.security.oauth2.client.registration.my-client-1.redirect-uri={baseUrl}/authorized/user
spring.security.oauth2.client.registration.my-client-1.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-client-1.authorization-grant-type=authorization_code
spring.security.oauth2.client.registration.my-client-2.client-id=abcd
spring.security.oauth2.client.registration.my-client-2.client-secret=password
spring.security.oauth2.client.registration.my-client-2.client-name=Client for email scope
spring.security.oauth2.client.registration.my-client-2.provider=my-oauth-provider
spring.security.oauth2.client.registration.my-client-2.scope=email
spring.security.oauth2.client.registration.my-client-2.redirect-uri={baseUrl}/authorized/email
spring.security.oauth2.client.registration.my-client-2.client-authentication-method=client_secret_basic
spring.security.oauth2.client.registration.my-client-2.authorization-grant-type=authorization_code
spring.security.oauth2.client.provider.my-oauth-provider.authorization-uri=https://my-auth-server.com/oauth2/authorize
spring.security.oauth2.client.provider.my-oauth-provider.token-uri=https://my-auth-server.com/oauth2/token
spring.security.oauth2.client.provider.my-oauth-provider.user-info-uri=https://my-auth-server.com/userinfo
spring.security.oauth2.client.provider.my-oauth-provider.user-info-authentication-method=header
spring.security.oauth2.client.provider.my-oauth-provider.jwk-set-uri=https://my-auth-server.com/oauth2/jwks
spring.security.oauth2.client.provider.my-oauth-provider.user-name-attribute=namespring:
security:
oauth2:
client:
registration:
my-login-client:
client-id: "abcd"
client-secret: "password"
client-name: "Client for OpenID Connect"
provider: "my-oauth-provider"
scope: "openid,profile,email,phone,address"
redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
client-authentication-method: "client_secret_basic"
authorization-grant-type: "authorization_code"
my-client-1:
client-id: "abcd"
client-secret: "password"
client-name: "Client for user scope"
provider: "my-oauth-provider"
scope: "user"
redirect-uri: "{baseUrl}/authorized/user"
client-authentication-method: "client_secret_basic"
authorization-grant-type: "authorization_code"
my-client-2:
client-id: "abcd"
client-secret: "password"
client-name: "Client for email scope"
provider: "my-oauth-provider"
scope: "email"
redirect-uri: "{baseUrl}/authorized/email"
client-authentication-method: "client_secret_basic"
authorization-grant-type: "authorization_code"
provider:
my-oauth-provider:
authorization-uri: "https://my-auth-server.com/oauth2/authorize"
token-uri: "https://my-auth-server.com/oauth2/token"
user-info-uri: "https://my-auth-server.com/userinfo"
user-info-authentication-method: "header"
jwk-set-uri: "https://my-auth-server.com/oauth2/jwks"
user-name-attribute: "name"对于支持 OpenID Connect 发现的 OpenID Connect 提供商，可以进一步简化配置。
提供程序需要配置一个issuer-uri，这是它断言为其颁发者标识符的 URI。
例如，如果issuer-uri如果是 “https://example.com”，则将向 “https://example.com/.well-known/openid-configuration” 发出“OpenID 提供程序配置请求”。
结果应为“OpenID Provider Configuration Response”。
以下示例显示了如何使用issuer-uri:
spring.security.oauth2.client.provider.oidc-provider.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/spring:
security:
oauth2:
client:
provider:
oidc-provider:
issuer-uri: "https://dev-123456.oktapreview.com/oauth2/default/"默认情况下，Spring Security 的OAuth2LoginAuthenticationFilter仅处理匹配的 URL/login/oauth2/code/*.
如果要自定义redirect-uri要使用其他模式，您需要提供配置来处理该自定义模式。
例如，对于 servlet 应用程序，您可以添加自己的SecurityFilterChain类似于以下内容：
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
public class MyOAuthClientConfiguration {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http
.authorizeHttpRequests((requests) -> requests
.anyRequest().authenticated()
)
.oauth2Login((login) -> login
.redirectionEndpoint((endpoint) -> endpoint
.baseUri("/login/oauth2/callback/*")
)
);
return http.build();
}
}
@Configuration(proxyBeanMethods = false)
@EnableWebSecurity
open class MyOAuthClientConfiguration {
@Bean
open fun securityFilterChain(http: HttpSecurity): SecurityFilterChain {
http {
authorizeHttpRequests {
authorize(anyRequest, authenticated)
}
oauth2Login {
redirectionEndpoint {
baseUri = "/login/oauth2/callback/*"
}
}
}
return http.build()
}
}
Spring Boot 会自动配置InMemoryOAuth2AuthorizedClientServiceSpring Security 使用它来管理 Client 端注册。
这InMemoryOAuth2AuthorizedClientService功能有限，我们建议仅将其用于开发环境。
对于生产环境，请考虑使用JdbcOAuth2AuthorizedClientService或创建您自己的OAuth2AuthorizedClientService. |
常见提供商的 OAuth2 客户端注册
对于常见的 OAuth2 和 OpenID 提供程序（包括 Google、Github、Facebook 和 Okta），我们提供了一组提供程序默认值 （google,github,facebook和okta）。
如果您不需要自定义这些提供程序，则可以设置provider属性设置为需要推断 defaults 的 URL。
此外，如果 Client 端注册的密钥与默认支持的提供程序匹配，则 Spring Boot 也会推断这一点。
换句话说，以下示例中的两个配置使用 Google 提供程序：
spring.security.oauth2.client.registration.my-client.client-id=abcd
spring.security.oauth2.client.registration.my-client.client-secret=password
spring.security.oauth2.client.registration.my-client.provider=google
spring.security.oauth2.client.registration.google.client-id=abcd
spring.security.oauth2.client.registration.google.client-secret=passwordspring:
security:
oauth2:
client:
registration:
my-client:
client-id: "abcd"
client-secret: "password"
provider: "google"
google:
client-id: "abcd"
client-secret: "password"4.3.2. 资源服务器
如果你有spring-security-oauth2-resource-server在你的 Classpath 上，Spring Boot 可以设置一个 OAuth2 资源服务器。
对于 JWT 配置，需要指定 JWK Set URI 或 OIDC Issuer URI，如以下示例所示：
spring.security.oauth2.resourceserver.jwt.jwk-set-uri=https://example.com/oauth2/default/v1/keysspring:
security:
oauth2:
resourceserver:
jwt:
jwk-set-uri: "https://example.com/oauth2/default/v1/keys"spring.security.oauth2.resourceserver.jwt.issuer-uri=https://dev-123456.oktapreview.com/oauth2/default/spring:
security:
oauth2:
resourceserver:
jwt:
issuer-uri: "https://dev-123456.oktapreview.com/oauth2/default/"如果授权服务器不支持 JWK 集 URI，则可以使用用于验证 JWT 签名的公钥来配置资源服务器。
这可以使用spring.security.oauth2.resourceserver.jwt.public-key-location属性，其中该值需要指向包含 PEM 编码的 x509 格式的公钥的文件。 |
这spring.security.oauth2.resourceserver.jwt.audiences属性可用于指定 JWT 中 aud 声明的预期值。
例如，要求 JWT 包含值为my-audience:
spring.security.oauth2.resourceserver.jwt.audiences[0]=my-audiencespring:
security:
oauth2:
resourceserver:
jwt:
audiences:
- "my-audience"相同的属性适用于 servlet 和响应式应用程序。
或者，您可以定义自己的JwtDecoderbean 用于 servlet 应用程序或ReactiveJwtDecoder用于响应式应用。
如果使用不透明令牌而不是 JWT，您可以配置以下属性以通过自省验证令牌：
spring.security.oauth2.resourceserver.opaquetoken.introspection-uri=https://example.com/check-token
spring.security.oauth2.resourceserver.opaquetoken.client-id=my-client-id
spring.security.oauth2.resourceserver.opaquetoken.client-secret=my-client-secretspring:
security:
oauth2:
resourceserver:
opaquetoken:
introspection-uri: "https://example.com/check-token"
client-id: "my-client-id"
client-secret: "my-client-secret"同样，相同的属性适用于 servlet 和 reactive 应用程序。
或者，您可以定义自己的OpaqueTokenIntrospectorbean 用于 servlet 应用程序或ReactiveOpaqueTokenIntrospector用于响应式应用。
4.3.3. 授权服务器
如果你有spring-security-oauth2-authorization-server在你的 Classpath 上，你可以利用一些自动配置来设置基于 Servlet 的 OAuth2 授权服务器。
您可以在spring.security.oauth2.authorizationserver.clientprefix，如以下示例所示：
spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-id=abcd
spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-secret={noop}secret1
spring.security.oauth2.authorizationserver.client.my-client-1.registration.client-authentication-methods[0]=client_secret_basic
spring.security.oauth2.authorizationserver.client.my-client-1.registration.authorization-grant-types[0]=authorization_code
spring.security.oauth2.authorizationserver.client.my-client-1.registration.authorization-grant-types[1]=refresh_token
spring.security.oauth2.authorizationserver.client.my-client-1.registration.redirect-uris[0]=https://my-client-1.com/login/oauth2/code/abcd
spring.security.oauth2.authorizationserver.client.my-client-1.registration.redirect-uris[1]=https://my-client-1.com/authorized
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[0]=openid
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[1]=profile
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[2]=email
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[3]=phone
spring.security.oauth2.authorizationserver.client.my-client-1.registration.scopes[4]=address
spring.security.oauth2.authorizationserver.client.my-client-1.require-authorization-consent=true
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-id=efgh
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-secret={noop}secret2
spring.security.oauth2.authorizationserver.client.my-client-2.registration.client-authentication-methods[0]=client_secret_jwt
spring.security.oauth2.authorizationserver.client.my-client-2.registration.authorization-grant-types[0]=client_credentials
spring.security.oauth2.authorizationserver.client.my-client-2.registration.scopes[0]=user.read
spring.security.oauth2.authorizationserver.client.my-client-2.registration.scopes[1]=user.write
spring.security.oauth2.authorizationserver.client.my-client-2.jwk-set-uri=https://my-client-2.com/jwks
spring.security.oauth2.authorizationserver.client.my-client-2.token-endpoint-authentication-signing-algorithm=RS256spring:
security:
oauth2:
authorizationserver:
client:
my-client-1:
registration:
client-id: "abcd"
client-secret: "{noop}secret1"
client-authentication-methods:
- "client_secret_basic"
authorization-grant-types:
- "authorization_code"
- "refresh_token"
redirect-uris:
- "https://my-client-1.com/login/oauth2/code/abcd"
- "https://my-client-1.com/authorized"
scopes:
- "openid"
- "profile"
- "email"
- "phone"
- "address"
require-authorization-consent: true
my-client-2:
registration:
client-id: "efgh"
client-secret: "{noop}secret2"
client-authentication-methods:
- "client_secret_jwt"
authorization-grant-types:
- "client_credentials"
scopes:
- "user.read"
- "user.write"
jwk-set-uri: "https://my-client-2.com/jwks"
token-endpoint-authentication-signing-algorithm: "RS256"这client-secret属性的格式必须与配置的PasswordEncoder.
默认的PasswordEncoder通过以下方式创建PasswordEncoderFactories.createDelegatingPasswordEncoder(). |
Spring Boot 为 Spring Authorization Server 提供的自动配置旨在快速入门。 大多数应用程序都需要定制，并且希望定义多个 bean 以覆盖自动配置。
可以将以下组件定义为 bean 以覆盖特定于 Spring Authorization Server 的自动配置：
-
RegisteredClientRepository -
AuthorizationServerSettings -
SecurityFilterChain -
com.nimbusds.jose.jwk.source.JWKSource<com.nimbusds.jose.proc.SecurityContext> -
JwtDecoder
Spring Boot 会自动配置InMemoryRegisteredClientRepositorySpring Authorization Server 使用它来管理已注册的 Client 端。
这InMemoryRegisteredClientRepository功能有限，我们建议仅将其用于开发环境。
对于生产环境，请考虑使用JdbcRegisteredClientRepository或创建您自己的RegisteredClientRepository. |
其他信息可以在 Spring Authorization Server Reference Guide 的 Getting Started 章节中找到。
4.4. SAML 2.0
4.4.1. 依赖方
如果你有spring-security-saml2-service-provider在您的 Classpath 上，您可以利用一些自动配置来设置 SAML 2.0 依赖方。
此配置使用Saml2RelyingPartyProperties.
信赖方注册表示身份提供程序 （IDP） 和服务提供商 （SP） 之间的配对配置。
您可以在spring.security.saml2.relyingpartyprefix，如以下示例所示：
spring.security.saml2.relyingparty.registration.my-relying-party1.signing.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party1.signing.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party1.decryption.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party1.decryption.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.url=https://myapp/logout/saml2/slo
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.response-url=https://remoteidp2.slo.url
spring.security.saml2.relyingparty.registration.my-relying-party1.singlelogout.binding=POST
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.verification.credentials[0].certificate-location=path-to-verification-cert
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.entity-id=remote-idp-entity-id1
spring.security.saml2.relyingparty.registration.my-relying-party1.assertingparty.sso-url=https://remoteidp1.sso.url
spring.security.saml2.relyingparty.registration.my-relying-party2.signing.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party2.signing.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party2.decryption.credentials[0].private-key-location=path-to-private-key
spring.security.saml2.relyingparty.registration.my-relying-party2.decryption.credentials[0].certificate-location=path-to-certificate
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.verification.credentials[0].certificate-location=path-to-other-verification-cert
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.entity-id=remote-idp-entity-id2
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.sso-url=https://remoteidp2.sso.url
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.url=https://remoteidp2.slo.url
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.response-url=https://myapp/logout/saml2/slo
spring.security.saml2.relyingparty.registration.my-relying-party2.assertingparty.singlelogout.binding=POSTspring:
security:
saml2:
relyingparty:
registration:
my-relying-party1:
signing:
credentials:
- private-key-location: "path-to-private-key"
certificate-location: "path-to-certificate"
decryption:
credentials:
- private-key-location: "path-to-private-key"
certificate-location: "path-to-certificate"
singlelogout:
url: "https://myapp/logout/saml2/slo"
response-url: "https://remoteidp2.slo.url"
binding: "POST"
assertingparty:
verification:
credentials:
- certificate-location: "path-to-verification-cert"
entity-id: "remote-idp-entity-id1"
sso-url: "https://remoteidp1.sso.url"
my-relying-party2:
signing:
credentials:
- private-key-location: "path-to-private-key"
certificate-location: "path-to-certificate"
decryption:
credentials:
- private-key-location: "path-to-private-key"
certificate-location: "path-to-certificate"
assertingparty:
verification:
credentials:
- certificate-location: "path-to-other-verification-cert"
entity-id: "remote-idp-entity-id2"
sso-url: "https://remoteidp2.sso.url"
singlelogout:
url: "https://remoteidp2.slo.url"
response-url: "https://myapp/logout/saml2/slo"
binding: "POST"对于 SAML2 注销，默认情况下， Spring Security 的Saml2LogoutRequestFilter和Saml2LogoutResponseFilter仅处理匹配的 URL/logout/saml2/slo.
如果要自定义urlAP 发起的注销请求将发送到哪个 AP 或response-urlAP 向其发送注销响应，要使用其他模式，您需要提供配置以处理该自定义模式。
例如，对于 servlet 应用程序，您可以添加自己的SecurityFilterChain类似于以下内容：
@Configuration(proxyBeanMethods = false)
public class MySamlRelyingPartyConfiguration {
@Bean
public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
http.authorizeHttpRequests((requests) -> requests.anyRequest().authenticated());
http.saml2Login(withDefaults());
http.saml2Logout((saml2) -> saml2.logoutRequest((request) -> request.logoutUrl("/SLOService.saml2"))
.logoutResponse((response) -> response.logoutUrl("/SLOService.saml2")));
return http.build();
}
}
5. Spring Session
Spring Boot 为各种数据存储提供 Spring Session 自动配置。 在构建 servlet Web 应用程序时，可以自动配置以下存储：
-
Redis
-
JDBC
-
Hazelcast
-
MongoDB 数据库
servlet 自动配置取代了使用@Enable*HttpSession.
如果 Classpath 上存在单个 Spring Session 模块，则 Spring Boot 会自动使用该 store 实现。 如果您有多个实现，则 Spring Boot 使用以下 Sequences 来选择特定实现：
-
Redis
-
JDBC
-
Hazelcast
-
MongoDB 数据库
-
如果 Redis、JDBC、Hazelcast 和 MongoDB 都不可用，我们不会配置
SessionRepository.
在构建反应式 Web 应用程序时，可以自动配置以下 store：
-
Redis
-
MongoDB 数据库
reactive 自动配置取代了使用@Enable*WebSession.
与 Servlet 配置类似，如果你有多个实现，Spring Boot 使用以下 Sequences 来选择特定的实现：
-
Redis
-
MongoDB 数据库
-
如果 Redis 和 MongoDB 都不可用，我们不会配置
ReactiveSessionRepository.
每个商店都有特定的附加设置。 例如，可以自定义 JDBC 存储的表的名称，如以下示例所示：
spring.session.jdbc.table-name=SESSIONSspring:
session:
jdbc:
table-name: "SESSIONS"要设置会话的超时，您可以使用spring.session.timeout财产。
如果未使用 servlet Web 应用程序设置该属性，则自动配置将回退到server.servlet.session.timeout.
你可以使用 Spring Session 的配置来控制@Enable*HttpSession（servlet） 或@Enable*WebSession（反应式）。
这将导致自动配置回退。
然后可以使用 Comments 的属性而不是前面描述的配置属性来配置 Spring Session。
6. 适用于 GraphQL 的 Spring
如果要构建 GraphQL 应用程序，可以利用 Spring Boot 对 Spring for GraphQL 的自动配置。
Spring for GraphQL 项目基于 GraphQL Java。
您将需要spring-boot-starter-graphqlstarter 的最小值。
由于 GraphQL 与传输无关，因此您还需要在应用程序中添加一个或多个额外的Starters，以便在 Web 上公开 GraphQL API：
| 起动机 | 运输 | 实现 |
|---|---|---|
|
HTTP 协议 |
Spring MVC |
|
WebSocket 浏览器 |
用于 Servlet 应用程序的 WebSocket |
|
HTTP、WebSocket |
Spring WebFlux |
|
TCP、WebSocket |
Reactor Netty 上的 Spring WebFlux |
6.1. GraphQL 架构
Spring GraphQL 应用程序在启动时需要定义的架构。
默认情况下，您可以在src/main/resources/graphql/**Spring Boot 将自动选取它们。
您可以使用spring.graphql.schema.locations和带有spring.graphql.schema.file-extensions.
如果您希望 Spring Boot 检测该位置的所有应用程序模块和依赖项中的 schema 文件，
您可以设置spring.graphql.schema.locations自"classpath*:graphql/**/"（请注意classpath*:前缀）。 |
在以下部分中，我们将考虑此示例 GraphQL 架构，定义两种类型和两种查询：
type Query {
greeting(name: String! = "Spring"): String!
project(slug: ID!): Project
}
""" A Project in the Spring portfolio """
type Project {
""" Unique string id used in URLs """
slug: ID!
""" Project name """
name: String!
""" URL of the git repository """
repositoryUrl: String!
""" Current support status """
status: ProjectStatus!
}
enum ProjectStatus {
""" Actively supported by the Spring team """
ACTIVE
""" Supported by the community """
COMMUNITY
""" Prototype, not officially supported yet """
INCUBATING
""" Project being retired, in maintenance mode """
ATTIC
""" End-Of-Lifed """
EOL
}默认情况下，架构上将允许现场自省，因为 GraphiQL 等工具需要它。
如果您不想公开有关架构的信息，可以通过设置spring.graphql.schema.introspection.enabled自false. |
6.2. GraphQL 运行时布线
The GraphQL JavaRuntimeWiring.Builder可用于注册自定义标量类型、指令、类型解析器、DataFetcher等。
您可以声明RuntimeWiringConfigurerbeans 来访问RuntimeWiring.Builder.
Spring Boot 会检测此类 bean 并将它们添加到 GraphQlSource 构建器中。
但是，应用程序通常不会实现DataFetcher直接创建带注释的控制器。
Spring Boot 将自动检测@Controller类，并将其注册为DataFetchers.
以下是我们的问候查询的示例实现，其中@Controller类：
@Controller
public class GreetingController {
@QueryMapping
public String greeting(@Argument String name) {
return "Hello, " + name + "!";
}
}
@Controller
class GreetingController {
@QueryMapping
fun greeting(@Argument name: String): String {
return "Hello, $name!"
}
}
6.3. Querydsl 和 QueryByExample 存储库支持
Spring Data 提供对 Querydsl 和 QueryByExample 存储库的支持。
Spring GraphQL 可以将 Querydsl 和 QueryByExample 存储库配置为DataFetcher.
带注释的 Spring Data 存储库@GraphQlRepository以及扩展 one of：
-
QuerydslPredicateExecutor -
ReactiveQuerydslPredicateExecutor -
QueryByExampleExecutor -
ReactiveQueryByExampleExecutor
被 Spring Boot 检测到并被视为DataFetcher用于匹配的顶级查询。
6.4. 传输
6.4.1. HTTP 和 WebSocket
GraphQL HTTP 终端节点位于 HTTP POST/graphql默认情况下。
路径可以使用spring.graphql.path.
Spring MVC 和 Spring WebFlux 的 HTTP 端点都由RouterFunction带有@Order之0.
如果您定义自己的RouterFunctionbeans 中，您可能希望添加适当的@Order注解，以确保它们被正确排序。 |
默认情况下，GraphQL WebSocket 终端节点处于关闭状态。要启用它：
-
对于 Servlet 应用程序，请添加 WebSocket Starters
spring-boot-starter-websocket -
对于 WebFlux 应用程序，不需要额外的依赖项
-
对于这两个对象，
spring.graphql.websocket.path必须设置 application 属性
Spring GraphQL 提供了一个 Web 拦截模型。
这对于从 HTTP 请求标头中检索信息并在 GraphQL 上下文中设置信息或从同一上下文获取信息并将其写入响应标头非常有用。
使用 Spring Boot，您可以声明WebInterceptorbean 将其注册到 Web 传输中。
Spring MVC 和 Spring WebFlux 支持 CORS（跨域资源共享）请求。 CORS 是 GraphQL 应用程序的 Web 配置的关键部分，这些应用程序可以从使用不同域的浏览器访问。
Spring Boot 在spring.graphql.cors.*Namespace;下面是一个简短的配置示例：
spring.graphql.cors.allowed-origins=https://example.org
spring.graphql.cors.allowed-methods=GET,POST
spring.graphql.cors.max-age=1800sspring:
graphql:
cors:
allowed-origins: "https://example.org"
allowed-methods: GET,POST
max-age: 1800s6.4.2. RSocket
还支持将 RSocket 作为 WebSocket 或 TCP 之上的传输。
配置 RSocket 服务器后，我们可以使用spring.graphql.rsocket.mapping.
例如，将该映射配置为"graphql"意味着我们可以在使用RSocketGraphQlClient.
Spring Boot 会自动配置RSocketGraphQlClient.Builder<?>bean 中可以注入到组件中：
@Component
public class RSocketGraphQlClientExample {
private final RSocketGraphQlClient graphQlClient;
public RSocketGraphQlClientExample(RSocketGraphQlClient.Builder<?> builder) {
this.graphQlClient = builder.tcp("example.spring.io", 8181).route("graphql").build();
}
@Component
class RSocketGraphQlClientExample(private val builder: RSocketGraphQlClient.Builder<*>) {
然后发送请求：
Mono<Book> book = this.graphQlClient.document("{ bookById(id: \"book-1\"){ id name pageCount author } }")
.retrieve("bookById")
.toEntity(Book.class);
val book = graphQlClient.document(
"""
{
bookById(id: "book-1"){
id
name
pageCount
author
}
}
"""
)
.retrieve("bookById").toEntity(Book::class.java)
6.5. 异常处理
Spring GraphQL 使应用程序能够注册一个或多个 SpringDataFetcherExceptionResolver按顺序调用的组件。
异常必须解析为graphql.GraphQLError对象，请参阅 Spring GraphQL 异常处理文档。
Spring Boot 将自动检测DataFetcherExceptionResolverbean 并将它们注册到GraphQlSource.Builder.
6.6. GraphiQL 和 Schema 打印机
Spring GraphQL 提供了基础设施，可帮助开发人员使用或开发 GraphQL API。
Spring GraphQL 附带一个默认的 GraphiQL 页面，该页面在"/graphiql"默认情况下。
默认情况下，此页面处于禁用状态，可以使用spring.graphql.graphiql.enabled财产。
许多公开此类页面的应用程序将首选自定义版本。
默认实现在开发过程中非常有用，这就是为什么它会自动公开spring-boot-devtools在开发过程中。
您还可以选择以文本格式公开 GraphQL 架构，网址为/graphql/schema当spring.graphql.schema.printer.enabled属性已启用。
7. Spring HATEOAS
如果您开发使用超媒体的 RESTful API，Spring Boot 将为 Spring HATEOAS 提供自动配置，该配置适用于大多数应用程序。
自动配置取代了使用@EnableHypermediaSupport并注册了大量 bean 以简化基于超媒体的应用程序的构建，包括LinkDiscoverers（用于客户端支持）和ObjectMapper配置为将响应正确封送到所需的表示形式中。
这ObjectMapper通过设置各种spring.jackson.*属性，或者，如果存在，则通过Jackson2ObjectMapperBuilder豆。
你可以通过使用@EnableHypermediaSupport.
请注意，这样做会禁用ObjectMapper自定义。
spring-boot-starter-hateoas特定于 Spring MVC，不应与 Spring WebFlux 结合使用。
为了将 Spring HATEOAS 与 Spring WebFlux 一起使用，您可以添加对org.springframework.hateoas:spring-hateoas以及spring-boot-starter-webflux. |
默认情况下，接受application/json将收到一个application/hal+json响应。
要禁用此行为，请将spring.hateoas.use-hal-as-default-json-media-type自false并定义一个HypermediaMappingInformation或HalConfiguration配置 Spring HATEOAS 以满足您的应用程序及其客户端的需求。