什么是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容器依赖：

<!--web 模块 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <exclusions> <!--排除tomcat依赖 --> <exclusion> <artifactId>spring-boot-starter-tomcat</artifactId> <groupId>org.springframework.boot</groupId> </exclusion> </exclusions> </dependency> <dependency> <!--undertow容器 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-undertow</artifactId> </dependency> 

2. 编写Undertow配置

创建undertow.properties配置文件

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

下面是yaml格式的配置：

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

参数解释：

• 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启动成功提示语

[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 '' 复制代码

Tomcat启动成功提示语

[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 '' 

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

Undertow的FileServer

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

import java.io.File; import io.undertow.Handlers; import io.undertow.Undertow; import io.undertow.server.handlers.resource.PathResourceManager; public class FileServer { public static void main(String[] args) {
        File file = new File("/");
        Undertow server = Undertow.builder().addHttpListener(8080, "localhost")
                .setHandler(Handlers.resource(new PathResourceManager(file.toPath(), 100))
                        .setDirectoryListingEnabled(true))
                .build();
        server.start();
    }
}

SpringBoot下比较Tomcat与Undertow的性能

1. 添加依赖

pom.xml配置

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

<dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> <scope>provided</scope> </dependency> </dependencies> 复制代码

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

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> <!-- 若使用log4j2 --> <exclusions> <exclusion> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifactId> </exclusion> </exclusions> </dependency> <!-- undertow容器 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-undertow</artifactId> </dependency> 

2. 创建容器配置文件

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

tomcat配置

/**
 * 
 */ package com.lz.ovuola.general.util.tomcat; import org.apache.catalina.connector.Connector; import org.apache.coyote.http11.Http11NioProtocol; import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory; import org.springframework.boot.context.embedded.tomcat.TomcatConnectorCustomizer; import org.springframework.boot.context.embedded.tomcat.TomcatEmbeddedServletContainerFactory; import org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /**
 * 编程方式自定义内嵌容器
 * 
 * @author deepinsea
 *
 */ @Configuration @ConfigurationProperties(prefix = "tomcat") public class CustomTomcatEmbeddedCustomizer { private int maxThreads; private int minSpareThreads; private int acceptCount; private int connectionTimeout; private String URIEncoding = "UTF-8"; private boolean disableUploadTimeout; private boolean enableLookups; private String compression; private int compressionMinSize; private String compressableMimeType; /**
* 订制内嵌tomcat容器
*/ @Bean public EmbeddedServletContainerFactory servletContainer() {
        TomcatEmbeddedServletContainerFactory factory = new TomcatEmbeddedServletContainerFactory();
        factory.addConnectorCustomizers(new MyTomcatConnectorCustomizer()); return factory;
    } class MyTomcatConnectorCustomizer implements TomcatConnectorCustomizer { public void customize(Connector connector) {
            Http11NioProtocol protocol = (Http11NioProtocol) connector
                .getProtocolHandler(); // 设置最大连接数 protocol.setMaxThreads(maxThreads);
            protocol.setConnectionTimeout(connectionTimeout);
            protocol.setMinSpareThreads(minSpareThreads);
            protocol.setAcceptorThreadCount(acceptCount);
            protocol.setDisableUploadTimeout(disableUploadTimeout);
            protocol.setCompression(compression);
            protocol.setCompressionMinSize(compressionMinSize);
            protocol.setCompressableMimeType(compressableMimeType); // connector.setURIEncoding(URIEncoding); connector.setEnableLookups(enableLookups);
        }
    } public int getMaxThreads() { return maxThreads;
    } public void setMaxThreads(int maxThreads) { this.maxThreads = maxThreads;
    } public int getMinSpareThreads() { return minSpareThreads;
    } public void setMinSpareThreads(int minSpareThreads) { this.minSpareThreads = minSpareThreads;
    } public int getAcceptCount() { return acceptCount;
    } public void setAcceptCount(int acceptCount) { this.acceptCount = acceptCount;
    } public int getConnectionTimeout() { return connectionTimeout;
    } public void setConnectionTimeout(int connectionTimeout) { this.connectionTimeout = connectionTimeout;
    } public String getURIEncoding() { return URIEncoding;
    } public void setURIEncoding(String uRIEncoding) {
        URIEncoding = uRIEncoding;
    } public boolean isDisableUploadTimeout() { return disableUploadTimeout;
    } public void setDisableUploadTimeout(boolean disableUploadTimeout) { this.disableUploadTimeout = disableUploadTimeout;
    } public boolean isEnableLookups() { return enableLookups;
    } public void setEnableLookups(boolean enableLookups) { this.enableLookups = enableLookups;
    } public String getCompression() { return compression;
    } public void setCompression(String compression) { this.compression = compression;
    } public int getCompressionMinSize() { return compressionMinSize;
    } public void setCompressionMinSize(int compressionMinSize) { this.compressionMinSize = compressionMinSize;
    } public String getCompressableMimeType() { return compressableMimeType;
    } public void setCompressableMimeType(String compressableMimeType) { this.compressableMimeType = compressableMimeType;
    }
}

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

undertow配置

//package com.lz.ovuola.general.util.tomcat; // //import io.undertow.Undertow.Builder; // //import org.springframework.boot.context.embedded.EmbeddedServletContainerFactory; //import org.springframework.boot.context.embedded.undertow.UndertowBuilderCustomizer; //import org.springframework.boot.context.embedded.undertow.UndertowEmbeddedServletContainerFactory; //import org.springframework.boot.context.properties.ConfigurationProperties; //import org.springframework.context.annotation.Bean; //import org.springframework.context.annotation.Configuration; // //@Configuration //public class CustomUndertowEmbeddedCustomizer { // //  @Bean //  public EmbeddedServletContainerFactory servletContainer() { //  UndertowEmbeddedServletContainerFactory factory = new UndertowEmbeddedServletContainerFactory(); //  factory.addBuilderCustomizers(new UndertowBuilderCustomizer() { // //  @Override //  public void customize(Builder builder) { //  builder.addHttpListener(8080, "127.0.0.1"); //  } // //  }); //  return factory; //  } // // } 

3. 添加启动配置参数

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

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

4. 使用VisualVM监控

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

5. 使用Jmeter压测性能

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