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
    评论
专栏目录
SpringBoot深入（一）--SpringBoot内置web容器及配置
m0_67401055的博客
04-26 916
版权声明：作者原创，转载请注明出处。 本系列文章目录地址：http://blog.csdn.net/u011961421/article/details/79416510 前言 在学会基本运用SpringBoot同时，想必搭过SSH、SSM等开发框架的小伙伴都有疑惑，SpringBoot在spring的基础上做了些什么，使得使用SpringBoot搭建开发框架能如此简单，便捷，快速。本系列文章记录博主网罗博客、分析源码、结合微薄经验后的总结，以便日后翻阅自省。 正文 使用SpringBoot时，首先引人.
Spring boot 之内嵌服务器
qq_38571892的博客
03-10 5666
什么是内嵌式服务器 所谓内嵌式服务器就是不需要我们单独部署，集成到Spring Boot中的服务器。 回想一下，我们如何访问传统的web项目？首先我们需要在系统（如linux系统）中安装web服务器（如tomcat），然后将我们的应用程序打包成war，再将war包放入tomcat目录下的webapps，启动Tomcat，才可以正常访问我们的web项目。 那内嵌式服务器有什么好处呢？好处就是不需要我们进行上述繁琐的操作了，Spring boot会直接将项目打包成jar包，但是这个jar包和我们传统意义的jar
Java --- springboot3之嵌入式容器原理
qq_46093575的博客
06-09 644
Web服务器的创建是通过WebServerFactory搞定的。容器中又会根据导了什么包条件注解，启动相关的 服务器配置，默认。Web场景的Spring容器启动，在onRefresh的时候，会调用创建web服务器的方法。，来禁用掉SpringBoot默认放的服务器工厂，实现自定义嵌入。⑥、refresh() 容器刷新 十二大步的刷新子容器会调用。ioc容器，启动的时候会调用创建web服务器。，导致项目启动，自动创建出Tomcat。的时候，会预留一个时机，刷新子容器。配置类，所有和服务器有关的配置。
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)技术发展日新月异，而容器技术刚好遇到这样的机遇，将在几个方面促进物联网的发展。......
嵌入式Linux容器技术
飞翔de刺猬
08-13 5675
嵌入式Linux容器技术 一、Linux容器技术 Linux Container容器是一种内核虚拟化技术，可以提供轻量级的虚拟化，以便隔离进程和资源。 LXC为Linux Container的简写。可以提供轻量级的虚拟化，以便隔离进程和资源，而且不需要提供指令解释机制以及全虚拟化的其他复杂性。相当于C++中的NameSpace。容器有效地将由单个操作系统管理的资源划分到孤立的组中，以更好地...
【boot开发】SpringBoot JPA + H2嵌入式
a23452的博客
06-10 1754
SpringBootSpringBoot开发技术工具类CommonUtil的创建使用到正则表达式，不清楚的看之前的blog，对于日期的格式化，we使用的是static块，在其中对成员变量daysLookup和englishFormater进行赋值，就是自定义一个日期格式化DateTimeFormatter，自定义的方式通过DateTimeFormatterBuilder，append自定义格式即可【pattern，text，literal（按字面意义的）】JPA是一个全自动的持久层框架，相比Mybatis的
springboot项目启动报org.apache.tomcat.util.modeler.Registry.disableRegistry的错误
qq_27577113的博客
02-03 1191
结合网上的众多说法分析，发现这是因为本地有太多依赖版本导致的错误，解决方式就是重新引入maven依赖，把org.springframework.boot这个文件夹删了让他重新下载就行了，找到这个本地仓库，删掉就行 ...
springboot项目启动报错org.apache.tomcat.util.modeler.Registry.disableRegistry()V
Dark_Blue__的博客
07-07 3650
springboot项目启动报org.apache.tomcat.util.modeler.Registry.disableRegistry的错误 原因就是spring boot的版本和tomcat的版本不对应导致的 spring-boot-dependencies中版本如果是2.4.0的时候，对应的tomcat的配置为<tomcat.version>9.0.39</tomcat.version>，如果tomcat的版本是8.xx的话，此时启动服务就会出异常。 这个时候，有两个选择：
SpringBoot运行时提示NoSuchMethodError以及更换Tomcat版本后无法启动的解决方案
weixin_42290467的博客
04-28 6136
最近在练习项目时发现SpringBoot每次运行后再调用对应的Controller后控制台总会提示NoSuchMethodError:.....HttpServletRequest.getHttpServletMapping()的提示，虽然项目还能够正常运行，但是看着就很不舒服，刚开始看网上说是SpringBoot2.x内置的tomcat9，tomcat9使用的是servletAPI v4，...
Error--启动报错，org.apache.tomcat.util.modeler.Registry.disableRegistry()V
JemeryShen的专栏
08-16 1063
搜“An attempt was made to call a method that does not exist. The attempt was made from the following location:”前面两篇篇文章说是添加了两个一样的包，删除其中一个，后面两篇文章说exclesion去除其中包喊得一个包，诶看到这句慢慢的从后面看到这两篇文章想到前几天的有一个错误是用。解决的，抱着试一试看，还果真解决了。........................
微服务架构中的链路超时分析
Java技术攻略的博客
03-30 998
1.1 现象（问题）​ 微服务架构项目落地过程中，开发人员一般都遇到过调用超时问题，大部分时候会出现在feign接口调用上，这是微服务与单体服务最大的区别，单体从来不用考虑服务之间调用因为网络、序列化等因素导致的额外时间损耗问题。
SpringBoot----嵌入式Servelt容器
m0_53157173的博客
08-03 561
嵌入式Servelt容器SpringBoot默认使用tomcat作为嵌入式的Servlet容器定制和修改Servelt容器的相关配置1.修改和Server有关的配置，去找对应绑定的类(ServerProperties)通用的Servlet设置和tomcat相关设置编写一个嵌入式的容器定制器（EmbeddedServletContainerCustomizer），来修改Servlet容器的相关配置EmbeddedServletContainerCustomizer不存在,SpringBoot2.0 以上，使用
SpringBoot嵌入式容器
qq_45429856的博客
10-23 423
Servlet web容器对比 jetty的优势： 主要看中其大小和灵活性，如果每一服务器能省1Mb,那么10s内就会省下GB量级的内存；jatty还具有可插拔和可扩的特性，可以最大限度的进行定制 undertow, 使红帽公司开发的一款基于INO的高性能web嵌入式服务器，兼容servlet3.1+规范，最大的特点是“轻量”，加载应用可<10M内存 Tomcat和jetty的比较 架构比较 Jetty的架构比Tomcat的更为简单 Jetty的架构是基于Handler来实现的，主要的扩展功能都可以
20年架构师用一文带你彻底搞懂SpringBoot嵌入式Web容器原理
m0_63213253的博客
10-24 174
Spring Boot嵌入式Web容器原理 Spring Boot的目标是构建“非常容易创建、独立、产品级别的基于Spring的应用”。这些应用是“立即可运行的”。在这个过程中，完全没有代码生成，不需要配置任何特殊的XML配置，为了这个目标，Spring Boot在Spring 4.0框架之上提供了很多特性，帮助应用以“约定优于配置”“开箱即用”的方式来启动应用并运行上下文。 Spring Boot同样改变了一个传统的Web应用服务的启动流程和部署方式。通过自动配置机制，Spring Boot提供了一个
SpringBoot配置嵌入式容器及三大组件
wf_feng的博客
09-11 3223
首先明白的一点的是：SpringBoot是默认采用ssm架构，里面的日志采用的是logback ，嵌入式的tomcat容器。 配置端口号，项目名等我们除了可以通过application.properties配置文件配置外，我们可以用代码自定义配置tomcat的相关设置。 server的基本配置 通过配置文件配置端口号 server.port= 9999 spring.thym...
SpringBoot - 嵌入式容器配置与修改
小小默：进无止境
06-21 1916
【1】嵌入式容器 SpringBoot默认使用Tomcat作为嵌入式的Servlet容器。 查看pom文件依赖图如下： 【2】配置嵌入式Tomcat容器 ① 配置文件中进行配置 查看Server配置类ServerProperties，其属性和内部类如下： 即，与Server有关的配置与该类对应，该类中除了Tomcat还有jetty、undertow等容器可以进行...
Spring实现原理分析(二十六).Spring Boot关于嵌入式servlet容器
roberts939299的专栏
12-04 1532
       大家好！用过spring boot的开发者会有种很直观的感受，就是发现servlet容器“消失了”，从而来带一丝丝的空虚感。之前开发web项目，都是把程序写完后部署到servlet容器(比如Tomcat)，但是使用spring boot开发项目，写完程序后直接就能运行了，好神奇！      其实呢，这是因为spring boot使用了嵌入式servlet容器的关系，话说Jetty好多...
SpringBoot嵌入式Servlet容器定制与配置详解
本文档主要探讨SpringBoot中嵌入式Servlet容器的配置与管理，特别是如何利用SpringBoot的自动配置和定制功能来定制化Tomcat等常用容器的行为。首先，SpringBoot默认选择Tomcat作为嵌入式Servlet容器，但用户可以根据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值