为什么Sprint Boot要内嵌服务器呢？
 
想象一下如果要部署一个Java应用都需要做些什么呢？
 
安装JDK
安装Web/Application服务器(Tomcat/Jetty etc)
部署war包
如果我们想要简化这个流程，并且只要拥有Java运行环境就能够运行部署应用，要做些什么呢？
 
在创建一个可部署的应用时，内嵌一个服务器，在Spring Boot创建一个应用时，会生产一个包含服务器的Jar包，这样就可以运行这个web application香java application 那样
 
嵌入式服务器意味着我们的可部署单元包含服务器的二进制文件（例如tomcat.jar.

SpringBoot 集成的服务器源码分析
 
本文主要针对内嵌服务器的原理以及如何切换不同内嵌服务器进行介绍。
 下面针对springBoot2.3.4版本进行简单的介绍。springBoot主要内嵌的服务器从官方文档可以看到：
 
 由此可知，主要集成了jetty（适合交互式消息）,tomcat以及undertow（不支持JSP，并发性能较高）三种，spring-boot-starter-web默认使用的是tomcat服务器。我们在启动springboot的时候就会发现，不需要导入tomcat组件就可以直接运行，这就是内嵌服务器。这与传统的打war包不同，内嵌服务器直接将项目打包成jar包，使用 java -jar + jar包名 来直接部署，而打war包需将war包放入tomcat目录下的webapps，启动Tomcat才可以。
 
如何修改这些内嵌服务器的配置
 
查看ServerProperties.class类
 
public class ServerProperties {
 private Integer port;
 private InetAddress address;
 @NestedConfigurationProperty
 private final ErrorProperties error = new ErrorProperties();
 private ServerProperties.ForwardHeadersStrategy forwardHeadersStrategy;
 private String serverHeader;
 private DataSize maxHttpHeaderSize = DataSize.ofKilobytes(8L);
 private Shutdown shutdown;
 @NestedConfigurationProperty
 private Ssl ssl;
 @NestedConfigurationProperty
 private final Compression compression;
 @NestedConfigurationProperty
 private final Http2 http2;
 private final ServerProperties.Servlet servlet;
 private final ServerProperties.Tomcat tomcat;
 private final ServerProperties.Jetty jetty;
 private final ServerProperties.Netty netty;
 private final ServerProperties.Undertow undertow;
 
这些配置都可在application.yml/application-{profiles}.yml/application.properties等配置文件下配置，例如：
 
server:
  port: 8089
  #开启压缩
  compression:
    enable: true
    #压缩文件类型
    # 触发压缩的最小内容长度
    min-response-size: 2048
    mime-types: /*
  servlet:
    # session 过期时间，注意单位是秒
    session:
      timeout: 3600
  undertow:
    threads:
      io: 8
      worker: 256
 
如何切换内嵌服务器
 
由于我们在引入spring-boot-starter-web模块的时候，默认会将tomcat作为servlet容器。因此，在pom.xml中更改如下：
 
<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>
 
内嵌服务器自动配置原理介绍（如何使用）
 
在SpringBoot的自动配置类路径下找到：org\springframework\boot\spring-boot-autoconfigure\2.3.4.RELEASE\spring-boot-autoconfigure-2.3.4.RELEASE.jar!\org\springframework\boot\autoconfigure\web\servlet\ServletWebServerFactoryAutoConfiguration.class，
 
@Configuration(
 proxyBeanMethods = false
)
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(
 type = Type.SERVLET
)
@EnableConfigurationProperties({ServerProperties.class})
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
 
这里主要关注两个注解：
 @EnableConfigurationProperties({ServerProperties.class})//加载可配置的属性
 @Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})//导入内嵌服务器插件
 下面对具体实现进行分析：
 
public class ServletWebServerFactoryAutoConfiguration {
    public ServletWebServerFactoryAutoConfiguration() {
    }

    @Bean
    public ServletWebServerFactoryCustomizer servletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new ServletWebServerFactoryCustomizer(serverProperties);
    }

    @Bean
    @ConditionalOnClass(
        name = {"org.apache.catalina.startup.Tomcat"}
    )
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }

    @Bean
    @ConditionalOnMissingFilterBean({ForwardedHeaderFilter.class})
    @ConditionalOnProperty(
        value = {"server.forward-headers-strategy"},
        havingValue = "framework"
    )
    public FilterRegistrationBean<ForwardedHeaderFilter> forwardedHeaderFilter() {
        ForwardedHeaderFilter filter = new ForwardedHeaderFilter();
        FilterRegistrationBean<ForwardedHeaderFilter> registration = new FilterRegistrationBean(filter, new ServletRegistrationBean[0]);
        registration.setDispatcherTypes(DispatcherType.REQUEST, new DispatcherType[]{DispatcherType.ASYNC, DispatcherType.ERROR});
        registration.setOrder(-2147483648);
        return registration;
    }
//前面主要注册了三个Bean对象，分别为ServletWebServerFactoryCustomizer、TomcatServletWebServerFactoryCustomizer和FilterRegistrationBean。

    public static class BeanPostProcessorsRegistrar implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
        private ConfigurableListableBeanFactory beanFactory;

        public BeanPostProcessorsRegistrar() {
        }

        public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
            if (beanFactory instanceof ConfigurableListableBeanFactory) {
                this.beanFactory = (ConfigurableListableBeanFactory)beanFactory;
            }

        }

        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
            if (this.beanFactory != null) {
                this.registerSyntheticBeanIfMissing(registry, "webServerFactoryCustomizerBeanPostProcessor", WebServerFactoryCustomizerBeanPostProcessor.class);
                this.registerSyntheticBeanIfMissing(registry, "errorPageRegistrarBeanPostProcessor", ErrorPageRegistrarBeanPostProcessor.class);
            }
        }

        private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry, String name, Class<?> beanClass) {
            if (ObjectUtils.isEmpty(this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
                RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
                beanDefinition.setSynthetic(true);
                registry.registerBeanDefinition(name, beanDefinition);
            }

        }
    }
}
//后续三个函数主要注册了WebServerFactoryCustomizerBeanPostProcessor.class和ErrorPageRegistrarBeanPostProcessor.class两个类。
 
分析：
 WebServerFactoryCustomizerBeanPostProcessor.class：后置处理器。bean初始化前后（创建完对象，还没赋值），执行初始化工作。
 //如果当前初始化的是一个webServerFactory对象，就执行postProcessBeforeInitialization
 public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
 if (bean instanceof WebServerFactory) {
 this.postProcessBeforeInitialization((WebServerFactory)bean);
 }
 return bean;
 }
 //获取所有的定制器，调用每一个定制器的customize方法为其赋值。这里的customize方法就是为其做赋值处理的。
 private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
 ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
 customizer.customize(webServerFactory);
 });
 }

Jetty 是高性能的 Servlet 容器，经常会在开发环境中作为服务器来使用。在本文中，我们将使用 Spring Web MVC 技术来实现 REST 接口，并使用 使用 Jetty 作为内嵌服务器，方便测试。
 
接口设计
 
我们将会在系统中实现两个接口：
 
GET http://localhost:8080/hello
GET http://localhost:8080/hello/way
 
其中，第一个接口“/hello”将会返回“Hello World!” 的字符串；而第二个接口“/hello/way”则会返回一个包含用户信息的JSON字符串。
 
系统配置
 
我们需要在应用中添加如下依赖：
 
<properties>
    <spring.version>5.0.4.RELEASE</spring.version>
    <jetty.version>9.4.9.v20180320</jetty.version>
    <jackson.version>2.9.4</jackson.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.eclipse.jetty</groupId>
        <artifactId>jetty-servlet</artifactId>
        <version>${jetty.version}</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
</dependencies>
 
其中，
 
spring-webmvc 是为了使用 Spring MVC 的功能。
jetty-servlet是为了提供内嵌的 Servlet 容器，这样我们就无需依赖外部的容器，可以直接运行我们的应用。
jackson-core 和 jackson-databind 为我们的应用提供 JSON 序列化的功能。
 
后台编码实现
 
领域模型
 
创建一个 User 类，代表用户信息。
 
public class User {
    private String username;
    private Integer age;

    public User(String username, Integer age) {
        this.username = username;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

}
 
控制器
 
创建 HelloController 用于处理用户的请求。
 
@RestController
public class HelloController {

    @RequestMapping("/hello")
    public String hello() {
        return "Hello World! Welcome to visit waylau.com!";
    }

    @RequestMapping("/hello/way")
    public User helloWay() {
        return new User("Way Lau", 30);
    }
}
 
其中，映射到“/hello”的方法将会返回“Hello World!” 的字符串；而映射到“/hello/way”则会返回一个包含用户信息的JSON字符串。
 
应用配置
 
在本应用中，我们采用基于 Java 注解的配置。
 
AppConfiguration 是我们的主应用配置：
 
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan(basePackages = { "com.waylau.spring" })  
@Import({ MvcConfiguration.class })
public class AppConfiguration {

}
 
AppConfiguration 会扫描“com.waylau.spring”包下的文件，并自动将相关的 bean 进行注册。
 
AppConfiguration 同时又引入了 MVC 的配置类 MvcConfiguration：
 
@EnableWebMvc
@Configuration
public class MvcConfiguration implements WebMvcConfigurer {

    public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
        converters.add(new MappingJackson2HttpMessageConverter());
    }
}
 
MvcConfiguration 配置类一方面启用了 MVC 的功能，另一方面添加了 Jackson JSON 的转换器。
 
最后，我们需要引入 Jetty 服务器 JettyServer：
 
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.servlet.ServletContextHandler;
import org.eclipse.jetty.servlet.ServletHolder;
import org.springframework.web.context.ContextLoaderListener;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.servlet.DispatcherServlet;
import com.waylau.spring.mvc.configuration.AppConfiguration;

public class JettyServer {
    private static final int DEFAULT_PORT = 8080;
    private static final String CONTEXT_PATH = "/";
    private static final String MAPPING_URL = "/*";

    public void run() throws Exception {
        Server server = new Server(DEFAULT_PORT);
        server.setHandler(servletContextHandler(webApplicationContext()));
        server.start();
        server.join();
    }

    private ServletContextHandler servletContextHandler(WebApplicationContext context) {
        ServletContextHandler handler = new ServletContextHandler();
        handler.setContextPath(CONTEXT_PATH);
        handler.addServlet(new ServletHolder(new DispatcherServlet(context)), MAPPING_URL);
        handler.addEventListener(new ContextLoaderListener(context));
        return handler;
    }

    private WebApplicationContext webApplicationContext() {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfiguration.class);
        return context;
    }
}
 
JettyServer 将会在 Application 类中进行启动：
 
public class Application {

    public static void main(String[] args) throws Exception {
        new JettyServer().run();;
    }

}
 
11.13.6 运行
 
在编辑器中，直接运行 Application 类即可。启动之后，应能看到如下控制台信息：
 
2018-03-21 23:14:52.665:INFO::main: Logging initialized @203ms to org.eclipse.jetty.util.log.StdErrLog
2018-03-21 23:14:52.868:INFO:oejs.Server:main: jetty-9.4.9.v20180320; built: 2018-03-20T20:21:10+08:00; git: 1f8159b1e4a42d3f79997021ea1609f2fbac6de5; jvm 1.8.0_112-b15
2018-03-21 23:14:52.902:INFO:oejshC.ROOT:main: Initializing Spring root WebApplicationContext
三月 21, 2018 11:14:52 下午 org.springframework.web.context.ContextLoader initWebApplicationContext
信息: Root WebApplicationContext: initialization started
三月 21, 2018 11:14:52 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing Root WebApplicationContext: startup date [Wed Mar 21 23:14:52 CST 2018]; root of context hierarchy
三月 21, 2018 11:14:52 下午 org.springframework.web.context.support.AnnotationConfigWebApplicationContext loadBeanDefinitions
信息: Registering annotated classes: [class com.waylau.spring.mvc.configuration.AppConfiguration]
三月 21, 2018 11:14:53 下午 org.springframework.web.servlet.handler.AbstractHandlerMethodMapping$MappingRegistry register
信息: Mapped "{[/hello]}" onto public java.lang.String com.waylau.spring.mvc.controller.HelloController.hello()
三月 21, 2018 11:14:53 下午 org.springframework.web.servlet.handler.AbstractHandlerMethodMapping$MappingRegistry register
信息: Mapped "{[/hello/way]}" onto public com.waylau.spring.mvc.vo.User com.waylau.spring.mvc.controller.HelloController.helloWay()
三月 21, 2018 11:14:53 下午 org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter initControllerAdviceCache
信息: Looking for @ControllerAdvice: Root WebApplicationContext: startup date [Wed Mar 21 23:14:52 CST 2018]; root of context hierarchy
三月 21, 2018 11:14:53 下午 org.springframework.web.context.ContextLoader initWebApplicationContext
信息: Root WebApplicationContext: initialization completed in 983 ms
2018-03-21 23:14:53.893:INFO:oejshC.ROOT:main: Initializing Spring FrameworkServlet 'org.springframework.web.servlet.DispatcherServlet-6aaa5eb0'
三月 21, 2018 11:14:53 下午 org.springframework.web.servlet.FrameworkServlet initServletBean
信息: FrameworkServlet 'org.springframework.web.servlet.DispatcherServlet-6aaa5eb0': initialization started
三月 21, 2018 11:14:53 下午 org.springframework.web.servlet.FrameworkServlet initServletBean
信息: FrameworkServlet 'org.springframework.web.servlet.DispatcherServlet-6aaa5eb0': initialization completed in 15 ms
2018-03-21 23:14:53.910:INFO:oejsh.ContextHandler:main: Started o.e.j.s.ServletContextHandler@2796aeae{/,null,AVAILABLE}
2018-03-21 23:14:54.037:INFO:oejs.AbstractConnector:main: Started ServerConnector@42054532{HTTP/1.1,[http/1.1]}{0.0.0.0:8080}
2018-03-21 23:14:54.038:INFO:oejs.Server:main: Started @1578ms
 
分别在浏览器中访问 “http://localhost:8080/hello” 和 “http://localhost:8080/hello/way” 地址进行测试，能看到图1和图2的响应效果。
 
 
图1 “/hello”接口的返回内容
 
 
图2 “/hello/way”接口的返回内容
 
参考应用
 
源码:见《Spring 5 案例大全》（https://github.com/waylau/spring-5-book）的 “s5-ch11-mvc-rest”应用。
原文同步至：https://waylau.com/spring-mvc-use-jetty/

      在开发Java web项目时候，有时候需要使用内嵌服务器作为来运行web程序。
 
     现在介绍Java中常用的两种服务器Tomcat和jetty,实现web服务器的内嵌.
 
 1.Jetty服务器的内嵌
 
      Jetty是一个Java实现的开源的servlet容器，它既可以像Tomcat一样作为一个完整的Web服务器和Servlet容器，同时也可以嵌入在Java应用程序中，在Java程序中调用Jetty。
 
 
      步骤：
 
      （1）.首先下载jetty的jar包。
 
               我下载的是jetty-9.1.2.v20140210版本，
 
              下载地址：
 
              http://central.maven.org/maven2/org/eclipse/jetty/jetty-distribution/9.1.2.v20140210/jetty-distribution-             
 
              9.1.2.v20140210.zip
 
      （2）.新建Java项目
 
               项目结构：
 
                                                        
 
      （3）.解压,添加libs文件夹下除了文件夹其他所有的jar包和 lib/jsp文件夹下所有jar包到项目中去
 
 
 
 
 
       （4）.编写jetty启动类
 
 
 
import org.eclipse.jetty.server.Connector;
import org.eclipse.jetty.server.Server;
import org.eclipse.jetty.server.ServerConnector;
import org.eclipse.jetty.util.thread.QueuedThreadPool;
import org.eclipse.jetty.webapp.WebAppContext;

import java.io.File;


public class Main {

    public static void main(String[] args) {
        System.out.println("initJetty.........");
        initJetty();
    }

    public static  void initJetty() {
        try {
            QueuedThreadPool threadPool = new QueuedThreadPool();
            threadPool.setMaxThreads(300);
            threadPool.setMinThreads(3);

            Server server = new Server(threadPool);// 创建jetty web容器
            server.setStopAtShutdown(true);// 在退出程序是关闭服务

            // 创建连接器，每个连接器都是由IP地址和端口号组成，连接到连接器的连接将会被jetty处理
            ServerConnector connector = new ServerConnector(server);// 创建一个连接器
            connector.setHost("127.0.0.1");// ip地址
            connector.setPort(8080);// 连接的端口号
            connector.setName("connector0");
            server.addConnector(connector);// 添加连接

            // 配置服务
            WebAppContext context = new WebAppContext();// 创建服务上下文
            context.setContextPath("/");// 访问服务路径 http://{ip}:{port}/
            context.setConfigurationDiscovered(true);
            context.setClassLoader(Thread.currentThread().getContextClassLoader());
            String baseDir = Thread.currentThread().getContextClassLoader()
                    .getResource("").getPath();
//            context.setWar("WebRoot");
            context.setDescriptor(baseDir + File.separator + "/WEB-INF/web.xml");// 指明服务描述文件，就是web.xml
            // context.setDescriptor("/E:/workspace/strutsDemo/target/classes/\\/WEB-INF/web.xml");//
            // 指明服务描述文件，就是web.xml
            context.setResourceBase(System.getProperty("user.dir")
                    + "/WebContent");// 指定服务的资源根路径，配置文件的相对路径与服务根路径有关
            server.setHandler(context);// 添加处理try {
            server.start();// 开启服务
            server.join();
        } catch (Exception e) {
            e.printStackTrace();
            System.exit(1);
        }
    }
}
        （5）
运行结果： 
 
 
 2.Tomcat服务器的内嵌
 
 
 
       Tomcat是一个Java实现的开源的servlet容器可以嵌入在Java应用程序中，在Java程序中调用Jetty。
 
 
 
      步骤：
 
      （1）.首先下载Tomcat的jar包。
 
               我下载的是apache-tomcat-8.5.23-embed.zip版本，
 
              下载地址：
 
              http://mirror.bit.edu.cn/apache/tomcat/tomcat-8/v8.5.23/bin/embed/apache-tomcat-8.5.23-embed.zip
 
 
 
      （2）.新建Java项目
 
               项目结构：
 
                                                        
 
      （3）.解压,添加libs文件夹下除了文件夹其他所有的jar包和 lib/jsp文件夹下所有jar包到项目中去
 
              
 
 
 
       （4）.编写jetty启动类
 
                 
 

import org.apache.catalina.LifecycleException;
import org.apache.catalina.core.AprLifecycleListener;
import org.apache.catalina.core.StandardServer;
import org.apache.catalina.startup.Tomcat;

import javax.servlet.ServletException;
import java.io.File;

public class EmbeddedTomcat {

    private static Tomcat tomcat;

    public static Tomcat getTomcat() {
        return tomcat;
    }

    private static StandardServer server;

    private static AprLifecycleListener listener;

    public static void main(String[] args) throws LifecycleException, ServletException {
        tomcat = new Tomcat();
        // 主机名，或ip
        tomcat.setHostname("localhost");
        // 设置端口，80为默认端口
        tomcat.setPort(8989);
        // tomcat用于存储自身的信息，可以随意指定，最好包含在项目目录下
        tomcat.setBaseDir(".");
        // 建立server参照tomcat文件结构
        server = (StandardServer) tomcat.getServer();
        listener = new AprLifecycleListener();
        server.addLifecycleListener(listener);
        // 将appBase设为本项目所在目录
        //tomcat.getHost().setAppBase(".");
        tomcat.getHost().setAppBase(
                System.getProperty("user.dir") + File.separator + ".");

        // 第二个参数对应docBase为web应用路径，目录下应有WEB-INF,WEB-INF下要有web.xml
        tomcat.addWebapp("", "WebContent");

        // 启动tomcat
        tomcat.start();
        // 维持
        tomcat.getServer().await();

    }

}


 
 
       （5）运行结果：