十、SpringBoot之配置嵌入式Servlet容器及其原理

最新推荐文章于 2023-08-21 17:34:47 发布
最新推荐文章于 2023-08-21 17:34:47 发布
阅读量163 收藏
点赞数
分类专栏： spring boot 文章标签： SpringBoot 配置嵌入式Servlet容器 配置嵌入式Servlet容器原理

一、如何定制和修改Servlet容器的相关配置

1.修改Servlet容器的相关配置

  • 修改和server有关的配置（ServerProperties）； 
    //和server有关的配置
@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)
public class ServerProperties {

     

//和server有关的配置
@ConfigurationProperties(
    prefix = "server",
    ignoreUnknownFields = true
)
public class ServerProperties {

​​​

  • 编写一个WebServerFactoryCustomizer：嵌入式的Servlet容器的定制器，来修改Servlet容器的配置
  •     //配置嵌入式的servlet容器
    @Bean  //一定要将这个定制器加入到容器中
    public WebServerFactoryCustomizer<ConfigurableWebServerFactory> webServerFactoryCustomizer(){
        return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {
            @Override
            public void customize(ConfigurableWebServerFactory factory) {
                //定制嵌入式的Servlet容器相关的规则
                factory.setPort(8084);
            }
        };
    }

     

2.注册Servlet三大组件(Servlet、Filter、Listener)

SpringMvc是用web.xml文件来注册三大组件的。由于SpringBoot默认是以jar包的方式启动嵌入式的Servlet容器来启动SpringBoot的web应用，没有web.xml文件。

SpringBoot注册三大组件用以下方式:

  • ServletRegistrationBean
public class MyServlet extends HttpServlet {
    //处理get请求
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }
 
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello MyServlet");
    }
}

  1.  

//注册三大组件
@Bean
public ServletRegistrationBean myServlet(){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
    return registrationBean;
}
  • FilterRegistrationBean
public class MyFilter implements Filter {
 
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
 
    }
 
    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        System.out.println("MyFilter process...");
        filterChain.doFilter(servletRequest,servletResponse);
    }
 
    @Override
    public void destroy() {
 
    }
}

  1.  

    @Bean
public FilterRegistrationBean myFilter(){
    FilterRegistrationBean registrationBean = new FilterRegistrationBean();
    registrationBean.setFilter(new MyFilter());
    registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
    return registrationBean;
}

     

  • ServletListenerRegistrationBean
 
public class MyListener implements ServletContextListener {
 
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        System.out.println("contextInitialized...web应用启动");
    }
 
    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        System.out.println("contextDestroyed...当前web项目销毁");
    }
}

@Bean
public ServletListenerRegistrationBean myListener(){
    ServletListenerRegistrationBean<MyListener> registrationBean = new ServletListenerRegistrationBean<>(new MyListener());
    return registrationBean;
}

SpringBoot帮我们自动SpringMVC的时候，自动的注册SpringMVC的前端控制器；DIspatcherServlet；

在DispatcherServletAutoConfiguration中：

 
@AutoConfigureOrder(-2147483648)
@Configuration
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
@ConditionalOnClass({DispatcherServlet.class})
@AutoConfigureAfter({ServletWebServerFactoryAutoConfiguration.class})
@EnableConfigurationProperties({ServerProperties.class})
public class DispatcherServletAutoConfiguration {
 
        @Bean(
            name = {"dispatcherServletRegistration"}
        )
        @ConditionalOnBean(
            value = {DispatcherServlet.class},
            name = {"dispatcherServlet"}
        )
        public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet) {
            //默认拦截： /  （所有请求；包静态资源，但是不拦截jsp请求）；   /*（会拦截jsp）
            //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径
            DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet, this.serverProperties.getServlet().getPath());
            registration.setName("dispatcherServlet");
            registration.setLoadOnStartup(this.webMvcProperties.getServlet().getLoadOnStartup());
            if (this.multipartConfig != null) {
                registration.setMultipartConfig(this.multipartConfig);
            }
 
            return registration;
        }
    }

  1.  

二、SpringBoot也支持其他的Servlet容器

Spring Boot默认支持：

1.Tomcat（默认使用）

<dependency>
   <!--引入web模块默认就是使用嵌入式的Tomcat作为Servlet容器；-->
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>  
</dependency>

2.Jetty（长链接，例如，web聊天）

<!-- 引入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>
 
<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-jetty</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

3.Undertow（不支持JSP）

<!-- 引入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>
 
<!--引入其他的Servlet容器-->
<dependency>
   <artifactId>spring-boot-starter-undertow</artifactId>
   <groupId>org.springframework.boot</groupId>
</dependency>

三、嵌入式Servlet容器自动配置原理

ServletWebServerFactoryAutoConfiguration：嵌入式的Servlet容器自动配置类

@Configuration
@AutoConfigureOrder(-2147483648)
@ConditionalOnClass({ServletRequest.class})
@ConditionalOnWebApplication(
    type = Type.SERVLET
)
//导入BeanPostProcessorsRegistrar：给容器中导入一些组件
//导入了WebServerFactoryCustomizerBeanPostProcessor，后置处理器：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作
@EnableConfigurationProperties({ServerProperties.class})
@Import({ServletWebServerFactoryAutoConfiguration.BeanPostProcessorsRegistrar.class, EmbeddedTomcat.class, EmbeddedJetty.class, EmbeddedUndertow.class})
public class ServletWebServerFactoryAutoConfiguration {
 
    @Bean
    @ConditionalOnClass(
        name = {"org.apache.catalina.startup.Tomcat"} //判断当前是否引入了Tomcat依赖；
    )
    public TomcatServletWebServerFactoryCustomizer tomcatServletWebServerFactoryCustomizer(ServerProperties serverProperties) {
        return new TomcatServletWebServerFactoryCustomizer(serverProperties);
    }

    @Configuration
    //判断当前是否引入了Tomcat依赖；
    @ConditionalOnClass({Servlet.class, Tomcat.class, UpgradeProtocol.class})
    //判断当前容器没有用户自己定义ServletWebServerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )
    public static class EmbeddedTomcat {
        public EmbeddedTomcat() {
        }
 
        @Bean
        public TomcatServletWebServerFactory tomcatServletWebServerFactory() {
            return new TomcatServletWebServerFactory();
        }
    }

    @Configuration
    //判断当前是否引入了Server依赖；
    @ConditionalOnClass({Servlet.class, Server.class, Loader.class, WebAppContext.class})
    //判断当前容器没有用户自己定义ServletWebServerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )
    public static class EmbeddedJetty {
        public EmbeddedJetty() {
        }
 
        @Bean
        public JettyServletWebServerFactory JettyServletWebServerFactory() {
            return new JettyServletWebServerFactory();
        }
    }

    @Configuration
    //判断当前是否引入了Undertow依赖；
    @ConditionalOnClass({Servlet.class, Undertow.class, SslClientAuthMode.class})
    //判断当前容器没有用户自己定义ServletWebServerFactory：嵌入式的Servlet容器工厂；作用：创建嵌入式的Servlet容器
    @ConditionalOnMissingBean(
        value = {ServletWebServerFactory.class},
        search = SearchStrategy.CURRENT
    )
    public static class EmbeddedUndertow {
        public EmbeddedUndertow() {
        }
 
        @Bean
        public UndertowServletWebServerFactory undertowServletWebServerFactory() {
            return new UndertowServletWebServerFactory();
        }
    }

1.ServletWebServerFactory（嵌入式Servlet容器工厂）

@FunctionalInterface
public interface ServletWebServerFactory {
    获取嵌入式的Servlet容器
    WebServer getWebServer(ServletContextInitializer... initializers);
}

2.WebServer：（嵌入式的Servlet容器）

以TomcatWebServer为例

 public class TomcatWebServer implements WebServer {
    private static final Log logger = LogFactory.getLog(TomcatWebServer.class);
    private static final AtomicInteger containerCounter = new AtomicInteger(-1);
    private final Object monitor;
    private final Map<Service, Connector[]> serviceConnectors;
    private final Tomcat tomcat;
    private final boolean autoStart;
    private volatile boolean started;
 
    public TomcatWebServer(Tomcat tomcat, boolean autoStart) {
        this.monitor = new Object();
        this.serviceConnectors = new HashMap();
        Assert.notNull(tomcat, "Tomcat Server must not be null");
        this.tomcat = tomcat;
        this.autoStart = autoStart;
        this.initialize();
    }
 
    //初始化配置Tomcat并启动tomcat
    private void initialize() throws WebServerException {
        logger.info("Tomcat initialized with port(s): " + this.getPortsDescription(false));
        Object var1 = this.monitor;
        synchronized(this.monitor) {
            try {
                this.addInstanceIdToEngineName();
                Context context = this.findContext();
                context.addLifecycleListener((event) -> {
                    if (context.equals(event.getSource()) && "start".equals(event.getType())) {
                        this.removeServiceConnectors();
                    }
 
                });
                this.tomcat.start();
                this.rethrowDeferredStartupExceptions();
 
                try {
                    ContextBindings.bindClassLoader(context, context.getNamingToken(), this.getClass().getClassLoader());
                } catch (NamingException var5) {
                    ;
                }
 
                this.startDaemonAwaitThread();
            } catch (Exception var6) {
                this.stopSilently();
                throw new WebServerException("Unable to start embedded Tomcat", var6);
            }
 
        }
    }

3.对嵌入式容器的配置修改的原理

WebServerFactoryCustomizer和ServerProperties都是定制器帮我们修改了Servlet容器的配置。

  • 原理：

ServletWebServerFactoryAutoConfiguration导入BeanPostProcessorsRegistrar，作用：给容器中导入一些组件，给容器中导入了WebServerFactoryCustomizerBeanPostProcessor（后置处理器），作用：bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作。

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

public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {
 
    //初始化之前
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        //如果当前初始化的是一个WebServerFactory类型的组件
        if (bean instanceof WebServerFactory) {
            this.postProcessBeforeInitialization((WebServerFactory)bean);
        }
        return bean;
    }
 
    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
        ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
            //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
            customizer.customize(webServerFactory);
        });
    }
    
    private Collection<WebServerFactoryCustomizer<?>> getCustomizers() {
        if (this.customizers == null) {
            this.customizers = new ArrayList(this.getWebServerFactoryCustomizerBeans());
            this.customizers.sort(AnnotationAwareOrderComparator.INSTANCE);
            this.customizers = Collections.unmodifiableList(this.customizers);
        }
 
        return this.customizers;
    }
 
    private Collection<WebServerFactoryCustomizer<?>> getWebServerFactoryCustomizerBeans() {
         //从容器中获取所有这类型的组件：WebServerFactoryCustomizer
        //定制Servlet容器，给容器中可以添加一个WebServerFactoryCustomizer类型的组件
        return this.beanFactory.getBeansOfType(WebServerFactoryCustomizer.class, false, false).values();
    }
}
  • 步骤：
  1. SpringBoot给容器中添加相应的容器工厂ServletWebServerFactory；
  2. 容器中某个组件要创建对象就会惊动后置处理器；WebServerFactoryCustomizerBeanPostProcessor；只要是嵌入式的Servlet容器工厂，后置处理器就工作；
  3. 后置处理器，从容器中获取所有的WebServerFactoryCustomizer，调用定制器的定制方法。

四、嵌入式Servlet容器启动原理；

什么时候创建嵌入式的Servlet容器工厂？什么时候获取嵌入式的Servlet容器并启动Tomcat；

先启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来；

IOC容器启动创建嵌入式的Servlet容器

1.SpringBoot应用启动运行run方法

    public static void main(String[] args) {
        SpringApplication.run(SpringBootWebRestfulcrudApplication.class, args);
    }
 
    public static ConfigurableApplicationContext run(Class<?> primarySource, String... args) {
        return run(new Class[]{primarySource}, args);
    }
 
    public static ConfigurableApplicationContext run(Class<?>[] primarySources, String[] args) {
        return (new SpringApplication(primarySources)).run(args);
    }

2.SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】

  public ConfigurableApplicationContext run(String... args) {
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        ConfigurableApplicationContext context = null;
        Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList();
        this.configureHeadlessProperty();
        SpringApplicationRunListeners listeners = this.getRunListeners(args);
        listeners.starting();
 
        Collection exceptionReporters;
        try {
            ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
            ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
            this.configureIgnoreBeanInfo(environment);
            Banner printedBanner = this.printBanner(environment);
            //创建IOC容器
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
            //SpringBoot刷新IOC容器【创建IOC容器对象，并初始化容器，创建容器中的每一个组件】；
            this.refreshContext(context);
            this.afterRefresh(context, applicationArguments);
            stopWatch.stop();
            if (this.logStartupInfo) {
                (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
            }
 
            listeners.started(context);
            this.callRunners(context, applicationArguments);
        } catch (Throwable var10) {
            this.handleRunFailure(context, var10, exceptionReporters, listeners);
            throw new IllegalStateException(var10);
        }
 
        try {
            listeners.running(context);
            return context;
        } catch (Throwable var9) {
            this.handleRunFailure(context, var9, exceptionReporters, (SpringApplicationRunListeners)null);
            throw new IllegalStateException(var9);
        }
    }

protected ConfigurableApplicationContext createApplicationContext() {
        Class<?> contextClass = this.applicationContextClass;
        if (contextClass == null) {
            try {
                switch(this.webApplicationType) {
                case SERVLET:
                    contextClass = Class.forName("org.springframework.boot.web.servlet.context.AnnotationConfigServletWebServerApplicationContext");
                    break;
                case REACTIVE:
                    contextClass = Class.forName("org.springframework.boot.web.reactive.context.AnnotationConfigReactiveWebServerApplicationContext");
                    break;
                default:
                    contextClass = Class.forName("org.springframework.context.annotation.AnnotationConfigApplicationContext");
                }
            } catch (ClassNotFoundException var3) {
                throw new IllegalStateException("Unable create a default ApplicationContext, please specify an ApplicationContextClass", var3);
            }
        }
 
        return (ConfigurableApplicationContext)BeanUtils.instantiateClass(contextClass);
    }

3.刷新刚才创建好的ioc容器；

    private void refreshContext(ConfigurableApplicationContext context) {
        this.refresh(context);
        if (this.registerShutdownHook) {
            try {
                context.registerShutdownHook();
            } catch (AccessControlException var3) {
                ;
            }
        }
 
    }
 
    protected void refresh(ApplicationContext applicationContext) {
        Assert.isInstanceOf(AbstractApplicationContext.class, applicationContext);
        ((AbstractApplicationContext)applicationContext).refresh();
    }
 
    public void refresh() throws BeansException, IllegalStateException {
        Object var1 = this.startupShutdownMonitor;
        synchronized(this.startupShutdownMonitor) {
            this.prepareRefresh();
            ConfigurableListableBeanFactory beanFactory = this.obtainFreshBeanFactory();
            this.prepareBeanFactory(beanFactory);
 
            try {
                this.postProcessBeanFactory(beanFactory);
                this.invokeBeanFactoryPostProcessors(beanFactory);
                this.registerBeanPostProcessors(beanFactory);
                this.initMessageSource();
                this.initApplicationEventMulticaster();
                //先启动嵌入式的Servlet容器，再将ioc容器中剩下没有创建出的对象获取出来
                this.onRefresh();
                
                this.registerListeners();
                this.finishBeanFactoryInitialization(beanFactory);
                this.finishRefresh();
            } catch (BeansException var9) {
                if (this.logger.isWarnEnabled()) {
                    this.logger.warn("Exception encountered during context initialization - cancelling refresh attempt: " + var9);
                }
 
                this.destroyBeans();
                this.cancelRefresh(var9);
                throw var9;
            } finally {
                this.resetCommonCaches();
            }
 
        }
    }

4. web的ioc容器重写了onRefresh方法

ServletWebServerApplicationContext.java 
    protected void onRefresh() {
        super.onRefresh();
 
        try {
            this.createWebServer();
        } catch (Throwable var2) {
            throw new ApplicationContextException("Unable to start web server", var2);
        }
    }

5.web的ioc容器会创建嵌入式的Servlet容器；createWebServer();

private void createWebServer() {
        WebServer webServer = this.webServer;
        ServletContext servletContext = this.getServletContext();
        if (webServer == null && servletContext == null) {
            //获取嵌入式的Servlet容器工厂
            ServletWebServerFactory factory = this.getWebServerFactory();
            //使用容器工厂获取嵌入式的Servlet容器,嵌入式的Servlet容器创建对象并启动Servlet容器；
            this.webServer = factory.getWebServer(new ServletContextInitializer[]{this.getSelfInitializer()});
        } else if (servletContext != null) {
            try {
                this.getSelfInitializer().onStartup(servletContext);
            } catch (ServletException var4) {
                throw new ApplicationContextException("Cannot initialize servlet context", var4);
            }
        }
 
        this.initPropertySources();
    }

6.获取嵌入式的Servlet容器工厂

从ioc容器中获取ServletWebServerFactory 组件；ServletWebServerFactory创建对象，后置处理器一看是这个对象，就获取所有的定制器来先定制Servlet容器的相关配置；

7.使用容器工厂获取嵌入式的Servlet容器：

8.嵌入式的Servlet容器创建对象并启动Servlet容器；

代码 搬运工
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot之配置嵌入式Servlet容器.pdf
03-27
SpringBoot配置嵌入式Servlet容器；注册Servlet三大组件；嵌入式Servlet容器自动配置原理以及启动原理
Java --- springboot3之嵌入式容器原理
qq_46093575的博客
06-09 644
Web服务器的创建是通过WebServerFactory搞定的。容器中又会根据导了什么包条件注解，启动相关的 服务器配置，默认。Web场景的Spring容器启动，在onRefresh的时候，会调用创建web服务器的方法。，来禁用掉SpringBoot默认放的服务器工厂，实现自定义嵌入。⑥、refresh() 容器刷新 十二大步的刷新子容器会调用。ioc容器，启动的时候会调用创建web服务器。，导致项目启动，自动创建出Tomcat。的时候，会预留一个时机，刷新子容器。配置类，所有和服务器有关的配置。
SpringBoot学习
pjh88的博客
02-09 816
SpringBoot学习 什么是SpringBoot他的优点是什么？ SpringBoot简介 Spring Boot是Spring项目中的一个子工程，与我们所熟知的Spring-framework 同属于spring的产品: 首页Spring Boot官方介绍简介可以看到下面的一段介绍： Spring Boot的设计目的是让您尽可能快地启动和运行，而无需预先配置Spring。Spring Boot以一种固定的方式来构建可用于生产级别的应用程序。 一般把Spring Boot称为搭建程序的脚手架 或者说是
SpringBoot 嵌入式容器原理与配置说明
最新发布
z69183787的专栏
08-21 348
在 springboot1.x 版本中，通過來定製嵌入式的servlet容器，如下所示。//匯入BeanPostProcessorsRegistrar：給容器中匯入一些元件//匯入了EmbeddedServletContainerCustomizerBeanPostProcessor//後置處理器：bean初始化前後（建立完物件，還沒賦值賦值）執行初始化工作@ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當前是否引入了Tomcat依賴；
SpringBoot学习 — 自动装配原理二
Z2Min_
04-02 504
JSR 303校验 JSR 303 是JAVA EE 6 中的一项子规范，叫做 Bean Validation。 JSR 303 用于对 Java Bean 中的数据进行验证。 分析自动配置原理 在spring.factories下随便打开一个类进行分析，这里以HttpEncodingAutoConfiguration（Http编码自动配置）为例进行分析。 进入这个配置类： @...
关于嵌入式容器技术的调研
qq_32174521的博客
07-21 1708
最后，数据采集端环境千变万化，如果需要手动适配工作量巨大，如果采用容器化技术，只要打包几类典型的容器镜像，如ARM,X86,x86_64等，就可以事半功倍实现终端的发布工作。跨机器的可移植部署使用一个版本的Docker创建的对象可以传输并安装到任何其他支持Docker的Linux主机上。版本控制Docker可以用一种类似git的方式跟踪版本——您可以创建容器的新版本，将它们回滚等等。1.物联网(IoT)技术发展日新月异，而容器技术刚好遇到这样的机遇，将在几个方面促进物联网的发展。......
SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解
08-18
SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解 本文主要介绍了SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程，通过图文并茂的形式给大家介绍的非常详细，对大家的学习或工作具有...
SpringBoot学习之路—嵌入式Servlet容器自动配置原理
12-21
本篇将探讨的是如何实现嵌入式Servlet容器的自动配置，主要关注`EmbeddedServletContainerAutoConfiguration`类的作用和工作原理。 首先，`EmbeddedServletContainerAutoConfiguration`是Spring Boot自动配置的核心...
springboot2.3.1替换为其他的嵌入式servlet容器的详细方法
08-18
在 Spring Boot 2.3.1 中，默认情况下使用 Tomcat 作为嵌入式 Servlet 容器，但是如果我们想使用其他的Servlet容器，例如 Jetty 或 Netty，该如何实现呢？下面我们将详细介绍 Spring Boot 2.3.1 替换嵌入式 Servlet ...
嵌入式Linux容器技术
飞翔de刺猬
08-13 5674
嵌入式Linux容器技术 一、Linux容器技术 Linux Container容器是一种内核虚拟化技术，可以提供轻量级的虚拟化，以便隔离进程和资源。 LXC为Linux Container的简写。可以提供轻量级的虚拟化，以便隔离进程和资源，而且不需要提供指令解释机制以及全虚拟化的其他复杂性。相当于C++中的NameSpace。容器有效地将由单个操作系统管理的资源划分到孤立的组中，以更好地...
SpringBoot----嵌入式Servelt容器
m0_53157173的博客
08-03 561
嵌入式Servelt容器SpringBoot默认使用tomcat作为嵌入式的Servlet容器定制和修改Servelt容器的相关配置1.修改和Server有关的配置，去找对应绑定的类(ServerProperties)通用的Servlet设置和tomcat相关设置编写一个嵌入式的容器定制器（EmbeddedServletContainerCustomizer），来修改Servlet容器的相关配置EmbeddedServletContainerCustomizer不存在,SpringBoot2.0 以上，使用
Java高级技术
12-19
本阶段课程涵盖Java开发流行的自动化构建工具：Maven，版本控制系统：SVN和Git,容器虚拟化技术：Docker,权限模型：RBAC,集成测试：Jenkins,微服务架构：SpringCloud等核心内容。旨在应对各种实际开发情况下的的各种开发场景及业务的需要。
SpringBoot核心技术
03-22
SpringBoot是企业级开发的整体整合解决方案，特别用于快速构建微服务应用，旨在用最简单的方式让开发人员适应各种开发场景。 本视频着重介绍SpringBoot的使用和内部原理； 内容包含微服务概念、配置文件、日志框架的使用、web开发、Thymeleaf模板引擎、Docker容器技术、MyBatis、Spring Data JPA、自定义starter等； 学习本套视频最基本需要掌握Spring、SpringMVC、Maven；
SpringBoot嵌入式容器
qq_45429856的博客
10-23 422
Servlet web容器对比 jetty的优势： 主要看中其大小和灵活性，如果每一服务器能省1Mb,那么10s内就会省下GB量级的内存；jatty还具有可插拔和可扩的特性，可以最大限度的进行定制 undertow, 使红帽公司开发的一款基于INO的高性能web嵌入式服务器，兼容servlet3.1+规范，最大的特点是“轻量”，加载应用可<10M内存 Tomcat和jetty的比较 架构比较 Jetty的架构比Tomcat的更为简单 Jetty的架构是基于Handler来实现的，主要的扩展功能都可以
springboot-嵌入式Servlet容器自动配置原理
Javap 指令集
01-03 897
一、在springboot-autoconfigure的jar包下查找嵌入式的Servlet容器自动配置类 org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration.class   @AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE) @C...
SpringBoot嵌入式Web容器
YinXin的博客
08-16 4711
前言 传统的Servlet容器有Eclipse Jetty，Apache Tomcat。 Eclipse Jetty Jetty作为Eclipse基金会的一部分，是一个开源的项目。它是一个纯粹的基于Java的网页服务器和Java Servlet容器。支持静态动态内容。 特性： Asynchronous HTTP Server 异步 Standards based Servlet C...
SpringBoot源码学习之路（十一、嵌入式Servlet容器的配置、切换和启动原理 ）
.... 永远年轻，永远热泪盈眶
07-23 6271
嵌入式Servlet容器 SpringBoot默认使用Tomcat作为嵌入式的Servlet容器 一、如何定制和修改Servlet容器的相关配置？ 方式1、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）； #通用的Servlet容器设置 #server.xxx #Tomcat的设置 #serv...
学习C++之STL：常用集合算法set_intersection、set_union、set_difference
星辰大海的博客
09-08 609
算法简介： set_intersection：求两个容器的交集 set_union：求两个容器并集 set_difference：求两个容器的差集 这3个算法均由algorithm头文件提供。 set_intersection 函数原型：set_intersection(iterator beg1,iterator end1,iterator beg2,iterator end2,iterator dest) 作用：将容器1和容器2的交集（既属于容器1又属于容器2的部分）存到目标容器，dest为目标容器的起
SpringBoot嵌入式Servlet容器定制与配置详解
本文档主要探讨SpringBoot中嵌入式Servlet容器的配置与管理，特别是如何利用SpringBoot的自动配置和定制功能来定制化Tomcat等常用容器的行为。首先，SpringBoot默认选择Tomcat作为嵌入式Servlet容器，但用户可以根据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值