• SpingBoot之替换容器为Undertow

    什么是Undertow容器

    Undertow 是一个采用 Java 开发的灵活的高性能Web服务器，提供包括阻塞和基于 NIO 的非堵塞机制。Undertow 是红帽公司的开源产品，是 Wildfly 默认的 Web 服务器。Undertow 提供一个基础的架构用来构建 Web 服务器，这是一个完全为嵌入式设计的项目，提供易用的构建器 API，完全向下兼容 Java EE Servlet 3.1 和低级非堵塞的处理器。

    为什么使用Undertow容器

    为什么要替换Undertow容器？

    Tomcat默认的最大线程为200，线程数限制了请求调用的性能；在高并发场景下明显并发能力较弱，需要进行调优。

    为什么不进行Tomcat参数调优？

    有两个方案：进行Tomcat容器调优或者替换为性能更强的容器。可以进行Tomcat调优，但是Undertow容器在性能和内存上都优于Tomcat容器，因此直接选择Undertow容器并进行调优是更好的选择。

    其实在并发量不大的情况下 Undertow、和其它两款 Servlet Web 容器 Jetty 、Tomcat 的差距并不是很大。 Undertow 的优势是高并发下的吞吐量，你可以根据自己的实际需要来选择。

    SpringBoot内嵌容器支持Tomcat(默认)、Jetty、Undertow。为什么选择Undertow？

    Undertow的特性

    Undertow 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器，有以下特性：

    • 支持HTTP 2.0：Undertow 支持 HTTP/2 开箱即用，不需要重写引导类路径。

    • 支持HTTP升级：支持 HTTP 升级，允许多个协议通过 HTTP 端口上进行复用。

    • 支持WebSocket：Undertow 提供对 Web 套接字的全面支持，包括对 JSR-356 的支持。

    • 支持Servlet 4.0：Undertow 提供了对 Servlet 4.0 的支持，包括对嵌入式 Servlet 的支持，还可以混合部署 Servlet 和原生 Undertow 非阻塞处理程序。

    • 内嵌性：Undertow 可以嵌入到应用程序中，它不需要容器，只需通过 API 即可快速搭建 Web 服务器。

    • 轻量级：它是一个内嵌Web服务器，仅由两个核心jar包组成，加载一个 Web 应用可以小于 10MB 内存。

    • 高灵活性：一个 Undertow 服务器是通过链式处理器来配置的，可以根据需要添加功能，因此可以避免添加没有必要的功能。

    集成Undertow容器

    1. 添加依赖

    在依赖中排除默认的tomcat容器依赖，添加undertow容器依赖：

    1.   
    2.   <dependency>
    3.    <groupId>org.springframework.bootgroupId>
    4.    <artifactId>spring-boot-starter-webartifactId>
    5.    <exclusions>
    6.     
    7.     <exclusion>
    8.      <artifactId>spring-boot-starter-tomcatartifactId>
    9.      <groupId>org.springframework.bootgroupId>
    10.     exclusion>
    11.    exclusions>
    12.   dependency>
    13.   <dependency>
    14.   
    15.   <dependency>
    16.    <groupId>org.springframework.bootgroupId>
    17.    <artifactId>spring-boot-starter-undertowartifactId>
    18.   dependency>
    19.

    2. 编写Undertow配置

    创建undertow.properties配置文件

    1. # Undertow 日志存放目录
    2. server.undertow.accesslog.dir=./undertow-logs
    3.   # 是否启动日志
    4. server.undertow.accesslog.enabled=false
    5.   # 日志格式
    6. server.undertow.accesslog.pattern=common
    7.   # 日志文件名前缀
    8. server.undertow.accesslog.prefix=access_log
    9.   # 日志文件名后缀
    10. server.undertow.accesslog.suffix=log
    11.   # HTTP POST请求最大的大小
    12. server.undertow.max-http-post-size=0
    13.   # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
    14. server.undertow.io-threads=4
    15.   # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
    16. server.undertow.worker-threads=20
    17.   # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
    18.   # 每块buffer的空间大小,越小的空间被利用越充分
    19. server.undertow.buffer-size=1024
    20.   # 每个区分配的buffer数量 , 所以pool的大小是buffer-size * buffers-per-region(已弃用)
    21. #server.undertow.buffers-per-region=1024
    22.   # 是否分配的直接内存
    23. server.undertow.direct-buffers=true
    24.

    下面是yaml格式的配置：

    1. server:
    2.   port: 9020
    3.   http2:
    4.     enabled: true
    5.   undertow:
    6.     # io-threads：IO线程数, 它主要执行非阻塞的任务，它们会负责多个连接，默认设置每个CPU核心一个线程，不可设置过大，否则启动项目会报错：打开文件数过多。
    7.     # worker-threads：阻塞任务线程池，当执行类似servlet请求阻塞IO操作，undertow会从这个线程池中取得线程。它的值取决于系统线程执行任务的阻塞系数，默认值是 io-threads*8
    8.     threads:
    9.       io: 16
    10.       worker: 256
    11.     # 以下配置会影响buffer，这些buffer会用于服务器连接的IO操作，有点类似netty的池化内存管理。
    12.     # buffer-size：每块buffer的空间大小，越小的空间被利用越充分，不要设置太大，以免影响其他应用，合适即可
    13.     # buffers-per-region：每个区分配的buffer数量，所以pool的大小是buffer-size * buffers-per-region
    14.     # direct-buffers：是否分配的直接内存(NIO直接分配的堆外内存)
    15.     buffer-size: 1024
    16.     direct-buffers: true
    17.

    参数解释：

    • io-threads：IO线程数, 它主要执行非阻塞的任务，它们会负责多个连接，默认设置每个CPU核心一个线程，不可设置过大，否则启动项目会报错：打开文件数过多。

    • worker-threads：阻塞任务线程池，当执行类似servlet请求阻塞IO操作，undertow会从这个线程池中取得线程。它的值取决于系统线程执行任务的阻塞系数，默认值是 io-threads*8

    • buffer-size：每块buffer的空间大小，越小的空间被利用越充分，不要设置太大，以免影响其他应用，合适即可

    • buffers-per-region：每个区分配的buffer数量，所以pool的大小是buffer-size * buffers-per-region

    • direct-buffers：是否分配的直接内存(NIO直接分配的堆外内存)

    3. 启动测试

    Undertow启动成功提示语

    1. [INFO ] 2020-08-13 10:38:32 [main] o.s.b.w.e.u.UndertowServletWebServer - Undertow started on port(s) 80 (http) with context path ''
    2. 复制代码

    Tomcat启动成功提示语

    1. [INFO ] 2020-08-13 10:41:35 [main] o.s.b.w.e.tomcat.TomcatWebServer - Tomcat started on port(s): 80 (http) with context path ''
    2.

    出现undertow的提示语，则说明springboot默认启动容器已经替换为undertow容器。

    Undertow的FileServer

    除了采用 NIO 的方式异步处理请求，undertow还有文件服务器的功能：

    1. import java.io.File;
    2.  
    3. import io.undertow.Handlers;
    4. import io.undertow.Undertow;
    5. import io.undertow.server.handlers.resource.PathResourceManager;
    6.  
    7. public class FileServer {
    8.     public static void main(String[] args) {
    9.         File file = new File("/");
    10.         Undertow server = Undertow.builder().addHttpListener(8080, "localhost")
    11.                 .setHandler(Handlers.resource(new PathResourceManager(file.toPath(), 100))
    12.                         .setDirectoryListingEnabled(true))
    13.                 .build();
    14.         server.start();
    15.     }
    16. }
    17.

    SpringBoot下比较Tomcat与Undertow的性能

    1. 添加依赖

    pom.xml配置

    如果使用tomcat服务器，则配置如下：

    1.  <dependencies>
    2.           <dependency>
    3.            <groupId>org.springframework.bootgroupId>
    4.            <artifactId>spring-boot-starter-tomcatartifactId>
    5.            <scope>providedscope>
    6.      dependency>
    7.  dependencies>
    8. 复制代码

    如果使用undertow服务器，则配置如下：

    1. <dependency>
    2.     <groupId>org.springframework.bootgroupId>
    3.     <artifactId>spring-boot-starter-webartifactId>
    4.     
    5.     <exclusions>
    6.         <exclusion> 
    7.             <groupId>org.springframework.bootgroupId>
    8.             <artifactId>spring-boot-starter-tomcatartifactId> 
    9.         exclusion> 
    10.     exclusions>
    11. dependency>
    13.  <dependency>
    14.            <groupId>org.springframework.bootgroupId>
    15.            <artifactId>spring-boot-starter-undertowartifactId>
    16. dependency>
    17.

    2. 创建容器配置文件

    定制tomcat/undertow服务器相关配置：

    tomcat配置

    1. /**
    2.  * 
    3.  */
    4. package com.lz.ovuola.general.util.tomcat;
    5. import org.apache.catalina.connector.Connector;
    6. import org.apache.coyote.http11.Http11NioProtocol;
    7. import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
    8. import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer;
    9. import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory;
    10. import org.springframework.boot.context.properties.ConfigurationProperties;
    11. import org.springframework.context.annotation.Bean;
    12. import org.springframework.context.annotation.Configuration;
    13. /**
    14.  * 编程方式自定义内嵌容器
    15.  * 
    16.  * @author deepinsea
    17.  *
    18.  */
    19. @Configuration
    20. @ConfigurationProperties(prefix = "tomcat")
    21. public class CustomTomcatEmbeddedCustomizer {
    22.     private int maxThreads;
    23.     private int minSpareThreads;
    24.     private int acceptCount;
    25.     private int connectionTimeout;
    26.     private String URIEncoding = "UTF-8";
    27.     private boolean disableUploadTimeout;
    28.     private boolean enableLookups;
    29.     private String compression;
    30.     private int compressionMinSize;
    31.     private String compressableMimeType;
    32.     /**
    33. * 订制内嵌tomcat容器
    34. */
    35.     @Bean
    36.     public EmbeddedServletContainerFactory servletContainer() {
    37.         TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
    38.         factory.addConnectorCustomizers(new MyTomcatConnectorCustomizer());
    39.         return factory;
    40.     }
    41.     class MyTomcatConnectorCustomizer implements TomcatConnectorCustomizer {
    42.         public void customize(Connector connector) {
    43.             Http11NioProtocol protocol = (Http11NioProtocol) connector
    44.                 .getProtocolHandler();
    45.             // 设置最大连接数
    46.             protocol.setMaxThreads(maxThreads);
    47.             protocol.setConnectionTimeout(connectionTimeout);
    48.             protocol.setMinSpareThreads(minSpareThreads);
    49.             protocol.setAcceptorThreadCount(acceptCount);
    50.             protocol.setDisableUploadTimeout(disableUploadTimeout);
    51.             protocol.setCompression(compression);
    52.             protocol.setCompressionMinSize(compressionMinSize);
    53.             protocol.setCompressableMimeType(compressableMimeType);
    54.             // connector.setURIEncoding(URIEncoding);
    55.             connector.setEnableLookups(enableLookups);
    56.         }
    57.     }
    58.     public int getMaxThreads() {
    59.         return maxThreads;
    60.     }
    61.     public void setMaxThreads(int maxThreads) {
    62.         this.maxThreads = maxThreads;
    63.     }
    64.     public int getMinSpareThreads() {
    65.         return minSpareThreads;
    66.     }
    67.     public void setMinSpareThreads(int minSpareThreads) {
    68.         this.minSpareThreads = minSpareThreads;
    69.     }
    70.     public int getAcceptCount() {
    71.         return acceptCount;
    72.     }
    73.     public void setAcceptCount(int acceptCount) {
    74.         this.acceptCount = acceptCount;
    75.     }
    76.     public int getConnectionTimeout() {
    77.         return connectionTimeout;
    78.     }
    79.     public void setConnectionTimeout(int connectionTimeout) {
    80.         this.connectionTimeout = connectionTimeout;
    81.     }
    82.     public String getURIEncoding() {
    83.         return URIEncoding;
    84.     }
    85.     public void setURIEncoding(String uRIEncoding) {
    86.         URIEncoding = uRIEncoding;
    87.     }
    88.     public boolean isDisableUploadTimeout() {
    89.         return disableUploadTimeout;
    90.     }
    91.     public void setDisableUploadTimeout(boolean disableUploadTimeout) {
    92.         this.disableUploadTimeout = disableUploadTimeout;
    93.     }
    94.     public boolean isEnableLookups() {
    95.         return enableLookups;
    96.     }
    97.     public void setEnableLookups(boolean enableLookups) {
    98.         this.enableLookups = enableLookups;
    99.     }
    100.     public String getCompression() {
    101.         return compression;
    102.     }
    103.     public void setCompression(String compression) {
    104.         this.compression = compression;
    105.     }
    106.     public int getCompressionMinSize() {
    107.         return compressionMinSize;
    108.     }
    109.     public void setCompressionMinSize(int compressionMinSize) {
    110.         this.compressionMinSize = compressionMinSize;
    111.     }
    112.     public String getCompressableMimeType() {
    113.         return compressableMimeType;
    114.     }
    115.     public void setCompressableMimeType(String compressableMimeType) {
    116.         this.compressableMimeType = compressableMimeType;
    117.     }
    118. }
    119.

    或者是 undertow，测试只要启动一个就行：

    undertow配置

    1. //package com.lz.ovuola.general.util.tomcat;
    2. //
    3. //import io.undertow.Undertow.Builder;
    4. //
    5. //import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory;
    6. //import org.springframework.boot.context.embedded.undertow.UndertowBuilderCustomizer;
    7. //import org.springframework.boot.context.embedded.undertow.UndertowEmbeddedServletContainerFactory;
    8. //import org.springframework.boot.context.properties.ConfigurationProperties;
    9. //import org.springframework.context.annotation.Bean;
    10. //import org.springframework.context.annotation.Configuration;
    11. //
    12. //@Configuration
    13. //public class CustomUndertowEmbeddedCustomizer {
    14. //
    15. //  @Bean
    16. //  public EmbeddedServletContainerFactory servletContainer() {
    17. //  UndertowEmbeddedServletContainerFactory factory = new UndertowEmbeddedServletContainerFactory();
    18. //  factory.addBuilderCustomizers(new UndertowBuilderCustomizer() {
    19. //
    20. //  @Override
    21. //  public void customize(Builder builder) {
    22. //  builder.addHttpListener(8080, "127.0.0.1");
    23. //  }
    24. //
    25. //  });
    26. //  return factory;
    27. //  }
    28. //
    29. // }
    30.

    3. 添加启动配置参数

    在application -runAs -run as configuratuion-Arguments添加：--用于jconsole或者是visualVM监控，推荐使用后者：

    1. -Djava.rmi.server.hostname=127.0.0.1   --ip地址
    2. -Dcom.sun.management.jmxremote
    3. -Dcom.sun.management.jmxremote.port="9093"   --端口号
    4. -Dcom.sun.management.jmxremote.authenticate="false"
    5.

    4. 使用VisualVM监控

    采用visualVM监控同一个服务，分别开启tomcat/undertow容器，注意两者在application.propertites参数尽量相同，以便观察稳定性

    5. 使用Jmeter压测性能

    打开jemter压力测试某一接口，观察堆内存、线程数、cpu等指标。

  • 相关阅读:
    巴塞瓦尔能量守恒定理
    FL Studio 21.2.3.4004 完整破解版 [Mac + Win] 下载 2024最新免费Crack 下载
    openfeign客户端调用远程服务端接口，传递参数为null及服务端接口返回值为null的情况
    Unity中Shader的XRay透视效果
    Redis限流实践：实现用户消息推送每天最多通知2次的功能
    面试系列分布式事务：谈谈3PC的理解
    线性代数+分治：446E
    巨额亏损，股价遭受重创，Polestar极星汽车已陷入困境
    Unity Webgl与JS相互交互 Unity 2021.2之后的版本
    软件过程与管理_期末复习知识点回顾总结
  • 原文地址：https://blog.csdn.net/LBWNB_Java/article/details/126340370