SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

配置嵌入式Servlet容器

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

问题?

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

1、修改和server有关的配置(ServerProperties【也是EmbeddedServletContainerCustomizer】);

server.port=8081
server.context-path=/crud

server.tomcat.uri-encoding=UTF-8

//通用的Servlet容器设置
server.xxx
//Tomcat的设置
server.tomcat.xxx

2、编写一个EmbeddedServletContainerCustomizer:嵌入式的Servlet容器的定制器;来修改Servlet容器的配置(1.x)

在Spring Boot2.0以上配置嵌入式Servlet容器时EmbeddedServletContainerCustomizer类不存在,被WebServerFactoryCustomizer替代。

1.x

@Bean //一定要将这个定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
 return new WebServerFactoryCustomizer<ConfigurableWebServerFactory> {

 //定制嵌入式的Servlet容器相关的规则
 @Override
 public void customize(ConfigurableWebServerFactory factory) {
  container.setPort(8083);
 }
 };
}

2.x

@Bean //一定要将这个定制器加入到容器中
public EmbeddedServletContainerCustomizer embeddedServletContainerCustomizer(){
 return new EmbeddedServletContainerCustomizer() {

 //定制嵌入式的Servlet容器相关的规则
 @Override
 public void customize(ConfigurableEmbeddedServletContainer container) {
  container.setPort(8083);
 }
 };
}

2)、注册Servlet三大组件【Servlet、Filter、Listener】

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

注册三大组件用以下方式

ServletRegistrationBean

//注册三大组件
@Bean
public ServletRegistrationBean myServlet(){
 ServletRegistrationBean registrationBean = new ServletRegistrationBean(new MyServlet(),"/myServlet");
 return registrationBean;
}

FilterRegistrationBean

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

ServletListenerRegistrationBean

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

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

DispatcherServletAutoConfiguration中:

@Bean(name = DEFAULT_DISPATCHER_SERVLET_REGISTRATION_BEAN_NAME)
@ConditionalOnBean(value = DispatcherServlet.class, name = DEFAULT_DISPATCHER_SERVLET_BEAN_NAME)
public ServletRegistrationBean dispatcherServletRegistration(
 DispatcherServlet dispatcherServlet) {
 ServletRegistrationBean registration = new ServletRegistrationBean(
  dispatcherServlet, this.serverProperties.getServletMapping());
 //默认拦截: / 所有请求;包静态资源,但是不拦截jsp请求; /*会拦截jsp
 //可以通过server.servletPath来修改SpringMVC前端控制器默认拦截的请求路径

 registration.setName(DEFAULT_DISPATCHER_SERVLET_BEAN_NAME);
 registration.setLoadOnStartup(
  this.webMvcProperties.getServlet().getLoadOnStartup());
 if (this.multipartConfig != null) {
 registration.setMultipartConfig(this.multipartConfig);
 }
 return registration;
}

2)、SpringBoot能不能支持其他的Servlet容器;

3)、替换为其他嵌入式Servlet容器

默认支持:

Tomcat(默认使用)

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

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>

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

Undertow

<!-- 引入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>

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

4)、嵌入式Servlet容器自动配置原理;

SpringBoot2.X原理略有不同

由EmbeddedWebServerFactoryCustomizerAutoConfiguration(嵌入式web服务工厂定制器自动配置类)而不是EmbeddedServletContainerAutoConfiguration(嵌入式的Servlet容器自动配置),根据导入的依赖信息,该配置类会自动创建相应类型的容器工厂定制器(目前Spring Boot 2.x 版本支持tomcat、jetty、undertow、netty),以tomcat为例,这里会创建TomcatWebServerFactoryCustomizer组件:

@Configuration(proxyBeanMethods = false)
@ConditionalOnWebApplication
//指定类ServerProperties(Servlet容器相关的配置类)中的ConfigurationProperties功能,将配置文件中对应的属性值与配置类中的属性值进行映射,并将该配置类添加到IOC容器中
@EnableConfigurationProperties(ServerProperties.class)
public class EmbeddedWebServerFactoryCustomizerAutoConfiguration {

	/**
	 * Nested configuration if Tomcat is being used.
	 */
 @Configuration(proxyBeanMethods = false)
 //导入的Servlet依赖为Tomcat,则创建Tomcat web服务工厂定制器
 @ConditionalOnClass({ Tomcat.class, UpgradeProtocol.class })
 public static class TomcatWebServerFactoryCustomizerConfiguration {

 @Bean
 public TomcatWebServerFactoryCustomizer tomcatWebServerFactoryCustomizer(Environment 				environment,ServerProperties serverProperties) {
  return new TomcatWebServerFactoryCustomizer(environment, serverProperties);
 }
 }
 ...
}

1.X中通过EmbeddedServletContainerAutoConfiguration:嵌入式的Servlet容器自动配置类创建组件

@AutoConfigureOrder(Ordered.HIGHEST_PRECEDENCE)
@Configuration
@ConditionalOnWebApplication
@Import(BeanPostProcessorsRegistrar.class)
//导入BeanPostProcessorsRegistrar:Spring注解版;给容器中导入一些组件
//导入了EmbeddedServletContainerCustomizerBeanPostProcessor:
//后置处理器:bean初始化前后(创建完对象,还没赋值赋值)执行初始化工作
public class EmbeddedServletContainerAutoConfiguration {

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

		@Bean
		public TomcatEmbeddedServletContainerFactory tomcatEmbeddedServletContainerFactory() {
			return new TomcatEmbeddedServletContainerFactory();
		}

	}

 /**
	 * Nested configuration if Jetty is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Server.class, Loader.class,
			WebAppContext.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedJetty {

		@Bean
		public JettyEmbeddedServletContainerFactory jettyEmbeddedServletContainerFactory() {
			return new JettyEmbeddedServletContainerFactory();
		}

	}

	/**
	 * Nested configuration if Undertow is being used.
	 */
	@Configuration
	@ConditionalOnClass({ Servlet.class, Undertow.class, SslClientAuthMode.class })
	@ConditionalOnMissingBean(value = EmbeddedServletContainerFactory.class, search = SearchStrategy.CURRENT)
	public static class EmbeddedUndertow {

		@Bean
		public UndertowEmbeddedServletContainerFactory undertowEmbeddedServletContainerFactory() {
			return new UndertowEmbeddedServletContainerFactory();
		}
	}

1)、EmbeddedServletContainerFactory(嵌入式Servlet容器工厂)

public interface EmbeddedServletContainerFactory {

 //获取嵌入式的Servlet容器
 EmbeddedServletContainer getEmbeddedServletContainer(
  ServletContextInitializer... initializers);

}

2)、EmbeddedServletContainer:(嵌入式的Servlet容器)

3)、以TomcatEmbeddedServletContainerFactory为例

@Override
public EmbeddedServletContainer getEmbeddedServletContainer(
 ServletContextInitializer... initializers) {
 //创建一个Tomcat
 Tomcat tomcat = new Tomcat();

 //配置Tomcat的基本环节
 File baseDir = (this.baseDirectory != null ? this.baseDirectory
  : createTempDir("tomcat"));
 tomcat.setBaseDir(baseDir.getAbsolutePath());
 Connector connector = new Connector(this.protocol);
 tomcat.getService().addConnector(connector);
 customizeConnector(connector);
 tomcat.setConnector(connector);
 tomcat.getHost().setAutoDeploy(false);
 configureEngine(tomcat.getEngine());
 for (Connector additionalConnector : this.additionalTomcatConnectors) {
 tomcat.getService().addConnector(additionalConnector);
 }
 prepareContext(tomcat.getHost(), initializers);

 //将配置好的Tomcat传入进去,返回一个EmbeddedServletContainer;并且启动Tomcat服务器
 return getTomcatEmbeddedServletContainer(tomcat);
}

4)、我们对嵌入式容器的配置修改是怎么生效?

ServerProperties、EmbeddedServletContainerCustomizer

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

怎么修改的原理?

5)、容器中导入了EmbeddedServletContainerCustomizerBeanPostProcessor

//初始化之前
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName)
 throws BeansException {
 //如果当前初始化的是一个ConfigurableEmbeddedServletContainer类型的组件
 if (bean instanceof ConfigurableEmbeddedServletContainer) {
 //
 postProcessBeforeInitialization((ConfigurableEmbeddedServletContainer) bean);
 }
 return bean;
}

private void postProcessBeforeInitialization(
			ConfigurableEmbeddedServletContainer bean) {
 //获取所有的定制器,调用每一个定制器的customize方法来给Servlet容器进行属性赋值;
 for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
 customizer.customize(bean);
 }
}

private Collection<EmbeddedServletContainerCustomizer> getCustomizers() {
 if (this.customizers == null) {
 // Look up does not include the parent context
 this.customizers = new ArrayList<EmbeddedServletContainerCustomizer>(
  this.beanFactory
  //从容器中获取所有这葛类型的组件:EmbeddedServletContainerCustomizer
  //定制Servlet容器,给容器中可以添加一个EmbeddedServletContainerCustomizer类型的组件
  .getBeansOfType(EmbeddedServletContainerCustomizer.class,
    false, false)
  .values());
 Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
 this.customizers = Collections.unmodifiableList(this.customizers);
 }
 return this.customizers;
}

ServerProperties也是定制器

步骤:

1)、SpringBoot根据导入的依赖情况,给容器中添加相应的EmbeddedServletContainerFactory【TomcatEmbeddedServletContainerFactory】

2)、容器中某个组件要创建对象就会惊动后置处理器;EmbeddedServletContainerCustomizerBeanPostProcessor;

只要是嵌入式的Servlet容器工厂,后置处理器就工作;

3)、后置处理器,从容器中获取所有的EmbeddedServletContainerCustomizer,调用定制器的定制方法

5)、嵌入式Servlet容器启动原理;

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

获取嵌入式的Servlet容器工厂:

1)、SpringBoot应用启动运行run方法

2)、refreshContext(context);SpringBoot刷新IOC容器【创建IOC容器对象,并初始化容器,创建容器中的每一个组件】;如果是web应用创建AnnotationConfigEmbeddedWebApplicationContext,否则:AnnotationConfigApplicationContext

3)、refresh(context);刷新刚才创建好的ioc容器;

public void refresh() throws BeansException, IllegalStateException {
 synchronized (this.startupShutdownMonitor) {
 // Prepare this context for refreshing.
 prepareRefresh();

 // Tell the subclass to refresh the internal bean factory.
 ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

 // Prepare the bean factory for use in this context.
 prepareBeanFactory(beanFactory);

 try {
  // Allows post-processing of the bean factory in context subclasses.
  postProcessBeanFactory(beanFactory);

  // Invoke factory processors registered as beans in the context.
  invokeBeanFactoryPostProcessors(beanFactory);

  // Register bean processors that intercept bean creation.
  registerBeanPostProcessors(beanFactory);

  // Initialize message source for this context.
  initMessageSource();

  // Initialize event multicaster for this context.
  initApplicationEventMulticaster();

  // Initialize other special beans in specific context subclasses.
  onRefresh();

  // Check for listener beans and register them.
  registerListeners();

  // Instantiate all remaining (non-lazy-init) singletons.
  finishBeanFactoryInitialization(beanFactory);

  // Last step: publish corresponding event.
  finishRefresh();
 }

 catch (BeansException ex) {
  if (logger.isWarnEnabled()) {
  logger.warn("Exception encountered during context initialization - " +
   "cancelling refresh attempt: " + ex);
  }

  // Destroy already created singletons to avoid dangling resources.
  destroyBeans();

  // Reset 'active' flag.
  cancelRefresh(ex);

  // Propagate exception to caller.
  throw ex;
 }

 finally {
  // Reset common introspection caches in Spring's core, since we
  // might not ever need metadata for singleton beans anymore...
  resetCommonCaches();
 }
 }
}

4)、 onRefresh(); web的ioc容器重写了onRefresh方法

5)、webioc容器会创建嵌入式的Servlet容器;createEmbeddedServletContainer();

6)、获取嵌入式的Servlet容器工厂:

EmbeddedServletContainerFactory containerFactory = getEmbeddedServletContainerFactory();

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

7)、使用容器工厂获取嵌入式的Servlet容器:this.embeddedServletContainer = containerFactory .getEmbeddedServletContainer(getSelfInitializer());

8)、嵌入式的Servlet容器创建对象并启动Servlet容器;

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

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

使用外置的Servlet容器

嵌入式Servlet容器:应用打成可执行的jar

​优点:简单、便携;

​缺点:默认不支持JSP、优化定制比较复杂(使用定制器【ServerProperties、自定义EmbeddedServletContainerCustomizer】,自己编写嵌入式Servlet容器的创建工厂【EmbeddedServletContainerFactory】);

外置的Servlet容器:外面安装Tomcat---应用war包的方式打包;

步骤

1)、必须创建一个war项目;(利用idea创建好目录结构)

2)、将嵌入式的Tomcat指定为provided;

<dependency>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-tomcat</artifactId>
 <scope>provided</scope>
</dependency>

3)、必须编写一个SpringBootServletInitializer的子类,并调用configure方法

public class ServletInitializer extends SpringBootServletInitializer {

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

}

4)、启动服务器就可以使用;

原理

jar包:执行SpringBoot主类的main方法,启动ioc容器,创建嵌入式的Servlet容器;

war包:启动服务器,服务器启动SpringBoot应用【SpringBootServletInitializer】,启动ioc容器;

servlet3.0(Spring注解版):

8.2.4 Shared libraries / runtimes pluggability:

规则:

​1)、服务器启动(web应用启动)会创建当前web应用里面每一个jar包里面ServletContainerInitializer实例:

​2)、ServletContainerInitializer的实现放在jar包的META-INF/services文件夹下,有一个名为javax.servlet.ServletContainerInitializer的文件,内容就是ServletContainerInitializer的实现类的全类名

​3)、还可以使用@HandlesTypes,在应用启动的时候加载我们感兴趣的类;

流程:

1)、启动Tomcat

2)、org\springframework\spring-web\4.3.14.RELEASE\spring-web-4.3.14.RELEASE.jar!\META-INF\services\javax.servlet.ServletContainerInitializer:

Spring的web模块里面有这个文件:org.springframework.web.SpringServletContainerInitializer

3)、SpringServletContainerInitializer将@HandlesTypes(WebApplicationInitializer.class)标注的所有这个类型的类都传入到onStartup方法的Set<Class<?>>;为这些WebApplicationInitializer类型的类创建实例;

4)、每一个WebApplicationInitializer都调用自己的onStartup;

5)、相当于我们的SpringBootServletInitializer的类会被创建对象,并执行onStartup方法

6)、SpringBootServletInitializer实例执行onStartup的时候会createRootApplicationContext;创建容器

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

 //调用configure方法,子类重写了这个方法,将SpringBoot的主程序类传入了进来
 builder = configure(builder);

 //使用builder创建一个Spring应用
 SpringApplication application = builder.build();
 if (application.getSources().isEmpty() && AnnotationUtils
  .findAnnotation(getClass(), Configuration.class) != null) {
 application.getSources().add(getClass());
 }
 Assert.state(!application.getSources().isEmpty(),
  "No SpringApplication sources have been defined. Either override the "
  + "configure method or add an @Configuration annotation");
 // Ensure error pages are registered
 if (this.registerErrorPageFilter) {
 application.getSources().add(ErrorPageFilterConfiguration.class);
 }
 //启动Spring应用
 return run(application);
}

7)、Spring的应用就启动并且创建IOC容器

public ConfigurableApplicationContext run(String... args) {
 StopWatch stopWatch = new StopWatch();
 stopWatch.start();
 ConfigurableApplicationContext context = null;
 FailureAnalyzers analyzers = null;
 configureHeadlessProperty();
 SpringApplicationRunListeners listeners = getRunListeners(args);
 listeners.starting();
 try {
 ApplicationArguments applicationArguments = new DefaultApplicationArguments(
  args);
 ConfigurableEnvironment environment = prepareEnvironment(listeners,
  applicationArguments);
 Banner printedBanner = printBanner(environment);
 context = createApplicationContext();
 analyzers = new FailureAnalyzers(context);
 prepareContext(context, environment, listeners, applicationArguments,
  printedBanner);

 //刷新IOC容器
 refreshContext(context);
 afterRefresh(context, applicationArguments);
 listeners.finished(context, null);
 stopWatch.stop();
 if (this.logStartupInfo) {
  new StartupInfoLogger(this.mainApplicationClass)
  .logStarted(getApplicationLog(), stopWatch);
 }
 return context;
 }
 catch (Throwable ex) {
 handleRunFailure(context, listeners, analyzers, ex);
 throw new IllegalStateException(ex);
 }
}

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

到此这篇关于SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的文章就介绍到这了,更多相关SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

(0)

相关推荐

  • springboot注入servlet的方法

    问:有了springMVC,为什么还要用servlet?有了servlet3的注解,为什么还要使用ServletRegistrationBean注入的方式? 使用场景:在有些场景下,比如我们要使用hystrix-dashboard,这时候就需要注入HystrixMetricsStreamServlet(第三方的servlet),该servlet是hystrix的组件. 一.代码 1.TestServlet(第一个servlet) package com.xxx.secondboot.servle

  • 关于SpringBoot获取IOC容器中注入的Bean(推荐)

    一: 注入一个TestUtils类 package com.shop.sell.Utils; import com.shop.sell.dto.CartDTO; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class TestUtils { @Bean(name="test

  • SpringBoot 项目如何在tomcat容器中运行的实现方法

    一. SpringBoot内嵌容器的部署方式 SpringBoot内部默认提供内嵌的tomcat容器,所以可以直接打成jar包,丢到服务器上的任何一个目录,然后在当前目录下执行java -jar demo.jar即可运行,但是这种方式的运行退出进程就结束了.如果想在后台可以运行,则需要执行 java -jar demo.jar > log_demo.file 2>&1 & 即可在后台运行该服务了,log_demo.file是日志文件.如需停止该进程 执行ps -ef|grep

  • springboot2.3.1替换为其他的嵌入式servlet容器的详细方法

    现阶段,springboot内嵌了Tomcat服务器,如果你不想使用Tomcat,springboot也是支持其他的服务器切换的. 如果你想了解底层springboot所支持的服务器你可以使用idea的快捷键快速按两次shift查询一个ServerProperties 的类,通过这个类你可以知道你想要了解的情况: springboot里面支持的服务器有Jetty.Netty-等等,大家有兴趣的话可以百度一下. 接着通过在pom文件的视图依赖分析可以得知: springboot里面的Tomcat是

  • SpringBoot初始教程之Servlet、Filter、Listener配置详解

    1.介绍 通过之前的文章来看,SpringBoot涵盖了很多配置,但是往往一些配置是采用原生的Servlet进行的,但是在SpringBoot中不需要配置web.xml的 因为有可能打包之后是一个jar包的形式,这种情况下如何解决?SpringBoot 提供了两种方案进行解决 2.快速开始 2.1 方案一 方案一采用原生Servlet3.0的注解进行配置.@WebServlet .@WebListener.@WebFilter是Servlet3.0 api中提供的注解 通过注解可以完全代替web

  • SpringBoot配置嵌入式Servlet容器和使用外置Servlet容器的教程图解

    配置嵌入式Servlet容器 SpringBoot默认使用Tomcat作为嵌入式的Servlet容器: 问题? 1).如何定制和修改Servlet容器的相关配置: 1.修改和server有关的配置(ServerProperties[也是EmbeddedServletContainerCustomizer]): server.port=8081 server.context-path=/crud server.tomcat.uri-encoding=UTF-8 //通用的Servlet容器设置 s

  • springboot配置嵌入式servlet容器的方法

    配置嵌入式Servlet容器 springboot默认tomcat为嵌入式servlet容器,所以不用在配置tomcat. 1.如何定制修改servlet容器? 1.在applicatio.properties里修改和server有关的配置(推荐) 如: server.tomcat server.tomcat.connection-timeout= 连接超时时间 server.tomcat.uri-encoding=UTF-8 修改编码 server.servlet.XXX 通用servlet容

  • SpringBoot应用部署于外置Tomcat容器的方法

    0x01. 概述 SpringBoot平时我们用的爽歪歪,爽到它自己连Tomcat都自集成了,我们可以直接编写SBT启动类,然后一键开启内置的Tomcat容器服务,确实是很好上手.但考虑到实际的情形中,我们的Tomcat服务器一般是另外部署好了的,有专门的维护方式.此时我们需要剥离掉SBT应用内置的Tomcat服务器,进而将应用发布并部署到外置的Tomcat容器之中,本文就实践一下这个. 0x02. 修改打包方式 修改项目的pom.xml配置,我们修改其打包方式为war方式,如: <groupI

  • springboot打war包部署到外置tomcat容器的方法

    目录 一.修改打包方式 二. 排除内置tomcat的依赖 三.新增加一个类继承SpringBootServletInitializer实现configure: 四.build要有finalName标签 五.打包与运行 打war包部署到外置tomcat容器 一.修改打包方式 <packaging>war</packaging> 将上面的代码加入到pom.xml文件刚开始的位置,如下: 二. 排除内置tomcat的依赖 我们使用外置的tomcat,自然要将内置的嵌入式tomcat的相关

  • SpringBoot中使用Servlet三大组件的方法(Servlet、Filter、Listener)

    本篇主要讲解SpringBoot当中使用Servlet三大组件,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧! 三大组件作用 1.Servlet Servlet是用来处理客户端请求的动态资源,也就是当我们在浏览器中键入一个地址回车跳转后,请求就会被发送到对应的Servlet上进行处理. Servlet的任务有: 1.接收请求数据:我们都知道客户端请求会被封装成HttpServletRequest对象,里面包含了请求头.参数等各种信息. 2.处理请求:通常我

  • SpringBoot启动嵌入式Tomcat的实现步骤

    目录 Spring Boot中Web容器相关接口 WebServer ServletWebServerFactory WebServerFactoryCustomizerBeanPostProcessor 创建.启动嵌入式Web容器 createWebServer getWebServer 注册Servlet Servlet注解 ServletRegistrationBean 动态注册 定制Web容器 ConfigurableServletWebServerFactory TomcatServl

  • springboot配置内存数据库H2教程详解

    业务背景:因soa系统要供外网访问,处于安全考虑用springboot做了个前置模块,用来转发外网调用的请求和soa返回的应答.其中外网的请求接口地址在DB2数据库中对应专门的一张表来维护,要是springboot直接访问数据库,还要专门申请权限等,比较麻烦,而一张表用内置的H2数据库维护也比较简单,就可以作为替代的办法. 环境:springboot+maven3.3+jdk1.7 1.springboot的Maven工程结构 说明一下,resource下的templates文件夹没啥用.我忘记

  • SpringBoot配置logback的步骤

    配置日志文件 spring boot 默认会加载 classpath:logback-spring.xml 或者 classpath:logback-spring.groovy. 如需要自定义文件名称,在 application.properties 中配置 logging.config 选项即可. 在 src/main/resources 下创建 logback-spring.xml 文件,内容如下: <?xml version="1.0" encoding="UTF

  • SpringBoot配置的加载流程详细分析

    在上一篇Springboot启动流程解析中我们没有张开对配置的解析,因为篇幅过大,需要单独在起一篇文章来讲. 且看一下两行代码: ApplicationArguments applicationArguments = new DefaultApplicationArguments( args); ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments); 第一行代码是对控制台

  • 详解SpringBoot配置连接池

    内置的连接池 目前spring Boot中默认支持的连接池有dbcp,dbcp2, tomcat, hikari三种连接池. 数据库连接可以使用DataSource池进行自动配置. 由于Tomcat数据源连接池的性能和并发,在tomcat可用时,我们总是优先使用它. 如果HikariCP可用,我们将使用它. 如果Commons DBCP可用,我们将使用它,但在生产环境不推荐使用它. 最后,如果Commons DBCP2可用,我们将使用它. 以上的几种连接池,可以通过在配置application文

随机推荐