IDEA项目实践——SpringBoot当中RestController、GetMapping、PostMapping、SpringBootApplication以及web服务器

 @RestController
 @RequestMapping("/api")
 public class UserController {
     
     @GetMapping("/users/{id}")
     public User getUser(@PathVariable int id) {
         // code to fetch user from database
         User user = userService.getUserById(id);
         return user;
     }
     
     @PostMapping("/users")
     public User createUser(@RequestBody User user) {
         // code to create a new user
         User newUser = userService.createUser(user);
         return newUser;
     }
     
     // other methods...
 }

在上面的示例中，类用注释标记。它有两种方法：和 .和注释用于将这些方法映射到特定 URL（分别为和）。UserController``@RestController``getUser()``createUser()``@GetMapping``@PostMapping``/users/{id}``/users

该方法将 a 作为路径变量并返回一个对象。该方法将对象作为请求正文，并返回新创建的对象。这些方法的返回值会自动序列化为 JSON 格式，并作为响应正文发送。getUser()``id``User``createUser()``User``User

通过使用注释，Spring 框架负责处理 HTTP 请求和响应，从而更轻松地在 Java 中构建 RESTful Web 服务。@RestController

@RestController、@Controller和@ResponseBody是Spring框架中用于构建Web应用程序的注解。

1.3 RestController与Controller和ResponseBody的区别与联系

@RestController是一个组合注解，它将@Controller和@ResponseBody注解合并在一起。它的作用是将一个类标记为REST控制器，表示该类处理HTTP请求并返回响应数据。在@RestController类中的所有方法都会自动映射到特定的URL，并且方法的返回值会自动序列化为HTTP响应的响应体。

@Controller是一个注解，用于标记一个类作为控制器组件。它告诉Spring框架该类是一个控制器，并且可以处理HTTP请求。通常，@Controller类的方法会返回一个逻辑视图名称，然后由视图解析器解析为实际的视图。

@ResponseBody是一个注解，用于标记一个方法或类的方法，指示该方法的返回值应该直接写入HTTP响应体中，而不是通过视图解析器解析为视图。它可以用于处理RESTful请求，将方法的返回值直接序列化为JSON、XML或其他格式的响应数据。

联系：

@RestController是@Controller和@ResponseBody的组合注解，它将两者的功能合并在一起。@RestController类中的方法会自动将返回值序列化为HTTP响应的响应体，并且不需要额外的@ResponseBody注解。
@Controller和@RestController都可以用于标记一个类作为控制器组件，用于处理HTTP请求。它们的主要区别是@RestController类中的方法默认情况下会将返回值序列化为响应体，而@Controller类中的方法通常返回逻辑视图名称。
@ResponseBody注解可以用于标记一个方法或类的方法，指示该方法的返回值应该直接写入HTTP响应体中。它通常与@Controller一起使用，以将方法的返回值序列化为响应数据，而不是视图。在@RestController中，@ResponseBody注解是隐式的，不需要额外的注解。

二 GetMapping与PostMapping简介以及区别

2.1 `@GetMapping`和`@PostMapping`的简介

@GetMapping和@PostMapping是Spring框架中的注解，用于将HTTP请求映射到特定的方法上。它们是@RequestMapping注解的缩写形式，用于处理GET和POST请求。

@GetMapping注解用于将HTTP GET请求映射到方法上。它可以用于类级别和方法级别的注解。当使用@GetMapping注解时，可以指定一个URL路径，当客户端发送GET请求到该URL时，Spring会调用相应的方法来处理请求。

2.2 相关案例

下面是一个使用@GetMapping的简单示例：

 @RestController
 @RequestMapping("/api")
 public class UserController {
     
     @GetMapping("/users/{id}")
     public User getUser(@PathVariable int id) {
         // code to fetch user from database
         User user = userService.getUserById(id);
         return user;
     }
     
     // other methods...
 }

在上面的示例中，getUser()方法使用了@GetMapping注解，并指定了URL路径为/users/{id}。当客户端发送GET请求到/api/users/{id}时，Spring会调用getUser()方法来处理请求。

@PostMapping注解用于将HTTP POST请求映射到方法上。它的用法和@GetMapping类似，只是用于处理POST请求而不是GET请求。

下面是一个使用@PostMapping的简单示例：

 @RestController
 @RequestMapping("/api")
 public class UserController {
     
     @PostMapping("/users")
     public User createUser(@RequestBody User user) {
         // code to create a new user
         User newUser = userService.createUser(user);
         return newUser;
     }
     
     // other methods...
 }

在上面的示例中，createUser()方法使用了@PostMapping注解，并指定了URL路径为/users。当客户端发送POST请求到/api/users时，Spring会调用createUser()方法来处理请求。

2.3 两者的区别

区别：

@GetMapping用于处理GET请求，而@PostMapping用于处理POST请求。
@GetMapping将HTTP请求映射到方法时，请求的参数会以查询字符串的形式附加在URL上，而@PostMapping将请求的参数放在请求体中。
@GetMapping和@PostMapping可以用于类级别和方法级别的注解，用于处理不同层级的请求。
@GetMapping和@PostMapping都可以指定URL路径，当客户端发送请求到该URL时，Spring会调用相应的方法来处理请求。

补充：spring与springboot的配置文件区别

三 SpringBootApplication 注解

3.1 SpringBootApplication简介

许多Spring Boot开发者希望他们的应用程序能够使用自动配置、组件扫描，并且能够在他们的 "application class "上定义额外的配置。一个 @SpringBootApplication 注解就可以用来启用这三个功能，如下。

@EnableAutoConfiguration：启用Spring Boot的自动配置机制。
@ComponentScan：对应用程序所在的包启用 @Component 扫描（见最佳实践）。
@SpringBootConfiguration：允许在Context中注册额外的Bean或导入额外的配置类。这是Spring标准的 @Configuration 的替代方案，有助于在你的集成测试中检测配置。

 // Same as @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan
 @SpringBootApplication
 public class MyApplication {
 
     public static void main(String[] args) {
         SpringApplication.run(MyApplication.class, args);
     }
 
 }

这些功能都不是强制必须的，你可以随时只使用其中任意功能的注解。例如，你不需要在你的应用程序中使用组件扫描或配置属性扫描。

3.2 SpringBootApplication相关案例

 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.SpringBootConfiguration;
 import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
 import org.springframework.context.annotation.Import;
 @SpringBootConfiguration(proxyBeanMethods = false)
 @EnableAutoConfiguration
 @Import({ SomeConfiguration.class, AnotherConfiguration.class })
 public class MyApplication {
     public static void main(String[] args) {
         SpringApplication.run(MyApplication.class, args);
     }
 }

在这个例子中，MyApplication 和其他Spring Boot应用程序一样，只是不能自动检测到 @Component 和 @ConfigurationProperties 注解的类，而是明确导入用户定义的Bean（见 @Import）。

四 SpringBoot的嵌入式WEB服务器

每个Spring Boot Web应用程序都包括一个嵌入式Web服务器。这一特性导致了一些操作问题，包括如何改变嵌入式服务器以及如何配置嵌入式服务器。本节将回答这些问题。

4.1 使用其他的Web服务

许多Spring Boot starter 包括默认的嵌入式容器。

对于 servlet stack 应用程序，spring-boot-starter-web 通过包含 spring-boot-starter-tomcat 来包含Tomcat，但是你可以使用 spring-boot-starter-jetty 或 spring-boot-starter-undertow 来代替。
对于 reactive stack 应用程序，spring-boot-starter-webflux 通过包括 spring-boot-starter-reactor-netty 包括Reactor Netty，但你可以使用 spring-boot-starter-tomcat， spring-boot-starter-jetty，或 spring-boot-starter-undertow 代替。

当切换到不同的HTTP服务器时，你需要把默认的依赖关系换成你需要的那些。为了帮助完成这一过程，Spring Boot为每个支持的HTTP服务器提供了一个单独的starter。

下面的Maven示例展示了如何为Spring MVC排除Tomcat并包含Jetty。

 <properties>
     <servlet-api.version>3.1.0</servlet-api.version>
 </properties>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <exclusions>
         <!-- 排除对Tomcat依赖 -->
         <exclusion>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-tomcat</artifactId>
         </exclusion>
     </exclusions>
 </dependency>
 <!-- 使用 Jetty 代替 -->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jetty</artifactId>
 </dependency>

servlet API的版本已被覆盖，因为与Tomcat 9和Undertow 2不同，Jetty 9.4不支持Servlet 4.0。

如果你想使用Jetty 10，它确实支持servlet 4.0，你可以按照下面的例子来做。

 <properties>
     <jetty.version>10.0.8</jetty.version>
 </properties>
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-web</artifactId>
     <exclusions>
         <!-- Exclude the Tomcat dependency -->
         <exclusion>
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-tomcat</artifactId>
         </exclusion>
     </exclusions>
 </dependency>
 <!-- Use Jetty instead -->
 <dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-jetty</artifactId>
     <exclusions>
         <!-- Exclude the Jetty-9 specific dependencies -->
         <exclusion>
             <groupId>org.eclipse.jetty.websocket</groupId>
             <artifactId>websocket-server</artifactId>
         </exclusion>
         <exclusion>
             <groupId>org.eclipse.jetty.websocket</groupId>
             <artifactId>javax-websocket-server-impl</artifactId>
         </exclusion>
     </exclusions>
 </dependency>

请注意，除了排除Tomcat starter之外，还需要排除一些Jetty9特有的依赖关系。

下面的Gradle例子配置了必要的依赖关系和模块替换，以便在Spring WebFlux中使用Undertow代替Reactor Netty。

 dependencies {
     implementation "org.springframework.boot:spring-boot-starter-undertow"
     implementation "org.springframework.boot:spring-boot-starter-webflux"
     modules {
         module("org.springframework.boot:spring-boot-starter-reactor-netty") {
             replacedBy("org.springframework.boot:spring-boot-starter-undertow", "Use Undertow instead of Reactor Netty")
         }
     }
 }

spring-boot-starter-reactor-netty 需要使用 WebClient 类，所以你可能需要保持对Netty的依赖，即使你需要包含一个不同的HTTP服务器。

4.2 禁用Web服务器

如果你的classpath包含启动Web服务器的必要位，Spring Boot将自动启动它。要禁用这种行为，请在你的 application.properties 中配置 WebApplicationType，如以下例子所示。

 spring.main.web-application-type=none

4.3 修改HTTP端口

在一个独立的应用程序中，主要的HTTP端口默认为 8080，但可以用 server.port 来设置（例如，在 application.properties 中或作为一个系统属性）。由于放松了对 Environment 值的绑定，你也可以使用 SERVER_PORT（例如，作为一个操作系统环境变量）。

要完全关闭HTTP端点，但仍然创建一个 WebApplicationContext，使用 server.port=-1 （这样做有时对测试很有用）。

更多细节，请参阅 "Spring Boot特性" 部分的 “web.html”，或 ServerProperties 源代码。

4.4 使用一个随机的未分配的HTTP端口

要扫描一个空闲的端口（使用操作系统的本地端口以防止冲突），使用 server.port=0。

4.5 在运行时发现HTTP端口

你可以从日志输出或从 WebServerApplicationContext 中通过其 WebServer 访问服务器正在运行的端口。获得该信息并确定其已被初始化的最好方法是添加一个 @Bean 类型的 ApplicationListener<WebServerInitializedEvent> 并在事件发布时将容器拉出。

使用 @SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT) 的测试也可以通过使用 @LocalServerPort 注解将实际端口注入一个字段，如下例所示。

 @SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
 class MyWebIntegrationTests {
 
     @LocalServerPort
     int port;
 
     // ...
 
 }

@LocalServerPort 是 @Value("${local.server.port}") 的一个元注解。不要试图在普通应用程序中注入端口。正如我们刚刚看到的，该值只在容器被初始化后才被设置。与测试相反，应用程序代码回调会被提前处理（在值实际可用之前）。

4.6 启用HTTP响应压缩

Jetty、Tomcat、Reactor Netty和Undertow都支持HTTP响应压缩。它可以在 application.properties 中启用，如下所示。

 server.compression.enabled=true

默认情况下，响应必须至少有2048字节的长度才能进行压缩。你可以通过设置 server.compression.min-response-size 属性来配置这种行为。

默认情况下，只有当响应的内容类型是下列之一时才会被压缩。

text/html
text/xml
text/plain
text/css
text/javascript
application/javascript
application/json
application/xml

你可以通过设置 server.compression.mime-types 属性来配置这种行为。

4.7 配置 SSL

SSL可以通过设置各种 server.ssl.* 属性来声明性地配置，通常在 application.properties 或 application.yaml 中。下面的例子显示了使用Java KeyStore文件设置SSL属性。

 server.port=8443
 server.ssl.key-store=classpath:keystore.jks
 server.ssl.key-store-password=secret
 server.ssl.key-password=another-secret

下面的例子显示了使用PEM编码的证书和私钥文件设置SSL属性。

 server.port=8443
 server.ssl.certificate=classpath:my-cert.crt
 server.ssl.certificate-private-key=classpath:my-cert.key
 server.ssl.trust-certificate=classpath:ca-cert.crt

另外，SSL信任材料可以配置在一个 SSL bundle 中，并应用到Web服务器，如本例所示：

 server.port=8443
 server.ssl.bundle=example

关于所有支持的属性的细节，请参见 Ssl。

使用像前面例子那样的配置意味着应用程序不再支持8080端口的普通HTTP连接器。 Spring Boot不支持通过 application.properties 同时配置HTTP连接器和HTTPS连接器。如果你想同时拥有，你需要以编程方式配置其中一个。我们建议使用 application.properties 来配置HTTPS，因为HTTP连接器是两者中比较容易编程配置的。

4.8 配置 HTTP/2

你可以通过 server.http2.enabled 配置属性在你的Spring Boot应用程序中启用HTTP/2支持。h2（HTTP/2 over TLS）和 h2c（HTTP/2 over TCP）都被支持。要使用 h2，必须同时启用SSL。当SSL未被启用时，将使用 h2c。例如，当你的应用程序在一个执行 TLS termination的代理服务器后面运行时，你可能想使用 h2c。

4.8.1 Tomcat 和 HTTP/2

Spring Boot 默认使用 Tomcat 10.1.x，它支持 h2c 和 h2。另外，如果主机操作系统上安装了库和其依赖项，你可以使用 libtcnative 来支持 h2。

库目录必须被提供给JVM的库路径，如果还没有的话。你可以通过JVM参数来做到这一点，如 -Djava.library.path=/usr/local/opt/tomcat-native/lib。更多信息请见官方Tomcat文档。

4.8.2 Jetty 和 HTTP/2

为了支持HTTP/2，Jetty需要额外的 org.eclipse.jetty.http2:http2-server 依赖项。要使用 h2c 不需要其他依赖。要使用 h2，你还需要根据你的部署选择以下依赖项之一。

org.eclipse.jetty:jetty-alpn-java-server 以使用JDK内置支持。
org.eclipse.jetty:jetty-alpn-conscrypt-server 和 Conscrypt库

4.8.3 Reactor Netty 和 HTTP/2

spring-boot-webflux-starter 默认使用 Reactor Netty 作为服务器。 Reactor Netty支持 h2c 和 h2，开箱即用。为了获得最佳的运行性能，该服务器还支持带有本地库的 h2。

Spring Boot为 io.netty:netty-tcnative-boringssl-static "uber jar" 管理版本，包含所有平台的本地库。开发者可以选择使用 classifier 只导入所需的依赖项（见 Netty官方文档）。

4.8.4 Undertow 和 HTTP/2

Undertow支持 h2c 和 h2，开箱即用。

4.9 配置Web服务器

一般来说，你应该首先考虑使用许多可用的配置key之一，并通过在 application.properties 或 application.yaml 文件中添加新条目来定制你的Web服务器。（见 “发现外部属性的内置选项”）。server.* 命名空间在这里相当有用，它包括 server.tomcat.*、server.jetty.* 等命名空间，用于服务器的特定功能。参见 application-properties.html 的列表。

前面的章节已经涵盖了许多常见的用例，如压缩、SSL或HTTP/2。然而，如果你的用例不存在配置密钥，那么你应该看看 WebServerFactoryCustomizer。你可以声明这样一个组件，并获得与你的选择相关的服务器工厂的访问权：你应该为所选择的服务器（Tomcat, Jetty, Reactor Netty, Undertow）和所选择的Web栈（servlet或reactive）选择变量。

下面的例子是针对Tomcat的 spring-boot-starter-web（servlet stack）。

 @Component
 public class MyTomcatWebServerCustomizer implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {
 
     @Override
     public void customize(TomcatServletWebServerFactory factory) {
         // customize the factory here
     }
 
 }

Spring Boot在内部使用该基础设施来自动配置服务器。自动配置的 WebServerFactoryCustomizer Bean的顺序为 0，将在任何用户定义的自定义器之前被处理，除非它有一个明确的顺序说明。

一旦你使用定制器获得了对 WebServerFactory 的访问权，你就可以用它来配置特定的部分，如连接器、服务器资源或服务器本身—所有这些都使用服务器特定的API。

此外，Spring Boot还提供了。

Server	Servlet stack	Reactive stack
Tomcat	`TomcatServletWebServerFactory`	`TomcatReactiveWebServerFactory`
Jetty	`JettyServletWebServerFactory`	`JettyReactiveWebServerFactory`
Undertow	`UndertowServletWebServerFactory`	`UndertowReactiveWebServerFactory`
Reactor	N/A	`NettyReactiveWebServerFactory`

作为最后的手段，你也可以声明你自己的 WebServerFactory bean，它将覆盖Spring Boot提供的那个。当你这样做的时候，自动配置的自定义器仍然会应用在你的自定义工厂上，所以要小心使用这个选项。

4.10 添加 Servlet、 Filter、 Listener 到应用

在servlet stack应用程序中，也就是使用 spring-boot-starter-web，有两种方法可以将 Servlet、Filter、ServletContextListener 以及Servlet API支持的其他监听器添加到你的应用程序。

4.10.1 使用 Spring Bean 添加 Servlet、Filter、Listener

要通过使用Spring Bean来添加 Servlet、Filter 或Servlet *Listener，你必须为它提供一个 @Bean 定义。当你想注入配置或依赖时，这样做会非常有用。然而，你必须非常小心，不要让它们导致太多其他Bean的急切初始化，因为它们必须在应用生命周期的早期安装在容器中。(例如，让它们依赖你的 DataSource 或 JPA configuration 并不是一个好主意）。你可以通过在第一次使用时懒加载地初始化Bean而不是在初始化时初始化来解决这些限制。

在 Filter 和 Servlet 的情况下，你也可以通过添加 FilterRegistrationBean 或 ServletRegistrationBean 来添加映射和初始参数，代替或补充底层组件。

	如果在filter注册中没有指定 `dispatcherType`，就会使用 `REQUEST`。这与servlet规范的默认dispatcher类型一致。

像其他Spring Bean一样，你可以定义servlet过滤器bean的顺序；请确保检查 “web.html” 部分。

禁用注册一个Servlet或Filter

如前所述，任何 Servlet 或 Filter Bean都会自动在Servlet容器中注册。要禁用某个 Filter 或 Servlet Bean的注册，请为其创建一个注册Bean，并将其标记为禁用，如下面的例子中所示。

 @Configuration(proxyBeanMethods = false)
 public class MyFilterConfiguration {
 
     @Bean
     public FilterRegistrationBean<MyFilter> registration(MyFilter filter) {
         FilterRegistrationBean<MyFilter> registration = new FilterRegistrationBean<>(filter);
         registration.setEnabled(false);
         return registration;
     }
 
 }

4.10.2 通过扫描类路径添加 Servlet、Filter、Listener

@WebServlet、@WebFilter 和 @WebListener 注解的类可以通过用 @ServletComponentScan 注解一个 @Configuration 类，并指定包含你想注册的组件的包来自动注册到嵌入式Servlet容器。默认情况下， @ServletComponentScan 从被注解的类的包中扫描。

4.11 配置访问日志

可以通过各自的命名空间为Tomcat、Undertow和Jetty配置访问日志。

例如，以下设置在Tomcat上用自定义 pattern 记录访问。

 server.tomcat.basedir=my-tomcat
 server.tomcat.accesslog.enabled=true
 server.tomcat.accesslog.pattern=%t %a %r %s (%D ms)

NOTE:日志的默认位置是相对于Tomcat基础目录的 logs 目录。默认情况下，logs 目录是一个临时目录，所以你可能想固定Tomcat的基本目录，或者为日志使用一个绝对路径。在前面的例子中，相对于应用程序的工作目录，日志在 my-tomcat/logs 中可用。

Undertow的访问日志可以用类似的方式配置，如下面的例子所示。

 server.undertow.accesslog.enabled=true
 server.undertow.accesslog.pattern=%t %a %r %s (%D ms)
 server.undertow.options.server.record-request-start-time=true

注意，除了启用访问日志和配置其模式外，还启用了记录请求开始时间。当在访问日志模式中包括响应时间（%D）时，这是必需的。日志被存储在相对于应用程序工作目录的 logs 目录中。你可以通过设置 server.undertow.accesslog.dir 属性自定义这个位置。

最后，Jetty的访问日志也可以按以下方式配置。

 server.jetty.accesslog.enabled=true
 server.jetty.accesslog.filename=/var/log/jetty-access.log

默认情况下，日志被重定向到 System.err。更多细节，请参见Jetty文档。

4.12 运行在代理服务器后面

如果你的应用程序在代理、负载均衡器或云端运行，请求信息（如主机、端口、scheme……）可能会沿途改变。你的应用程序可能在 10.10.10.10:8080 上运行，但HTTP客户应该只看到 example.org。

RFC7239 "Forwarded Headers" 定义了转发的HTTP头；代理可以使用这个头来提供关于原始请求的信息。你可以配置你的应用程序来读取这些头信息，并在创建链接并在HTTP 302响应、JSON文档或HTML页面中发送给客户端时自动使用这些信息。还有一些非标准的头信息，如 X-Forwarded-Host、X-Forwarded-Port、X-Forwarded-Proto、X-Forwarded-Ssl 和 X-Forwarded-Prefix。

如果代理添加了常用的 X-Forwarded-For 和 X-Forwarded-Proto 头信息，将 server.forward-headers-strategy 设置为 NATIVE 就可以支持这些。有了这个选项，web服务器本身就支持这个功能；你可以查看它们的具体文档来了解具体的行为。

如果这还不够，Spring框架提供了一个 ForwardedHeaderFilter。你可以通过设置 server.forward-headers-strategy 为 FRAMEWORK，将其注册为应用程序中的Servlet filter。

	如果你使用Tomcat并在代理处终止SSL， `server.tomcat.redirect-context-root` 应该设置为 `false`。这允许在执行任何重定向之前尊重 `X-Forwarded-Proto` 头。
	如果你的应用程序在 Cloud Foundry 或 Heroku 中运行， `server.forward-headers-strategy` 属性默认为 `NATIVE`。在所有其他情况下，它默认为 `NONE`。

4.12.1 自定义Tomcat的代理配置

如果你使用Tomcat，你可以额外配置用于携带 “forwarded” 信息的 header 名称，如下例所示。

 server.tomcat.remoteip.remote-ip-header=x-your-remote-ip-header
 server.tomcat.remoteip.protocol-header=x-your-protocol-header

Tomcat还配置了一个正则表达式，用于匹配要信任的内部代理。其默认值见附录中的 server.tomcat.remoteip.internal-proxies 条目。你可以通过在 application.properties 中添加一个条目来定制valve的配置，如下面的例子所示。

 server.tomcat.remoteip.internal-proxies=192\\.168\\.\\d{1,3}\\.\\d{1,3}

你可以通过设置 internal-proxies 为empty来信任所有代理（但在生产中不要这样做）。

你可以完全控制Tomcat的 RemoteIpValve 的配置，方法是关闭自动的（要这样做，设置 server.forward-headers-strategy=NONE），并使用 WebServerFactoryCustomizer bean添加一个新的valve实例。

4.13. Tomcat 启用多个连接器（Connector）

你可以在 TomcatServletWebServerFactory 中添加 org.apache.catalina.connector.Connector，它可以允许多个连接器，包括HTTP和HTTPS连接器，如下例所示。

 @Configuration(proxyBeanMethods = false)
 public class MyTomcatConfiguration {
 
     @Bean
     public WebServerFactoryCustomizer<TomcatServletWebServerFactory> connectorCustomizer() {
         return (tomcat) -> tomcat.addAdditionalTomcatConnectors(createConnector());
     }
 
     private Connector createConnector() {
         Connector connector = new Connector("org.apache.coyote.http11.Http11NioProtocol");
         connector.setPort(8081);
         return connector;
     }
 
 }

4.14 启用 Tomcat 的 MBean Registry

嵌入式Tomcat的MBean registry默认是禁用的。这样可以最大限度地减少Tomcat的内存占用。如果你想使用Tomcat的MBeans，例如让Micrometer使用它们来暴露指标，你必须使用 server.tomcat.mbeanregistry.enabled 属性来做到这一点，如下例所示。

 server.tomcat.mbeanregistry.enabled=true

4.15 Undertow 启用多个 Listener

在 UndertowServletWebServerFactory 中添加一个 UndertowBuilderCustomizer，并在 Builder 中添加一个 listener，如下例所示。

 @Configuration(proxyBeanMethods = false)
 public class MyUndertowConfiguration {
 
     @Bean
     public WebServerFactoryCustomizer<UndertowServletWebServerFactory> undertowListenerCustomizer() {
         return (factory) -> factory.addBuilderCustomizers(this::addHttpListener);
     }
 
     private Builder addHttpListener(Builder builder) {
         return builder.addHttpListener(8080, "0.0.0.0");
     }
 
 }

4.16 使用@ServerEndpoint创建WeSocket端点

如果你想在使用嵌入式容器的Spring Boot应用程序中使用 @ServerEndpoint，你必须声明一个 ServerEndpointExporter @Bean，如下例所示。

 @Configuration(proxyBeanMethods = false)
 public class MyWebSocketConfiguration {
 
     @Bean
     public ServerEndpointExporter serverEndpointExporter() {
         return new ServerEndpointExporter();
     }
 
 }

前面例子中显示的Bean将任何 @ServerEndpoint 注解的Bean与底层WebSocket容器注册。当部署到独立的servlet容器时，这个角色由servlet容器的初始化器执行，而不需要 ServerEndpointExporter bean。

前言

总结

以上就是今天的内容~

欢迎大家点赞👍，收藏⭐，转发🚀，
如有问题、建议，请您在评论区留言💬哦。

最后：转载请注明出处！！！

张小鱼༒

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
0
评论
IDEA项目实践——SpringBoot当中RestController、GetMapping、PostMapping、SpringBootApplication以及web服务器

本文主要介绍RestController的简介以及与Controller和ResponseBody的区别和联系，GetMapping与PostMapping简介以及区别，SpringBootApplication 注解，以及SpringBoot的嵌入式WEB服务器文。本文中的案例仅供参考。RestController是 Java Spring 应用程序中的一个类，负责处理传入的 HTTP 请求并返回相应的 HTTP 响应。它是一种基于注释的方法来构建 RESTful Web 服务。
复制链接

扫一扫