springboot-starter-undertow和tomcat的區別是什么

本篇內容主要講解“springboot-starter-undertow和tomcat的區別是什么”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“springboot-starter-undertow和tomcat的區別是什么”吧!

什么是tomcat

在說undertow和tomcat區別之前，先說下tomcat是什么（如果知道了可以跳過哦!）

Tomcat：免費開源，輕量級應用服務器，在中小型系統和并發訪問用戶不是很多的場合下被普遍使用，是開發和調試JSP 程序的首選。

實際上Tomcat 部分是Apache 服務器的擴展，但它是獨立運行的，所以當你運行tomcat 時，它實際上作為一個與Apache 獨立的進程單獨運行的。

只實現了JSP/Servlet的相關規范，不支持EJB。

雖說是tomcat服務器，但是并不是真正的硬件，它是部署在電腦上的軟件服務。

tomcat的作用

上面說過Tomcat是一個容器，但為什么開發出來的應用需要裝進Tomcat這個容器呢。忽略各個文件之間的跳轉，web應用本質只是一個裝有很多資源(java/html/jsp/js/css等各種格式文件)的文件夾。假如我們有一個web應用projectA，我們在某臺計算機A把這些文件寫好后，就希望其他設備能夠通過一些方式來訪問我們的資源。一種方法是通過在瀏覽器地址欄輸入URL來實現資源的訪問。

那么從我們在計算機A上寫好某個文件夾到文件夾能夠被其他計算機所訪問，需要什么呢。首先需要我們的互聯網。計算機B先通過互聯網找到計算機A。

而這樣做的前提是你這個電腦必須在互聯網這個網絡里面，這樣別人才能訪問到你。也就是說一臺電腦必須要有IP地址才能稱為服務器。但這樣也只是找到了IP地址而已，我們還需要找到對應的主機（注：一般主機是指一臺電腦，但在tomcat中，虛擬主機指的是計算機中的某個文件夾）。但就算找到了計算機A，我們怎么知道要去哪里尋找web應用projectA呢。Tomcat容器就是來解決這個問題的。在我看來，Tomcat的一個重要的功能就在于“映射”（通過配置文件實現）。

javaweb項目都需要tomcat？

其實可以不要，之前Javaweb項目多為jsp，而jsp需要jsp容器來解釋，所以需要tomcat等含有jsp容器的web服務器。使用jsp的時候，jsp沒有main方法，怎么把服務啟動呢，這個時候tomcat容器就很有必要了。

但隨著近些年了，前后端分離導致不需要jsp容器來解釋jsp，于是tomcat在項目中完全可以不要的，可以使用JBoss、Jetty等單純Web應用服務器。

但tomcat也可以做Web服務器，所以項目中還是可以繼續使用tomcat。

Java前后端分離的核心思想

前端html頁面通過ajax調用后端的restuful api接口并使用json數據進行交互。前后端分離的項目就可以不使用tomcat容器。

springboot內置的tomcat

不得不說SpringBoot的開發者是在為大眾程序猿謀福利，把大家都慣成了懶漢，xml不配置了，連tomcat也懶的配置了，典型的一鍵啟動系統，那么tomcat在springboot是怎么啟動的呢？

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
   <version>2.1.6.RELEASE</version>
</dependency>

@SpringBootApplication
public class MySpringbootTomcatStarter{
    public static void main(String[] args) {
        Long time=System.currentTimeMillis();
        SpringApplication.run(MySpringbootTomcatStarter.class);
    }
}

有的公司在生產環境不使用springboot自帶的tomcat，則需要在代碼中排出

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <!-- 移除嵌入式tomcat插件 -->
    <exclusions>
        <exclusion>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
        </exclusion>
    </exclusions>
</dependency>

將項目打成war包(下面會講==)，放到生產環境tomcat目錄下運行

undertow和tomcat的區別

在 SpringBoot 框架中，使用最多的是 Tomcat，這是 SpringBoot 默認的容器技術，而且是內嵌式的 Tomcat。

同時，SpringBoot 也支持 Undertow 容器，我們可以很方便的用 Undertow 替換 Tomcat，而 Undertow 的性能和內存使用方面都優于 Tomcat。

在高并發系統中，Tomcat 相對來說比較弱。在相同的機器配置下，模擬相等的請求數，Undertow 在性能和內存使用方面都是最優的。并且 Undertow 新版本默認使用持久連接，這將會進一步提高它的并發吞吐能力。所以，如果是高并發的業務系統，Undertow 是最佳選擇。

使用：

1.排除SpingBoot中自帶的tomcat

       <!--springboot web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

2.添加Undertow的依賴

        <!--undertow-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>

這樣即可，使用默認參數啟動undertow服務器。如果需要修改undertow參數，繼續往下看。

undertow的參數設置：

server:  
    port: 8084  
    http2:  
        enabled: true  
    undertow:  
        io-threads: 16  
        worker-threads: 256  
        buffer-size: 1024  
        buffers-per-region: 1024  
        direct-buffers: true

io-threads：IO線程數, 它主要執行非阻塞的任務，它們會負責多個連接，默認設置每個CPU核心一個線程，不可設置過大，否則啟動項目會報錯：打開文件數過多。

worker-threads：阻塞任務線程池，當執行類似servlet請求阻塞IO操作，undertow會從這個線程池中取得線程。它的值取決于系統線程執行任務的阻塞系數，默認值是 io-threads*8

以下配置會影響buffer，這些buffer會用于服務器連接的IO操作，有點類似netty的池化內存管理。

buffer-size：每塊buffer的空間大小，越小的空間被利用越充分，不要設置太大，以免影響其他應用，合適即可

buffers-per-region：每個區分配的buffer數量，所以pool的大小是buffer-size * buffers-per-region

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

3. 啟動SpringBoot測試

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 ‘’

部署jar和war包

war是一個web模塊，其中需要包括WEB-INF，是可以直接運行的WEB模塊。而jar一般只是包括一些class文件，在聲明了Main_class之后是可以用java命令運行的.

它們都是壓縮的包,拿Tomcat來說,將war文件包放置它的\webapps\目錄下，啟動Tomcat,這個包可以自動進行解壓，也就是你的web目錄，相當于發布了。

像之前jsp頁面，項目必須打包成war,放置到tomcat容器中運行。

Spring Boot支持傳統部署和更現代的部署形式。jar跟war都支持，在創建springboot項目時，默認是jar包，打成war包使用我上面說的即可

springboot下比較tomcat與undertow性能

第一步

pom.xml配置

如果使用tomcat服務器，則配置如下：

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

如果使用undertow服務器，則配置如下：因為spring boot默認配置為tomcat:

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

再添加dependency依賴：

 <dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-undertow</artifactId>

第二步

再在定制tomcat/undertow服務器

/**
 * 
 */
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 fz
 *
 */
@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,測試只要啟動一個就行

//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;
//  }
//
// }

第三步

在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"

第四步

采用visualVM監控同一個服務，分別開啟tomcat/undertow容器，注意兩者在application.propertites參數盡量相同，以便觀察穩定性

第五步

打開jemter壓力測試某一接口，觀察堆內存、線程數、cpu等指標。

到此，相信大家對“springboot-starter-undertow和tomcat的區別是什么”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！