undertow_undertow 优缺点 - CSDN
精华内容
参与话题
  • Undertow,Tomcat和Jetty服务器之间的区别

    千次阅读 2019-05-20 16:14:58
    Undertow,Tomcat和Jetty服务器配置详解与性能测试 本文文章是通过研究时下比较流行的Java框架spring boot引发的思考,希望大家能一起学习。 undertow,jetty和tomcat可以说是javaweb项目当下最火的三款服务器,...

    Undertow,Tomcat和Jetty服务器配置详解与性能测试

    	本文文章是通过研究时下比较流行的Java框架spring boot引发的思考,希望大家能一起学习。
    	undertow,jetty和tomcat可以说是javaweb项目当下最火的三款服务器,tomcat是apache下的一款重量级的服务器,不用多说历史悠久,经的起时间的考验。然后当下为服务兴起,spring boot,spring cloud越来越热的情况下,选择一款轻量级而性能优越的服务器是必要的选择。spring boot完美集成了tomcat,jetty和undertow,本文将通过对jetty和undertow服务器的分析以及测试,来比较两款服务器的性能如何。
    	值得一提的是jetty和undertow都是基于NIO实现的高并发轻量级的服务器,支持servlet3.1和websocket。所以,有必要先了解一下什么是NIO。
    

    NIO(非阻塞式输入输出)

    • channel
    • selector
    • buffer
    • acceptor
        Client和selector只想buffer读写数据不关注数据刘翔,数据通过channel通道进行流转。而selector只存在与服务端的,用channel的注册一次实现数据I/O操作。Acceptor负责接受所有的连接通道并且注册到channel中。而整个过程客户端与服务端是非阻塞的也就是异步操作。
      Jetty和Undertow主要配置
        对于服务器端而言我们关心的重点不是连接超时时间,socket超时时间以及任务的超时时间等的配置,重点是线程池设置,包括工作线程,I/O线程的分配。jetty在这方面似乎有点随意,全局使用一个线程池queuedThreaPool,而最小线程数8最大线程数200,Acceptor线程默认1个,Selector线程数默认2个。而undertow就比较合理,Acceptor通过递归循环注册,而用于I/O的线程默认是cpu的线程数,而工作线程是cpu线程数*8。
        对于服务器而言,如何分配线程可以提高服务器的并发性能。所以,下面将分析两款服务器的详细配置。
        服务器如何实现通道的注册

      Jetty可以设置acceptors的线程数默认是1个。详细实现如下:
    protected void doStart() throws Exception {
            if(this._defaultProtocol == null) {
                throw new IllegalStateException("No default protocol for " + this);
            } else {
                this._defaultConnectionFactory = this.getConnectionFactory(this._defaultProtocol);
                if(this._defaultConnectionFactory == null) {
                    throw new IllegalStateException("No protocol factory for default protocol \'" + this._defaultProtocol + "\' in " + this);
                } else {
                    SslConnectionFactory ssl = (SslConnectionFactory)this.getConnectionFactory(SslConnectionFactory.class);
                    if(ssl != null) {
                        String i = ssl.getNextProtocol();
                        ConnectionFactory a = this.getConnectionFactory(i);
                        if(a == null) {
                            throw new IllegalStateException("No protocol factory for SSL next protocol: \'" + i + "\' in " + this);
                        }
                    }
    
                    super.doStart();
                    this._stopping = new CountDownLatch(this._acceptors.length);
    
                   
    
     
    
    ~~for(int var4 = 0; var4 < this._acceptors.length; ++var4) {
                        AbstractConnector.Acceptor var5 = new AbstractConnector.Acceptor(var4, null);
                        this.addBean(var5);
                        this.getExecutor().execute(var5);
                    }~~ 
    
     
    
             this.LOG.info("Started {}", new Object[]{this});
                }
            }
        }
    

       “~~”删除线包裹的地方就是启动所有的acceptors线程,以下是线程详细执行过程。

    public void run() {
                Thread thread = Thread.currentThread();
                String name = thread.getName();
                this._name = String.format("%s-acceptor-%d@%x-%s", new Object[]{name, Integer.valueOf(this._id), Integer.valueOf(this.hashCode()), AbstractConnector.this.toString()});
                thread.setName(this._name);
                int priority = thread.getPriority();
                if(AbstractConnector.this._acceptorPriorityDelta != 0) {
                    thread.setPriority(Math.max(1, Math.min(10, priority + AbstractConnector.this._acceptorPriorityDelta)));
                }
    
                AbstractConnector stopping = AbstractConnector.this;
                synchronized(AbstractConnector.this) {
                    AbstractConnector.this._acceptors[this._id] = thread;
                }
    
                while(true) {
                    boolean var24 = false;
    
                    try {
                        var24 = true;
                        if(!AbstractConnector.this.isRunning()) {
                            var24 = false;
                            break;
                        }
    
                        try {
                            Lock stopping2 = AbstractConnector.this._locker.lock();
                            Throwable var5 = null;
    
                            try {
                                if(!AbstractConnector.this._accepting && AbstractConnector.this.isRunning()) {
                                    AbstractConnector.this._setAccepting.await();
                                    continue;
                                }
                            } catch (Throwable var41) {
                                var5 = var41;
                                throw var41;
                            } finally {
                                if(stopping2 != null) {
                                    if(var5 != null) {
                                        try {
                                            stopping2.close();
                                        } catch (Throwable var38) {
                                            var5.addSuppressed(var38);
                                        }
                                    } else {
                                        stopping2.close();
                                    }
                                }
    
                            }
                        } catch (InterruptedException var43) {
                            continue;
                        }
    
                        try {
                            AbstractConnector.this.accept(this._id);
                        } catch (Throwable var40) {
                            if(!AbstractConnector.this.handleAcceptFailure(var40)) {
                                var24 = false;
                                break;
                            }
                        }
                    } finally {
                        if(var24) {
                            thread.setName(name);
                            if(AbstractConnector.this._acceptorPriorityDelta != 0) {
                                thread.setPriority(priority);
                            }
    
                            AbstractConnector stopping1 = AbstractConnector.this;
                            synchronized(AbstractConnector.this) {
                                AbstractConnector.this._acceptors[this._id] = null;
                            }
    
                            CountDownLatch stopping4 = AbstractConnector.this._stopping;
                            if(stopping4 != null) {
                                stopping4.countDown();
                            }
    
                        }
                    }
                }
    
                thread.setName(name);
                if(AbstractConnector.this._acceptorPriorityDelta != 0) {
                    thread.setPriority(priority);
                }
    
                stopping = AbstractConnector.this;
                synchronized(AbstractConnector.this) {
                    AbstractConnector.this._acceptors[this._id] = null;
                }
    
                CountDownLatch stopping3 = AbstractConnector.this._stopping;
                if(stopping3 != null) {
                    stopping3.countDown();
                }
    
            }
    

      可以看到通过while循环监听所有建立的连接通道,然后在将通道submit到SelectorManager中。
    Undertow就没有这方面的处理,通过向通道中注册Selector,使用ChannelListener API进行事件通知。在创建Channel时,就赋予I/O线程,用于执行所有的ChannelListener回调方法。

    SelectionKey registerChannel(AbstractSelectableChannel channel) throws ClosedChannelException {
        if(currentThread() == this) {
            return channel.register(this.selector, 0);
        } else if(THREAD_SAFE_SELECTION_KEYS) {
            SelectionKey task1;
            try {
            
    
        
    
    ~~task1 = channel.register(this.selector, 0);~~ 
    
            } finally {
                if(this.polling) {
                    this.selector.wakeup();
                }
    
            }
    
            return task1;
        } else {
            WorkerThread.SynchTask task = new WorkerThread.SynchTask();
            this.queueTask(task);
    
            SelectionKey var3;
            try {
                this.selector.wakeup();
                var3 = channel.register(this.selector, 0);
            } finally {
                task.done();
            }
    
            return var3;
    }
    

    所以:无论设计架构如何可以看出两个服务器都是基于NIO实现的,而且都有通过selector来执行所有的I/O操作,通过IP的hash来将channel放入不同的work Tread或者selector Manager中,然后具体的处理工作线程池来完成。所以,我认为jetty的selectors数和undertow的IOThreads数都是用于selector或说是做I/O操作的线程数。不同的是jetty全局线程池。而对于两个服务器的承载能力以及读写效率,包括,lifeCycle过程管理等,决定了两个服务器性能的好坏。毕竟用于工作的县城所有的开销在于业务,所有个人觉得:I/O操作,管理与舰艇,决定了两个服务器的优劣。

    Jetty和Undertow压测分析

    准备工具:

    • siege用于压测
    • VisualVm用于监测

    项目准备:
    Jetty:acceptors=1,selectors=2, min and max threads=200

    Undertow: work_threads=200,io_threads=2

    压测梯度:
    siege -c 50 -r 2000 -t 2 --log=/Users/maybo/joinit_200.log http://127.0.0.1:8080/test

    siege -c 80 -r 2000 -t 2 --log=/Users/maybo/joinit_200.log http://127.0.0.1:8080/test

    siege -c 100 -r 2000 -t 2 --log=/Users/maybo/joinit_200.log http://127.0.0.1:8080/test

    测试结果:

    服务器 命中 成功率 吞吐量 平均耗时
    Jetty 11488 100% 96.25 trans/sec 0.00sec
    Jetty 18393 100% 153.92 trans/sec 0.00sec
    Jetty 21484 99.99% 179.51 trans/sec 0.01sec
    Undertow 11280 100% 94.02 trans/sec 0.00sec
    Undertow 19442 100% 163.35 trans/sec 0.01sec
    Undertow 23277 100% 195.54 trans/sec 0.01sec
    Tomcat 10845 100% 90.95 trans/sec 0.02sec
    Tomcat 21673 99.98% 181 trans/sec 0.01sec
    Tomcat 25084 99.98% 209.10 trans/sec 0.01sec

    从中可以看出在高负载下Undertow的吞吐量高于Jetty而且随着压力增大Jetty和Undertow成功率差距会拉大。而在负载不是太大情况下服务器处理能力差不多,jetty还略微高于Undertow。而tomcat的负载能力似乎和Undertow很接近。
    对比三个服务器发现在Undertow在负载过重情况下比Jetty和Tocmat更加顽强,实践证明在负载继续加大情况下Undertow的成功率高于其它两者,但是在并发不是太大情况下三款服务器整体来看差别不大。此次测试网络传输数据量太小,所以没有通过不断加大数据传输量来观察负载情况,个人决定测试一款服务器的I/O情况,还要通过改变数据传输量来看看在大数据文本高负载下三款服务器的性能。

    大数据量测试

    使用1892byte回复数据测试三款服务器性能,下面是开启线程执行情况图。
    Undertow:
    在这里插入图片描述
    Jetty:
    在这里插入图片描述
    Tomcat:
    在这里插入图片描述
      实验过程发现Undertow和Tomcat的负载能力很接近但是Undertow比较好点,而Jetty远远不足。通过观察以上三张图不难发现,Undertow的I/O线程执行100% , Tomcat的执行也是100%两者不同的是Undertow用于I/O的线程数是可以调整的,而Tomcat不可以,起码通过spring boot 无法调整,这样就制约了它的负载能力。而Jetty由于全局共享线程池所以,会存在Selector和Acceptor阻塞情况,这样就制约了I/O操作。但是有个好处就是在负载不是太重的情况下可以使工作线程有更多占用资源来处理程序,提高了吞吐量。但是,总体而言这种差距是很小的。

    结论:
      任何一个服务器都有其自己的优势。对于一个开发人员来说,选择一个什么样子的技术点能够帮助我们最有的解决问题才是目的。

    展开全文
  • Java微服务框架之Undertow

    万次阅读 2017-01-25 14:13:11
    Undertow 是红帽公司(RedHat)的开源产品,是 WildFly8(JBoos) 默认的 Web 服务器。  官网API给出一句话概述Undertow:  Undertow is a flexible performant web server written in java, providing both...

    Undertow 是红帽公司(RedHat)的开源产品,是 WildFly8(JBoos) 默认的 Web 服务器。

          官网API给出一句话概述Undertow:

          Undertow is a flexible performant web server written in java, providing both blocking and non-blocking API’s based on NIO.

          译文: Undertow是一个用java编写的灵活的高性能Web服务器,提供基于NIO的阻塞和非阻塞API。

          官网API总结特点:

           Lightweight(轻量级)

              Undertow非常轻量级,Undertow核心jar包在1Mb以下。 它在运行时也是轻量级的,有一个简单的嵌入式服务器使用少于4Mb的堆空间

           HTTP Upgrade Support(支持http升级)

              支持HTTP升级,允许多个协议通过HTTP端口进行多路复用

           Web Socket Support(支持WebScoket)

              Undertow提供对Web Socket的全面支持,包括JSR-356支持

           Servlet 3.1  

               Undertow提供对Servlet 3.1的支持,包括对嵌入式servlet的支持。 还可以在同一部署中混合Servlet和本机Undertow非阻塞处理程序

           Embeddable(可嵌入的)

               Undertow可以嵌入在应用程序中或独立运行,只需几行代码

           6. Flexible(灵活性)

             Undertow框架jar包: undertow-core.jar undertow-servlet.jar

     

    二、Undertow示例:

     1.官网给出一个Undertow Web 服务器使用异步IO的方式向界面输出字符串

    复制代码
     1 import io.undertow.Undertow;
     2 import io.undertow.server.HttpHandler;
     3 import io.undertow.server.HttpServerExchange;
     4 import io.undertow.util.Headers;
     5 
     6 public class HelloWorldServer {
     7    public static void main(String[] args) {
     8        Undertow server=Undertow.builder()
     9        .addHttpListener(8080, "localhost").setHandler(new HttpHandler(){//设置HttpHandler的回调方法
    10             @Override
    11             public void handleRequest(HttpServerExchange exchange)
    12                     throws Exception {        
    13                 exchange.getResponseHeaders().put(Headers.CONTENT_TYPE, "text/plain");
    14                 exchange.getResponseSender().send("This is my first insert server!");
    15             }
    16         }).build();
    17        server.start();
    18    }
    19 }

       运行后打开浏览器输入 http://localhost:8080 ,则页面输出“Hello World”字符串
    复制代码

      2.Undertow来部署Servlet

    复制代码
     1 import io.undertow.Handlers;
     2 import io.undertow.Undertow;
     3 import io.undertow.server.HttpHandler;
     4 import io.undertow.server.handlers.PathHandler;
     5 import io.undertow.servlet.Servlets;
     6 import io.undertow.servlet.api.DeploymentInfo;
     7 import io.undertow.servlet.api.DeploymentManager;
     8 import io.undertow.servlet.api.ServletContainer;
     9 import io.undertow.servlet.api.ServletInfo;
    10 
    11 import javax.servlet.ServletException;
    12 
    13 import org.wildfly.undertow.quickstart.servlet.MyServlet;
    14 
    15 public class ServletServer {
    16     
    17        public static void main(String[] args) {
    18     
    19         /*
    20          * 创建ServletInfo,Servelt的最小单位。是对javax.servlet.Servlet具体实现的再次封装。
    21          * 注意:ServletInfo的name必须是唯一的
    22          */
    23         ServletInfo servletInfo1 = Servlets.servlet("MyServlet",
    24                 MyServlet.class);
    25         // 创建servletInfo的初始化参数
    26         servletInfo1.addInitParam("message", "This is my first MyServlet!");
    27         // 绑定映射为/myServlet
    28         servletInfo1.addMapping("/myServlet");
    29         /**
    30          * 创建包部署对象,包含多个servletInfo。可以认为是servletInfo的集合
    31          */
    32         DeploymentInfo deploymentInfo1 = Servlets.deployment();
    33         // 指定ClassLoader
    34         deploymentInfo1.setClassLoader(ServletServer.class.getClassLoader());
    35         // 应用上下文(必须与映射路径一致,否则sessionId会出现问题,每次都会新建)
    36         deploymentInfo1.setContextPath("/myapp");
    37         // 设置部署包名
    38         deploymentInfo1.setDeploymentName("myServlet.war");
    39         // 添加servletInfo到部署对象中
    40         deploymentInfo1.addServlets(servletInfo1);
    41         /**
    42          * 使用默认的servlet容器,并将部署添加至容器
    43          * 容器,用来管理DeploymentInfo,一个容器可以添加多个DeploymentInfo
    44          */
    45         ServletContainer container = Servlets.defaultContainer();
    46         /**
    47          * 将部署添加至容器并生成对应的容器管理对象
    48          * 包部署管理。是对添加到ServletContaint中DeploymentInfo的一个引用,用于运行发布和启动容器
    49          */
    50         DeploymentManager manager = container.addDeployment(deploymentInfo1);
    51         // 实施部署
    52         manager.deploy();
    53         /**
    54          * 分发器:将用户请求分发给对应的HttpHandler
    55          */
    56         PathHandler pathHandler = Handlers.path();
    57         /**
    58          * servlet path处理器,DeploymentManager启动后返回的Servlet处理器。
    59          */
    60         HttpHandler myApp=null;
    61         try {
    62             //启动容器,生成请求处理器
    63             myApp=manager.start();
    64         } catch (ServletException e) {
    65             throw new RuntimeException("容器启动失败!");
    66         }
    67         //绑定映射关系
    68         pathHandler.addPrefixPath("/myapp", myApp);
    69         
    70         Undertow server=Undertow.builder().
    71                 //绑定端口号和主机
    72                 addHttpListener(8081, "localhost")
    73                 //设置分发处理器
    74                 .setHandler(pathHandler).build();
    75         //启动server
    76         server.start();
    77     }
    78 }

     
    复制代码
    自定义MyServlet
    复制代码
     1 import java.io.IOException;
     2 import java.io.PrintWriter;
     3 
     4 import javax.servlet.ServletException;
     5 import javax.servlet.http.HttpServlet;
     6 import javax.servlet.http.HttpServletRequest;
     7 import javax.servlet.http.HttpServletResponse;
     8 
     9 public class MyServlet extends HttpServlet {
    10 
    11     private static final long serialVersionUID = 2378494112650465478L;
    12 
    13     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    14         doPost(req, resp);
    15     }
    16 
    17     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    18         PrintWriter writer = resp.getWriter();
    19         writer.write("<p style='color:red;text-align:center;'>"+this.getInitParameter("message")+"</p>");
    20         writer.close();
    21     }
    22     
    23 }
    复制代码

       如下图,是本人抽象出Undertow生成应用的架构:


         示例运行:

         在浏览器地址栏里输入:http://localhost:8081/myapp/myServlet,界面上会显示ServletInfo的初始化参数message数据

     

    展开全文
  • undertow入门

    2020-06-30 11:04:01
    undertow 概述 : Undertow 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器 特点 : 轻量级:它是一个 Web 服务器,但不像传统的 Web 服务器有容器概念,它由两个核心 Jar 包组成,加载一个 Web 应用可以...

    undertow

    概述 :
    Undertow 是红帽公司开发的一款基于 NIO 的高性能 Web 嵌入式服务器

    特点 :
    轻量级:它是一个 Web 服务器,但不像传统的 Web 服务器有容器概念,它由两个核心 Jar 包组成,加载一个 Web 应用可以小于 10MB 内存

    Servlet3.1 支持:它提供了对 Servlet3.1 的支持

    WebSocket 支持:对 Web Socket 完全支持,用以满足 Web 应用巨大数量的客户端

    嵌套性:它不需要容器,只需通过 API 即可快速搭建 Web 服务器

    Spring Boot项目中的引入方式 :
    Spring Boot 内嵌 Jetty , Tomcat , Undertow , 默认是Tomcat

    pom.xml配置
    添加如下依赖

    <!--移除Tomcat依赖-->
    <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>
    <!--引入undertow-->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-undertow</artifactId>
    </dependency>
    

    application.yml配置 :
    与原来使用Tomcat时配置无太大差别 , 将tomca字段改为undertow即可

    # Undertow 日志存放目录
    server.undertow.accesslog.dir=
    # 是否启动日志
    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
    

    添加启动类后运行就可以看到控制台中打印如下信息

    Registering beans for JMX exposure on startup

    Undertow started on port(s) 8080 (http) with context path ‘’

    Started UndertowApplication in 3.933 seconds (JVM running for 6.734)

    性能/压力测试
    测试结论参考链接 :

    https://www.jianshu.com/p/ab78515265f4

    https://www.cnblogs.com/maybo/p/7784687.html

    https://blog.csdn.net/weixin_38187317/article/details/81532560

    结论 : 在并发量不高的情况下 , Tomcat与undertow的吞吐量区别不大 , 并发量高的情况下 , undertow的性能要优于Jetty与Tomcat

    展开全文
  • SpringBoot使用Undertow做服务器

    万次阅读 热门讨论 2018-08-09 10:55:16
     undertow,jetty和tomcat可以说是javaweb项目当下最火的三款服务器,tomcat是apache下的一款重量级的服务器,不用多说历史悠久,经得起实践的考验。然而:当下微服务兴起,spring boot ,spring cloud 越来越热的...

    说明

            undertow,jetty和tomcat可以说是javaweb项目当下最火的三款服务器,tomcat是apache下的一款重量级的服务器,不用多说历史悠久,经得起实践的考验。然而:当下微服务兴起,spring boot ,spring cloud 越来越热的情况下,选择一款轻量级而性能优越的服务器是必要的选择。spring boot 完美集成了tomcat,jetty和undertow,本文将通过对jetty和undertow服务器的分析以及测试,来比较两款服务器的性能如何。

      值得一提的是jetty和undertow都是基于NIO实现的高并发轻量级的服务器,支持servlet3.1和websocket。所以,有必要先了解下什么是NIO。

    NIO(非阻塞式输入输出)

    • Channel
    • Selector
    • Buffer
    • Acceptor

      Client和Server只向Buffer读写数据不关注数据的流向,数据通过Channel通道进行流转。而Selector是存在与服务端的,用于Channel的注册以此实现数据I/O操作。Acceptor负责接受所以的连接通道并且注册到Channel中。而整个过程客户端与服务端是非阻塞的也就是异步操作。

    下面是压力测试对比图:

    服务器 命中 成功率 吞吐量 平均耗时
    Jetty 11488 100% 96.25 trans/sec 0.00sec
    18393 100% 153.92 trans/sec 0.01sec
    21484 99.99% 179.51 trans/sec 0.01sec
    Undertow 11280 100% 94.02 trans/sec 0.00sec
    19442 100% 163.35 trans/sec 0.01sec
    23277 100% 195.54 tran/sec 0.01sec
    Tomcat 10845 100% 90.95 trans/sec 0.02sec
    21673 99.98% 181 trans/sec 0.01sec
    25084 99.98% 209.10 trans/sec 0.01sec

    从中可以看出在高负载下Undertow的吞吐量高于Jetty而且随着压力增大Jetty和Undertow成功率差距会拉大。而在负载不是太大情况下服务器处理能力差不多,jetty还略微高于Undertow。而tomcat的负载能力似乎和Undertow很接近。

      对比三个服务器发现在Undertow在负载过重情况下比Jetty和Tocmat更加顽强,实践证明在负载继续加大情况下Undertow的成功率高于其它两者,但是在并发不是太大情况下三款服务器整体来看差别不大。

    快速开始

    更新pom.xml文件:

            <!--<dependency>-->
                <!--<groupId>org.springframework.boot</groupId>-->
                <!--<artifactId>spring-boot-starter-web</artifactId>-->
            <!--</dependency>-->
    
            <!-- 下面的配置将使用undertow来做服务器而不是tomcat -->
            <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>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-undertow</artifactId>
            </dependency>

    application.yml配置:

    server:
      port: 8081
      # 下面是配置undertow作为服务器的参数
      undertow:
        # 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程
        io-threads: 4
        # 阻塞任务线程池, 当执行类似servlet请求阻塞操作, undertow会从这个线程池中取得线程,它的值设置取决于系统的负载
        worker-threads: 20
        # 以下的配置会影响buffer,这些buffer会用于服务器连接的IO操作,有点类似netty的池化内存管理
        # 每块buffer的空间大小,越小的空间被利用越充分
        buffer-size: 1024
        # 是否分配的直接内存
        direct-buffers: true

    配置比较简单,和tomcat使用基本一样,然后就可以快乐的使用undertow啦~

    展开全文
  • Undertow服务器基础分析 - Undertow

    千次阅读 2017-01-25 14:04:00
    Undertow是一个Web服务器,那么它就需要具备的现代Web服务器的基本特性,比如Servlet,JSP,文件服务器,代理服务器,安全认证等。undertow目前已经实现了绝大多数功能,并且因为wildfly通过了JavaEE7 TCK认证,所以...
  • undertow

    2019-12-20 09:39:09
    1\ http://undertow.io/undertow-docs/undertow-docs-2.0.0/index.html#access-log-handler 2、https://www.cnblogs.com/softidea/p/6068128.html
  • 使用 Undertow 替换掉 Tomcat

    万次阅读 2018-11-01 14:24:55
    文章目录UndertowUndertow 参数   官方说:For servlet stack applications, the spring-boot-starter-web includes Tomcat by including spring-boot-starter-tomcat, but you can use spring-boot-starter-...
  • SpringBoot中使用undertow

    千次阅读 2020-04-17 07:58:51
    undertow依赖参数配置多端口监听 首先说一下undertow是个啥? undertow是一个采用Java开发的灵活的高性能web服务器。其提供包括阻塞和基于NIO的非阻塞机制。 它是红帽公司的开源产品,是一个完全为嵌入式设计的web...
  • undertow配置

    2020-09-22 08:54:51
    #server.undertow.io-threads=32 # 阻塞任务线程池, 当执行类似servlet请求阻塞IO操作, undertow会从这个线程池中取得线程 # 它的值设置取决于系统线程执行任务的阻塞系数,默认值是IO线程数*8 #server.undertow....
  • Undertow web容器

    千次阅读 2019-07-23 23:55:34
    Undertow web容器一、Undertow 介绍二、使用undertow2.1、依赖添加2.2、在启动类,配置undewtow-server bean2.3、对比Tomcat启动日志输出2.4、对HTTP 2.0的支持2.5、配置undertow三、undertow 的深入 一、Undertow ...
  • Undertow

    2020-07-30 23:31:30
    Undertow
  • Undertow Undertow是一个Java开发的灵活的高性能Web服务器,提供包括阻塞和基于NIO的非阻塞机制。Undertow是红帽公司的开源产品,是Wildfly默认的Web服务器。 SpringBoot2中可以将Web服务器切换到Undertow来提高应用...
  • 高性能非阻塞 Web 服务器 Undertow

    千次阅读 2017-07-25 17:44:38
    Undertow 简介 Undertow是一个用java编写的、灵活的、高性能的Web服务器,提供基于NIO的阻塞和非阻塞API。 Undertow的架构是组合式的,可以通过组合各种小型的目的单一的处理程序来构建Web服务器。所以可以...
  • Spring Boot 内嵌容器Undertow参数设置

    万次阅读 2018-05-09 23:50:57
    配置项:# 设置IO线程数, 它主要执行非阻塞的任务,它们会负责多个连接, 默认设置每个CPU核心一个线程,不要设置过大,如果过大,启动项目会报错:打开文件数过多server.undertow.io-threads=16# 阻塞任务线程池, 当...
  • 高性能非阻塞Web 服务器Undertow

    千次阅读 2017-01-25 14:05:33
    WildFly 8 包含了一个全新的Web服务器(Undertow),WildFly 8 默认的Web服务器为Undertow。一句话概括什么是Undertow - 高性能非阻塞 Web 服务器。Undertow 主要有以下几个特点:   轻量化 - Undertow 是...
  • undertow服务器分析 随着Java EE 7的到来以及处理诸如Web Sockets API和HTTP升级(例如EJB over HTTP)之类的高级功能的要求,WildFly开发团队已经做出了重要决定。 在长期致力于JBoss Web服务器(Apache Tomcat的...
  • 叙述 最近在做压测 , 同事觉得 Tomcat 不行想要切换 web 服务器 , 于是我就去网上搜了一些测评结果 , ...抱着怀疑的态度 , 我决定对 SpringBoot 内嵌支持的三款 Servlet 容器 ( Tomcat 、Jetty 和 Undertow ) 做...
  • UnderTow Access.log格式

    千次阅读 2018-12-24 12:08:27
    最近从tomcat切换到UnderTow,来优化下频繁YoungGC的问题。发现accesslog格式不太一样,并且官方文档上面的并不全面,所以就看看源码来总结下,这样以后就算有更新,也可以通过这些类来知道最新的格式。 核心配置在...
  • Spring boot 中 Undertow 配置线程数

    万次阅读 2020-10-15 22:28:30
    Spring boot 弃用tomcat 作为内嵌服务器,转用undertow configurations { compile.exclude module: "spring-boot-starter-tomcat" } compile "org.springframework.boot:spring-boot-starter-undertow:$...
  • 先说一下出现这种情况的场景。该场景在使用jetty,tomcat作为容器时是可以正常运行的。首先是表单提交。 &lt;form id="submitForm" action="${base}/test/aa.html"... value=&
1 2 3 4 5 ... 20
收藏数 8,510
精华内容 3,404
关键字:

undertow