SpringBoot（七）——嵌入式容器配置

最新推荐文章于 2023-08-21 17:34:47 发布
最新推荐文章于 2023-08-21 17:34:47 发布
阅读量286 收藏 1
点赞数
分类专栏： spring boot 文章标签： spring boot web服务器 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43691723/article/details/107295102
版权

文章目录

1. 如何定制和修改Servlet容器的相关配置

SpringBoot 默认使用Tomcat作为嵌入式的容器。

  1. 修改和server相关的配置（相关配置都在ServerProperties 类中）
server.port=8081
server.tomcat.uri-encoding=UTF-8
server.servlet.context-path=/crud

//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx
  1. 编写一个EmbeddedServletContainerCustomizer，2.0以后改为WebServerFactoryCustomizer：嵌入式的Servlet容器的定制器；来修改Servlet容器的配置
@Configuration //实现WebMvcConfigurer接口可以来扩展SpringMVC的功能 
public class MyMvcConfig implements WebMvcConfigurer {

    //编写WebServerFactoryCustomizer来修改Servlet容器的配置
    @Bean
    public WebServerFactoryCustomizer webServletFactoryCustomizer(){
        return new WebServerFactoryCustomizer<ConfigurableWebServerFactory>() {

            @Override //修改相关配置
            public void customize(ConfigurableWebServerFactory factory) {
                factory.setPort(8082);
            }
        };
    }
 }

代码方式的配置会覆盖配置文件的配置

2. 注册Servlet三大组件

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

注册三大组件用以下方式

2.1 Servlet

编写Servlet，继承javax.http.HttpServlet，重载方法

//自定义Servlet
public class MyServlet extends HttpServlet {
    @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 Servlet");
    }
}

注册servlet

@Configuration
public class MyServerConfig {

    //注册自己的servlet
    @Bean
    public ServletRegistrationBean myServlet() {
        ServletRegistrationBean servletRegistrationBean = new ServletRegistrationBean(new MyServlet(),  "/myServlet");
        return servletRegistrationBean;
    }
...
}

2.2 Filter

编写Filter，实现javax.servlet.Filter 接口，实现相关方法

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.....");
        filterChain.doFilter(servletRequest,servletResponse);
    }
    @Override
    public void destroy() {

    }
}

注册Filter

@Configuration
    public class MyServerConfig {

        //注册filetr
        @Bean
        public FilterRegistrationBean myFilter() {
            FilterRegistrationBean register = new FilterRegistrationBean(new MyFilter());
            //设置拦截路径
            register.setUrlPatterns(Arrays.asList("/myServlet","/"));
            return register;
        }
        ...
      }

2.3 Listener

自定义Listener，有很多不同的Listener，这里写的是监听容器初始化和销毁的Listener

//自定义监听容器创建销毁的listener
public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("contextInitialized...");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("contextDestroyed...");
    }
}

注册listener


    @Configuration
    public class MyServerConfig {
        //注册Listener
        @Bean
        public ServletListenerRegistrationBean myListener() {
            ServletListenerRegistrationBean servletListenerRegistrationBean = new ServletListenerRegistrationBean(new MyListener());
            return servletListenerRegistrationBean;
        }
        ...
      }

SpringBoot 自动配置SpringMvc的时候，自动的注册SpringMVC的前端控制器DIspatcherServlet, DispatcherServletAutoConfiguration中：

 @Bean(
            name = {"dispatcherServletRegistration"}
        )
        @ConditionalOnBean(
            value = {DispatcherServlet.class},
            name = {"dispatcherServlet"}
        )
        public DispatcherServletRegistrationBean dispatcherServletRegistration(DispatcherServlet dispatcherServlet, WebMvcProperties webMvcProperties, ObjectProvider<MultipartConfigElement> multipartConfig) {
        	//默认拦截的路径是/,拦截所有请求包括静态资源，但是不包括jsp，/*的话，会拦截jsp
        	//可以通过spring.mvc.servlet.path来修改
            DispatcherServletRegistrationBean registration = new DispatcherServletRegistrationBean(dispatcherServlet, webMvcProperties.getServlet().getPath());
            registration.setName("dispatcherServlet");
            registration.setLoadOnStartup(webMvcProperties.getServlet().getLoadOnStartup());
            multipartConfig.ifAvailable(registration::setMultipartConfig);
            return registration;
        }

3. 使用其他的嵌入式容器

SpringBoot默认使用的是Tomcat，并且支持Jetty(使用与长连接，比如通话，聊天)、Undertow(不支持jsp）、Netty

在这里插入图片描述

如果要换成其他的就把Tomcat的依赖排除掉，然后引入其他嵌入式Servlet容器的以来，如Jetty，Undertow，Netty

使用jetty

<!--引入web模板-->
  <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-web</artifactId>
       <exclusions>
           <exclusion>
               <artifactId>spring-boot-starter-tomcat</artifactId>
               <groupId>org.springframework.boot</groupId>
           </exclusion>
       </exclusions>
   </dependency>

   <!--引入其他Web容器-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-jetty</artifactId>
   </dependency>

使用Undertow

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

   <!--引入其他Web容器-->
   <dependency>
       <groupId>org.springframework.boot</groupId>
       <artifactId>spring-boot-starter-undertow</artifactId>
   </dependency>

4. 嵌入式Servlet容器自动配置原理

查看web容器自动配置类

2.0以下是：EmbeddedServletContainerAutoConfiguration，2.0以下是ServletContainer，2.0以上是WebServer

ServletWebServerFactoryAutoConfiguration：嵌入式的web服务器自动配置类

@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})
public class ServletWebServerFactoryAutoConfiguration {

EmbeddedTomcat.class

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

ServletWebServerFactory：嵌入式的web服务器工厂

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

嵌入式servlet容器工厂（ServletWebServerFactory 实现类）：
在这里插入图片描述
WebServer：嵌入式Servlet容器
在这里插入图片描述
嵌入式容器工厂和容器的对应，是依靠相应的@ConditionalOnClass相应的注解实现的，比如Tomcat
在这里插入图片描述

以TomcatServletWebServerFactory为例，下面是TomcatServletWebServerFactory类

 public WebServer getWebServer(ServletContextInitializer... initializers) {
        if (this.disableMBeanRegistry) {
            Registry.disableRegistry();
        }
		
		//创建Tomcat
        Tomcat tomcat = new Tomcat();

		 //配置Tomcat的基本环境，（tomcat的配置都是从本类获取的，tomcat.setXXX）
        File baseDir = this.baseDirectory != null ? this.baseDirectory : this.createTempDir("tomcat");
        tomcat.setBaseDir(baseDir.getAbsolutePath());
        Connector connector = new Connector(this.protocol);
        connector.setThrowOnFailure(true);
        tomcat.getService().addConnector(connector);
        this.customizeConnector(connector);
        tomcat.setConnector(connector);
        tomcat.getHost().setAutoDeploy(false);
        this.configureEngine(tomcat.getEngine());
        Iterator var5 = this.additionalTomcatConnectors.iterator();

        while(var5.hasNext()) {
            Connector additionalConnector = (Connector)var5.next();
            tomcat.getService().addConnector(additionalConnector);
        }
		
		 //将配置好的Tomcat传入进去，返回一个WebServer；并且启动Tomcat服务器
        this.prepareContext(tomcat.getHost(), initializers);
        return this.getTomcatWebServer(tomcat);
    }

我们对嵌入式容器的配置修改是怎么生效的？

5. 配置修改原理

EmbeddedServletContainerCustomizer：定制器帮我们修改了Servlet容器的配置

在像容器中注册ServletWebServerFactoryAutoConfiguration时，也注册了BeanPostProcessorsRegistrar

在这里插入图片描述
BeanPostProcessorsRegistrar：后置处理器注册器(给容器注入一些组件)

 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);
            }
        }
        ...
}

webServerFactoryCustomizerBeanPostProcessor：嵌入式Servlet容器定制器的后置处理器，在bean初始化前后（创建完对象，还没赋值赋值）执行初始化工作

public class WebServerFactoryCustomizerBeanPostProcessor implements BeanPostProcessor, BeanFactoryAware {
   ....
   
   //在Bean初始化之前
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        
		//判断添加的Bean是不是WebServerFactory类型的,是就执行postProcessBeforeInitialization
		if (bean instanceof WebServerFactory) {
            this.postProcessBeforeInitialization((WebServerFactory)bean);
        }

        return bean;
    }


    private void postProcessBeforeInitialization(WebServerFactory webServerFactory) {
    	
    	 //获取所有的定制器，调用每一个定制器的customize方法来给Servlet容器进行属性赋值；
        ((Callbacks)LambdaSafe.callbacks(WebServerFactoryCustomizer.class, this.getCustomizers(), webServerFactory, new Object[0]).withLogger(WebServerFactoryCustomizerBeanPostProcessor.class)).invoke((customizer) -> {
            customizer.customize(webServerFactory);
        });
    }

   ...
}

使用配置文件来配置Servlet容器，底层也是用的EmbeddedServletContainerCustomizer嵌入式servlet容器定制器来完成配置的。

总结：

  1. SpringBoot根据导入的依赖情况，给容器中添加相应的XXXServletWebServerFactory
  2. 容器中某个组件要创建对象就会惊动后置处理器 webServerFactoryCustomizerBeanPostProcessor,只要是嵌入式的是Servlet容器工厂，后置处理器就会工作
  3. 后置处理器，从容器中获取所有的WebServerFactoryCustomizer，调用定制器的定制方法给工厂添加配置

6. 嵌入式Servlet容器启动原理

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

获取嵌入式的Servlet容器工厂步骤：

  1. SpringBoot应用启动运行run方法
  2. refreshContext(context) SpringBoot刷新IOC容器（创建IOC容器对象，并初始化容器，创建容器中的每一 个组件），根据当前环境创建IOC容器
    在这里插入图片描述

在这里插入图片描述

  1. refresh(context) 刷新刚才创建好的ioc容器，和spring中的一样
 public void refresh() throws BeansException, IllegalStateException {
        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();
                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();
            }

        }
    }
  1. onRefresh() web的ioc容器重写了onRefresh方法，查看ServletWebServerApplicationContext类的onRefresh方法，在方法中调用了this.createWebServer()，创建web容器
protected void onRefresh() {
    super.onRefresh();

    try {
        this.createWebServer();
    } catch (Throwable var2) {
        throw new ApplicationContextException("Unable to start web server", var2);
    }
}

**createWebServer**中，获取嵌入式的web容器工厂并且创建Servle容器对象

在这里插入图片描述
5. 接下来就是上面的上面的相关配置流程，在创建web容器工厂时会触发webServerFactoryCustomizerBeanPostProcessor
6. 使用容器工厂获取嵌入式的Servlet容器
7. 嵌入式的Servlet容器创建对象并启动Servlet容器
8. 嵌入式的Servlet容器启动后，再将ioc容器中剩下没有创建出的对象获取出来(Controller,Service等)

也就是说，IOC容器启动的时候，创建并启动Servlet容器

7. 使用外置的Servlet容器

使用嵌入式的Servlet容器

  • 优点：方便、快捷
  • 缺点：默认不支持JSP，优化定制比较复杂（使用定期器，在配置文件中修改配置，或者使用WebServerFactoryCustomizer，也可以自定义WebServerFactory）

7.1 步骤

  1. 将项目的打包方式改为war
  2. 编写一个类继承**SpringBootServletInitializer**，并重写configure方法，调用参数的sources方法，将springboot启动类传过去
public class ServletInitializer extends SpringBootServletInitializer {

    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
    	//传入SpringBoot应用的主程序
        return application.sources(SpringBoot04WebJspApplication.class);
    }

}
  1. 将嵌入式的tomcat的依赖范围改为provided
<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        .....
</dependencies>
  1. 创建web应用的目录结构，webapp目录以及里面的WEB-INF目录和web.xml
    在这里插入图片描述
    添加webapp目录，和WEB-INF/web.xml文件
    在这里插入图片描述
  2. 最后就可以把项目打包成war放到tomcat中了， 在IDEA中可以这样配置
    在这里插入图片描述

在创建SpringBoot项目时，使用Spring Initializr创建，选择打包方式为war，1，2，3步骤会自动配置。

7.2 原理

jar包：执行SpringBoot主类的main方法，启动ioc容器，创建嵌入式的Servlet容器；
war包：：启动服务器，服务器启动SpringBoot应用【SpringBootServletInitializer】，启动ioc容器

  1. Servlet3.0标准规定，应用启动时，扫描所有jar包中META-INF/services/javax.servlet.ServletContainerInitializer文件中指定的类并加载

  2. 还可以使用@HandlesTypes，在应用启动的时候加载我们感兴趣的类；

  3. 在spring-web-xxx.jar包中的META-INF/services下有javax.servlet.ServletContainerInitializer这个文件，文件中的类是：

org.springframework.web.SpringServletContainerInitializer

对应的类：

@HandlesTypes({WebApplicationInitializer.class})
public class SpringServletContainerInitializer implements ServletContainerInitializer {
    public SpringServletContainerInitializer() {
    }

    public void onStartup(@Nullable Set<Class<?>> webAppInitializerClasses, ServletContext servletContext) throws ServletException {
    ....
    }
  1. SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>，为这些WebApplicationInitializer类型的类创建实例；
  2. 每一个WebApplicationInitializer都调用自己的onStartup方法
  3. WebApplicationInitializer的实现类
    在这里插入图片描述
  4. 我们的SpringBootServletInitializer的类会被创建对象，并执行onStartup方法
  5. SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext；创建容器
 public void onStartup(ServletContext servletContext) throws ServletException {
        this.logger = LogFactory.getLog(this.getClass());
        WebApplicationContext rootApplicationContext = this.createRootApplicationContext(servletContext);
        if (rootApplicationContext != null) {
            servletContext.addListener(new SpringBootServletInitializer.SpringBootContextLoaderListener(rootApplicationContext, servletContext));
        } else {
            this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not return an application context");
        }

    }

createRootApplicationContext ：创建容器

protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
		
		//1、创建SpringApplicationBuilder
        SpringApplicationBuilder builder = this.createSpringApplicationBuilder();
        builder.main(this.getClass());
        ApplicationContext parent = this.getExistingRootWebApplicationContext(servletContext);
        if (parent != null) {
            this.logger.info("Root context already created (using as parent).");
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, (Object)null);
            builder.initializers(new ApplicationContextInitializer[]{new ParentContextApplicationContextInitializer(parent)});
        }

        builder.initializers(new ApplicationContextInitializer[]{new ServletContextApplicationContextInitializer(servletContext)});
        builder.contextClass(AnnotationConfigServletWebServerApplicationContext.class);

		//调用configure方法，自定义的SpringBootServletInitializer子类重写了这个方法，将SpringBoot的主程序类传入了进来
        builder = this.configure(builder);
        builder.listeners(new ApplicationListener[]{new SpringBootServletInitializer.WebEnvironmentPropertySourceInitializer(servletContext)});
       
        //使用builder创建一个Spring应用
        SpringApplication application = builder.build();
        if (application.getAllSources().isEmpty() && MergedAnnotations.from(this.getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
            application.addPrimarySources(Collections.singleton(this.getClass()));
        }

        Assert.state(!application.getAllSources().isEmpty(), "No SpringApplication sources have been defined. Either override the configure method or add an @Configuration annotation");
        if (this.registerErrorPageFilter) {
            application.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
        }

        application.setRegisterShutdownHook(false);
        //调用run方法，启动spring应用
        return this.run(application);
    }
  1. Spring的应用就启动并且创建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);
            context = this.createApplicationContext();
            exceptionReporters = this.getSpringFactoriesInstances(SpringBootExceptionReporter.class, new Class[]{ConfigurableApplicationContext.class}, context);
            this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

			//刷新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);
        }
    }

启动Servlet容器，再启动SpringBoot应用

ewenll
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
20年架构师用一文带你彻底搞懂SpringBoot嵌入式Web容器原理
m0_63213253的博客
10-24 173
Spring Boot嵌入式Web容器原理 Spring Boot的目标是构建“非常容易创建、独立、产品级别的基于Spring的应用”。这些应用是“立即可运行的”。在这个过程中，完全没有代码生成，不需要配置任何特殊的XML配置，为了这个目标，Spring Boot在Spring 4.0框架之上提供了很多特性，帮助应用以“约定优于配置”“开箱即用”的方式来启动应用并运行上下文。 Spring Boot同样改变了一个传统的Web应用服务的启动流程和部署方式。通过自动配置机制，Spring Boot提供了一个
Springboot配置嵌入式Servlet容器
song_quan_的博客
10-12 116
1.SpringBoot默认使用Tomcat作为嵌入式的Servlet容器； 1）、如何定制和修改Servlet容器的相关配置； 1、修改和server有关的配置（ServerProperties【也是EmbeddedServletContainerCustomizer】）； 2、编写一个EmbeddedServletContainerCustomizer：嵌入式的Servlet容器的定制器；来修改Servlet容器的 配置 （更新servlet端口） 2）、注册...
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-2-嵌入式容器
zhoubangbang1的博客
02-15 628
SpringBoot---嵌入式容器SpringBoot支持嵌入式容器（比如：Apache Tomcat, Eclipse Jetty, RedHat Undertow），默认情况下使用tomcat.1.修改Tomcat版本 SpringBoot 2.6.3版本默认采用的是*Apache Tomcat/9.0.56版本日志显示:INFO 25080 --- [          
Spring boot 之内嵌服务器
qq_38571892的博客
03-10 5662
什么是内嵌式服务器 所谓内嵌式服务器就是不需要我们单独部署，集成到Spring Boot中的服务器。 回想一下，我们如何访问传统的web项目？首先我们需要在系统（如linux系统）中安装web服务器（如tomcat），然后将我们的应用程序打包成war，再将war包放入tomcat目录下的webapps，启动Tomcat，才可以正常访问我们的web项目。 那内嵌式服务器有什么好处呢？好处就是不需要我们进行上述繁琐的操作了，Spring boot会直接将项目打包成jar包，但是这个jar包和我们传统意义的jar
SpringBoot学习之路—嵌入式Servlet容器自动配置原理
12-21
本篇将探讨的是如何实现嵌入式Servlet容器的自动配置，主要关注`EmbeddedServletContainerAutoConfiguration`类的作用和工作原理。 首先，`EmbeddedServletContainerAutoConfiguration`是Spring Boot自动配置的核心...
java面试——SpringBoot面试专题.zip
09-26
- **嵌入式Servlet容器**：Spring Boot支持内嵌Tomcat、Jetty等Servlet容器，无需单独部署。 2. **Spring Boot的启动流程** - **SpringApplication.run()**：这是启动Spring Boot应用的入口，它会创建...
-Springboot致远汽车租赁系统.zip
07-03
3. 部署：Springboot的嵌入式Servlet容器（如Tomcat）使得应用可以直接打包为jar文件，简化部署流程。 六、总结 “致远汽车租赁系统”充分利用了Springboot的优势，实现了高效、稳定的汽车租赁业务管理。其设计思路...
基于springboot数码论坛系统.zip
最新发布
03-24
SpringBoot通过自动配置、starter组件和嵌入式Web服务器等特性，使得开发者可以快速构建应用程序，无需繁琐的配置。在这个数码论坛系统中，SpringBoot负责初始化和管理应用上下文，提供依赖注入，同时内置Tomcat...
-Springboot一起来约苗系统.zip
07-03
SpringBoot非常适合构建微服务，因为它支持嵌入式Servlet容器，可以快速打包为可执行的jar，便于部署和维护。 在前端，虽然具体文件列表未提供，但通常SpringBoot项目会配合Thymeleaf、Freemarker或Velocity等模板...
spring-boot入门学习之配置嵌入式Servlet容器
weixin_42310074的博客
08-06 132
1.springboot默认使用的是嵌入式Servlet容器（tomcat）: 1).修改和Servlet相关的配置(ServerProperties【也是EmbeddedServletContainerCustomizer】): server.port=8081 server.servlet.context-path=/crud server.tomcat.accesslog.encoding=utf-8 2).编写一个EmbeddedServletContainerCustomizer：嵌入式的Se
SpringBoot----嵌入式Servelt容器
m0_53157173的博客
08-03 560
嵌入式Servelt容器SpringBoot默认使用tomcat作为嵌入式的Servlet容器定制和修改Servelt容器的相关配置1.修改和Server有关的配置，去找对应绑定的类(ServerProperties)通用的Servlet设置和tomcat相关设置编写一个嵌入式的容器定制器（EmbeddedServletContainerCustomizer），来修改Servlet容器的相关配置EmbeddedServletContainerCustomizer不存在,SpringBoot2.0 以上，使用
011 嵌入式容器
weixin_30414305的博客
10-03 97
一 .概述 　　在springboot之中,有一个特点就是使用了嵌入式的web容器帮助我们实现快速的构建. 　　现在的版本之中默认使用的就是tomcat组件,本次我们说明一下嵌入式容器的一些内容. 二 .基本配置的修改 　　 在主配置文件之中,我们能够修改嵌入式容器的一些内容,通常情况下我们修改最多的就是端口这样的信息了. 三 .替换嵌入式容器 　　当我们不想使用T...
6.Spring Boot 嵌入式容器
u012708900的博客
11-10 215
嵌入式Servlet Web容器 Servlet Tomcat Jetty Undertow 2.5 6.x 6.x - 3.0 7.x 7.x - 3.1 8.x 8.x 1.x 4.0 9.x 9.x 2.x 使用Tomcat 从Spring Boot 项目的pom.xml文件中我们可以看到如果是spring-boot-starter-web默认依赖的有spring-boot-starter-tomcat 从项目运行的日志中，我们也可以看到，启动的是Tomcat。
SpringBoot深入（一）--SpringBoot内置web容器及配置
m0_67401055的博客
04-26 916
版权声明：作者原创，转载请注明出处。 本系列文章目录地址：http://blog.csdn.net/u011961421/article/details/79416510 前言 在学会基本运用SpringBoot同时，想必搭过SSH、SSM等开发框架的小伙伴都有疑惑，SpringBoot在spring的基础上做了些什么，使得使用SpringBoot搭建开发框架能如此简单，便捷，快速。本系列文章记录博主网罗博客、分析源码、结合微薄经验后的总结，以便日后翻阅自省。 正文 使用SpringBoot时，首先引人.
配置嵌入式Servlet容器
qq_40857365的博客
03-12 120
SpringBoot默认使用TomCat作为嵌入式的Servlet容器 如何定制和修改Servlet容器的相关配置 修改和Servlet有关的配置（ServerProperties） //通用的Servlet容器设置 server.xxx= //Tomcat的设置 server.tomcat.xxx= 编写一个WebServerFactoryCustomizer @Bean public WebServerFactoryCustomizer webServerFactoryCustomiz
嵌入式Linux容器技术
飞翔de刺猬
08-13 5671
嵌入式Linux容器技术 一、Linux容器技术 Linux Container容器是一种内核虚拟化技术，可以提供轻量级的虚拟化，以便隔离进程和资源。 LXC为Linux Container的简写。可以提供轻量级的虚拟化，以便隔离进程和资源，而且不需要提供指令解释机制以及全虚拟化的其他复杂性。相当于C++中的NameSpace。容器有效地将由单个操作系统管理的资源划分到孤立的组中，以更好地...
SpringBoot 嵌入式容器原理与配置说明
z69183787的专栏
08-21 348
在 springboot1.x 版本中，通過來定製嵌入式的servlet容器，如下所示。//匯入BeanPostProcessorsRegistrar：給容器中匯入一些元件//匯入了EmbeddedServletContainerCustomizerBeanPostProcessor//後置處理器：bean初始化前後（建立完物件，還沒賦值賦值）執行初始化工作@ConditionalOnClass({ Servlet.class, Tomcat.class })//判斷當前是否引入了Tomcat依賴；
关于嵌入式容器技术的调研
qq_32174521的博客
07-21 1708
最后，数据采集端环境千变万化，如果需要手动适配工作量巨大，如果采用容器化技术，只要打包几类典型的容器镜像，如ARM,X86,x86_64等，就可以事半功倍实现终端的发布工作。跨机器的可移植部署使用一个版本的Docker创建的对象可以传输并安装到任何其他支持Docker的Linux主机上。版本控制Docker可以用一种类似git的方式跟踪版本——您可以创建容器的新版本，将它们回滚等等。1.物联网(IoT)技术发展日新月异，而容器技术刚好遇到这样的机遇，将在几个方面促进物联网的发展。......
SpringBoot嵌入式Servlet容器定制与配置详解
本文档主要探讨SpringBoot中嵌入式Servlet容器的配置与管理，特别是如何利用SpringBoot的自动配置和定制功能来定制化Tomcat等常用容器的行为。首先，SpringBoot默认选择Tomcat作为嵌入式Servlet容器，但用户可以根据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值