关于springboot-starter-undertow和tomcat的区别说明

目录
  • 什么是tomcat
  • tomcat的作用
    • javaweb项目都需要tomcat?
    • Java前后端分离的核心思想
  • springboot内置的tomcat
  • undertow和tomcat的区别
  • 部署jar和war包
  • springboot下比较tomcat与undertow性能
    • 第一步
    • 第二步
    • 第三步
    • 第四步
    • 第五步

什么是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等指标。

以上为个人经验,希望能给大家一个参考,也希望大家多多支持我们。

(0)

相关推荐

  • 记一次springboot中用undertow的坑

    目录 springboot中用undertow的坑 本文实验的环境如下 环境准备 使用springboot2.2.11.springboot2.2.12.springboot2.2.13 如果是生产采用了上述几个版本的sringboot springboot需放弃Tomcat,选择Undertow吗? SpringBoot中的Tomcat容器 SpringBoot设置Undertow Tomcat与Undertow的优劣对比 springboot中用undertow的坑 场景:准备基于sprin

  • Spring Boot如何使用Undertow代替Tomcat

    1. Undertow 简介 Undertow 是一个采用 Java 开发的灵活的高性能 Web 服务器,提供包括阻塞和基于 NIO 的非堵塞机制.Undertow 是红帽公司的开源产品,是 Wildfly 默认的 Web 服务器.Undertow 提供一个基础的架构用来构建 Web 服务器,这是一个完全为嵌入式设计的项目,提供易用的构建器 API,完全向下兼容 Java EE Servlet 3.1 和低级非堵塞的处理器. 2. Undertow特点 高性能 在多款同类产品的压测中,在高并发情

  • Spring Boot启动过程(四)之Spring Boot内嵌Tomcat启动

    之前在Spring Boot启动过程(二)提到过createEmbeddedServletContainer创建了内嵌的Servlet容器,我用的是默认的Tomcat. private void createEmbeddedServletContainer() { EmbeddedServletContainer localContainer = this.embeddedServletContainer; ServletContext localServletContext = getServ

  • 传统tomcat启动服务与springboot启动内置tomcat服务的区别(推荐)

    spring整合springmvc spring整合springmvc中web.xml配置如下,tomcat在启动过程中会加载web.xml中的内容,ContextLoaderListener实现了tomcat里面的ServletContextListener接口,所以在tomcat容器启动过程通过ContextLoaderListener来进行spring容器的初始化操作,并将classpath:spring/applicationContext-*.xml指定下的spring配置文件加载,该

  • 关于springboot-starter-undertow和tomcat的区别说明

    目录 什么是tomcat tomcat的作用 javaweb项目都需要tomcat? Java前后端分离的核心思想 springboot内置的tomcat undertow和tomcat的区别 部署jar和war包 springboot下比较tomcat与undertow性能 第一步 第二步 第三步 第四步 第五步 什么是tomcat 在说undertow和tomcat区别之前,先说下tomcat是什么(如果知道了可以跳过哦!) Tomcat:免费开源,轻量级应用服务器,在中小型系统和并发访问用

  • 大厂禁止SpringBoot在项目使用Tomcat容器原理解析

    目录 前言 SpringBoot中的Tomcat容器 SpringBoot设置Undertow Tomcat与Undertow的优劣对比 最后 前言 在SpringBoot框架中,我们使用最多的是Tomcat,这是SpringBoot默认的容器技术,而且是内嵌式的Tomcat.同时,SpringBoot也支持Undertow容器,我们可以很方便的用Undertow替换Tomcat,而Undertow的性能和内存使用方面都优于Tomcat,那我们如何使用Undertow技术呢?本文将为大家细细讲解

  • 浅谈springboot内置tomcat和外部独立部署tomcat的区别

    前两天,我去面了个试,面试官问了我个问题,独立部署的tomcat跟springboot内置的tomcat有什么区别,为什么存在要禁掉springboot的tomcat然后将项目部署到独立的tomcat当中? 我就想,不都一个样?独立部署的tomcat可以配置优化?禁AJP,开多线程,开nio?而且springboot内置的tomcat多方便,部署上服务器写个java脚本运行即可.现在考虑下有什么条件能优于内置tomcat的. 1.tomcat的优化配置多线程?内置的也可以配置多线程 server

  • SpringBoot Starter机制及整合tomcat的实现详解

    目录 Starter机制和springboot整合tomcat Starter机制 springboot整合tomcat 总结 Starter机制和springboot整合tomcat Starter机制 先解释一下什么是Starter机制.Starter机制就是maven工程中pom文件引入了某个Starter依赖,就能使用对应的功能 例如 引入web的starter依赖 ,就可以使用有关于web方面的功能. <dependency> <groupId>org.springfra

  • SpringBoot配置和切换Tomcat流程详解

    目录 1.基本介绍 2.内置 Tomcat 的配置 1.通过 application.yml 完成配置 2.通过类来配置 Tomcat 3.切换 WebServer 1.基本介绍 SpringBoot 支持的 webServer: Tomcat, Jetty, or Undertow SpringBoot 应用启动是 Web 应用时.web 场景包-导入 tomcat 支持对 Tomcat(也可以是 Jetty .Undertow)的配置和切换 2.内置 Tomcat 的配置 1.通过 appl

  • SpringBoot应用部署到Tomcat中无法启动的解决方法

    背景 最近公司在做一些内部的小型Web应用时, 为了提高开发效率决定使用SpringBoot, 这货自带Servlet容器, 你在开发Web应用时可以直接在本地像运行控制台应用一样启动,省去了重复部署的时间:配置上相比于SpringMVC也是有了大大的简化.SpringBoot的应用可以直接打成一个可运行的jar包, 你无需发愁为了不同应用要部署多个Tomcat.但是实际部署时你会发现打成Jar包的方式有一个致命的缺点, 当你改动了一个资源文件.或者一个类时, 打要往服务器重新上传全量jar包.

  • Springboot 2使用外部Tomcat源码分析

    Springboot 使用外部 Tomcat 1.修改 pom.xml,改为打 war 包 <packaging>war</packaging> 2.将 Springboot 内置 tomcat 作用域改为provided <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifac

  • 配置springboot项目使用外部tomcat过程解析

    这篇文章主要介绍了配置springboot项目使用外部tomcat过程解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 在pom文件中添加依赖 <!--使用自带的tomcat--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-tomcat</artifac

随机推荐