SpringBoot--------TomCat端口号(三)
转载：https://blog.csdn.net/zknxx/article/details/53433592
转载：https://blog.csdn.net/weixin_33795093/article/details/89941428
一. SpringBoot修改默认端口号
有时候我们可能需要启动不止一个SpringBoot，而SpringBoot默认的端口号是8080，所以这时候我们就需要修改SpringBoot的默认端口了。修改SpringBoot的默认端口有两种方式。下面就分别说一下这两种方式。
修改application.properties
第一种方式我们只需要在application.properties中加这样的一句话就可以了：server.port=8004。为什么这种方式可以实现修改SpringBoot的默认端口呢？因为在SpringBoot中有这样的一个类：ServerProperties。我们可以大致看一下这个类：
@ConfigurationProperties(prefix = "server", ignoreUnknownFields = true)
public class ServerProperties
implements EmbeddedServletContainerCustomizer, EnvironmentAware, Ordered {
/**
* Server HTTP port.
*/
private Integer port;
在这个类里有一个@ConfigurationProperties注解，这个注解会读取SpringBoot的默认配置文件application.properties的值注入到bean里。这里定义了一个server的前缀和一个port字段，所以在SpringBoot启动的时候会从application.properties读取到server.port的值。我们接着往下看一下：
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
if (getPort() != null) {
container.setPort(getPort());
}
这里有一个customize的方法，这个方法里会给SpringBoot设置读取到的端口号。
实现EmbeddedServletContainerCustomizer
我们在上面看到了端口号是在customize这个方法中设置的，而这个方法是在EmbeddedServletContainerCustomizer这个接口中的，所以我们可以实现这个接口，来更改SpringBoot的默认端口号。具体代码如下：
@RestController
@EnableAutoConfiguration
@ComponentScan
public class FirstExample implements EmbeddedServletContainerCustomizer {
@RequestMapping("/first.do")
String home() {
return "Hello World！世界你好！O(∩_∩)O哈哈~！！！我不是太很好!";
}
public static void main(String[] args) {
SpringApplication.run(FirstExample.class, args);
}
@Override
public void customize(ConfigurableEmbeddedServletContainer configurableEmbeddedServletContainer) {
configurableEmbeddedServletContainer.setPort(8003);
}
}
然后你在启动SpringBoot的时候，发现端口号被改成了8003.
使用命令行参数
如果你只是想在启动的时候修改一次端口号的话，可以用命令行参数来修改端口号。配置如下：java -jar 打包之后的SpringBoot.jar --server.port=8000
使用虚拟机参数
你同样也可以把修改端口号的配置放到JVM参数里。配置如下：-Dserver.port=8009。 这样启动的端口号就被修改为8009了。
二. SpringBoot是怎么实现修改TomCat端口号的原理
修改TomCat的端口号大概可以分为这样的两类吧，一种是用配置项的方式，另一种是用程序实现的方式。配置项包含：设置命令行参数、系统参数、虚拟机参数、SpringBoot默认的application.properties(或者是application.yml等类似的方式)。用程序实现的方式，则需要实现EmbeddedServletContainerCustomizer接口，并将此实现类注入为Spring的Bean。我们先说配置项的方式。
通常我们用配置项的方式来修改TomCat端口号的时候，需要进行这样的配置(或类似的方式)：
server.port=8081看到这样的一个配置项再结合我们自己在使用ConfigurationProperties的时候所进行的设置，我们可以推断一下应该会存在一个这样的JavaBean，在这个JavaBean上使用了ConfigurationProperties注解，并且它的prefix的值为server。既然有了一个这样的推想，那么我们就要去证明这个推想。在SpringBoot中也确实存在了我们所推想的这样的一个JavaBean：ServerProperties。ServerProperties这个类的UML如下所示：
ServerProperties实现了EnvironmentAware接口，说明它可以获取Environment中的属性值，它也实现了Ordered接口，这个这里先记着，我们在后面再说，它也实现了EmbeddedServletContainerCustomizer接口，我们在上面说的第二种修改TomCat端口号的方式就是实现EmbeddedServletContainerCustomizer接口，并注入为Spring的Bean，而ServerProperties就实现了这个接口。但是这里还有一个问题，在这个类上没有添加Component注解(或者是相同作用的注解)。但是我们在SpringBoot中还发现了这样的一个类：ServerPropertiesAutoConfiguration。从名字我们可以猜出这个类应该是为ServerProperties提供自动配置的一个类，这个类也确实是这样的一个作用，关于SpringBoot的自动配置功能比较复杂，我们这里先不展开，有这方面疑问的童鞋可以在下面留言。我们去ServerPropertiesAutoConfiguration这个类中看一下这个类的代码：
//Configuration相当于标签
//EnableConfigurationProperties使ConfigurationProperties注解生效，并将EnableConfigurationProperties这个注解中执行的类注入为Spring的Bean
//ConditionalOnWebApplication 必须是在web开发环境中
@Configuration
@EnableConfigurationProperties
@ConditionalOnWebApplication
public class ServerPropertiesAutoConfiguration {
//如果在当前容器中 不存在ServerProperties类型的Bean，则创建ServerProperties Bean
@Bean
@ConditionalOnMissingBean(search = SearchStrategy.CURRENT)
public ServerProperties serverProperties() {
return new ServerProperties();
}
//这个Bean也实现了 EmbeddedServletContainerCustomizer 接口，它同时还实现了ApplicationContextAware 接口，说明在这个类中可以获取到Spring容器的应用上下文 这个类的作用是检测在Spring 容器中是否有多于一个ServerProperties类型的Bean存在 如果是则抛出异常
@Bean
public DuplicateServerPropertiesDetector duplicateServerPropertiesDetector() {
return new DuplicateServerPropertiesDetector();
}
private static class DuplicateServerPropertiesDetector implements
EmbeddedServletContainerCustomizer, Ordered, ApplicationContextAware {
private ApplicationContext applicationContext;
@Override
public int getOrder() {
return 0;
}
@Override
public void setApplicationContext(ApplicationContext applicationContext)
throws BeansException {
this.applicationContext = applicationContext;
}
@Override
public void customize(ConfigurableEmbeddedServletContainer container) {
// ServerProperties handles customization, this just checks we only have
// a single bean 主要作用就是检测当前容器中是否存在多于一个ServerProperties类型的Bean存在
String[] serverPropertiesBeans = this.applicationContext
.getBeanNamesForType(ServerProperties.class);
Assert.state(serverPropertiesBeans.length == 1,
"Multiple ServerProperties beans registered " + StringUtils
.arrayToCommaDelimitedString(serverPropertiesBeans));
}
}
} 通过上面的分析，我们看到了在哪里将ServerProperties包装为Spring容器的Bean的。下面我们来简单的说一下ServerProperties这个类中都为我们提供了什么东西：
/**
* 启动端口号
* Server HTTP port.
*/
private Integer port;
/**
* ServletConetxt上下文路径
* Context path of the application.
*/
private String contextPath;
/**
* DispatcherServlet 主要的 servlet Mapping
* Path of the main dispatcher servlet.
*/
private String servletPath = "/";
/**
* ServletContext参数
* ServletContext parameters.
*/
private final Map contextParameters = new HashMap(); 以及它的内部类，分别用来做和TomCat设置相关的内容、Jetty设置相关的内容、Undertow设置相关的内容以及Session设置相关的内容。关于ServerProperties中的属性值的设置请参考之前的文章，这里就不再多说了。
在ServerProperties中最重要的一个方法是customize方法，这个方法是用来设置容器相关的内容的。
//这里的ConfigurableEmbeddedServletContainer 请看这个类中的内容EmbeddedServletContainerAutoConfiguration，看完你应该就会明白它是什么了
public void customize(ConfigurableEmbeddedServletContainer container) {
//端口号
if (getPort() != null) {
container.setPort(getPort());
}
//IP地址
if (getAddress() != null) {
container.setAddress(getAddress());
}
//ContextPath
if (getContextPath() != null) {
container.setContextPath(getContextPath());
}
if (getDisplayName() != null) {
container.setDisplayName(getDisplayName());
}
//Session超时时间
if (getSession().getTimeout() != null) {
container.setSessionTimeout(getSession().getTimeout());
}
container.setPersistSession(getSession().isPersistent());
container.setSessionStoreDir(getSession().getStoreDir());
//SSL
if (getSsl() != null) {
container.setSsl(getSsl());
}
//JspServlet
if (getJspServlet() != null) {
container.setJspServlet(getJspServlet());
}
if (getCompression() != null) {
container.setCompression(getCompression());
}
container.setServerHeader(getServerHeader());
//如果是TomCat服务器
if (container instanceof TomcatEmbeddedServletContainerFactory) {
getTomcat().customizeTomcat(this,
(TomcatEmbeddedServletContainerFactory) container);
}
//如果是Jetty服务器
if (container instanceof JettyEmbeddedServletContainerFactory) {
getJetty().customizeJetty(this,
(JettyEmbeddedServletContainerFactory) container);
}
//如果是Undertow服务器
if (container instanceof UndertowEmbeddedServletContainerFactory) {
getUndertow().customizeUndertow(this,
(UndertowEmbeddedServletContainerFactory) container);
}
container.addInitializers(new SessionConfiguringInitializer(this.session));
//ServletContext 参数
container.addInitializers(new InitParameterConfiguringServletContextInitializer(
getContextParameters()));
}现在的关键问题是customize这个方法是在什么时候被调用的呢？通过翻开它的调用链，我们在SpringBoot中发现了这样的一个类：EmbeddedServletContainerCustomizerBeanPostProcessor在这个类中有这样的一个方法，
//这个方法 如果你对Spring中的生命周期熟悉的话，那么你看到这个方法的时候一定不会陌生，同时这个类应该是实现了BeanPostProcessor 那么现在还存在的一个问题是，只有这个类是一个Spring中的Bean的时候，它才会被调用到，那么这个类是什么时候被注入到Spring的容器中的呢
@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) {
//getCustomizers()获取容器中的EmbeddedServletContainerCustomizer的实现类，ServerProperties当然算是一个，我们上面提到的DuplicateServerPropertiesDetector 也是一个
for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
//调用EmbeddedServletContainerCustomizer的实现类中的customize方法
customizer.customize(bean);
}
}如果你对Spring中的生命周期熟悉的话，那么你看到postProcessBeforeInitialization这个方法的时候一定不会陌生，首先应该想到它应该是实现了BeanPostProcessor这个接口。那么现在还存在的一个问题是，只有这个类是一个Spring中的Bean的时候，它才会被调用到，那么这个类是什么时候被注入到Spring的容器中的呢 ？答案就在EmbeddedServletContainerAutoConfiguration这个类中。这个类的作用是自动配置嵌入式的Servlet容器。在这个类上用了这样的一个注解：
@Import(BeanPostProcessorsRegistrar.class)
Import这个注解在实现SpringBoot的自动配置功能的时候起到了非常重要的作用！Import这个注解中的value所指定的Class可以分为这样的三类：一类是实现了ImportSelector接口，一类是实现了ImportBeanDefinitionRegistrar接口，不属于前面说的这两种的就是第三种，具体的可以看一下这个方法org.springframework.context.annotation.ConfigurationClassParser#processImports。而上面所提到的BeanPostProcessorsRegistrar这个类就是实现了ImportBeanDefinitionRegistrar这个接口的。我们看一下这个类中的内容（EmbeddedServletContainerAutoConfiguration的内部类）：
//这个类实现了ImportBeanDefinitionRegistrar接口，同时也实现了BeanFactoryAware 接口
public static class BeanPostProcessorsRegistrar
implements ImportBeanDefinitionRegistrar, BeanFactoryAware {
private ConfigurableListableBeanFactory beanFactory;
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
if (beanFactory instanceof ConfigurableListableBeanFactory) {
this.beanFactory = (ConfigurableListableBeanFactory) beanFactory;
}
}
//注入Bean定义 注意这里的Bean 都是用注解的方法注入的bean 如标注Component注解的Bean
//这个方法的调用链先不介绍的
@Override
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata,
BeanDefinitionRegistry registry) {
if (this.beanFactory == null) {
return;
}
//注入EmbeddedServletContainerCustomizerBeanPostProcessor
registerSyntheticBeanIfMissing(registry,
"embeddedServletContainerCustomizerBeanPostProcessor",
EmbeddedServletContainerCustomizerBeanPostProcessor.class);
//注入ErrorPageRegistrarBeanPostProcessor
registerSyntheticBeanIfMissing(registry,
"errorPageRegistrarBeanPostProcessor",
ErrorPageRegistrarBeanPostProcessor.class);
}
private void registerSyntheticBeanIfMissing(BeanDefinitionRegistry registry,
String name, Class beanClass) {
//如果容器中不存在指定类型的Bean定义
if (ObjectUtils.isEmpty(
this.beanFactory.getBeanNamesForType(beanClass, true, false))) {
//创一个RootBean定义
RootBeanDefinition beanDefinition = new RootBeanDefinition(beanClass);
//合成的Bean 不是应用自己创建的基础建设角色的Bean
beanDefinition.setSynthetic(true);
//注入Spring容器中
registry.registerBeanDefinition(name, beanDefinition);
}
}
}到现在为止，关于SpringBoot设置TomCat启动端口号的简单分析就算是结束了。但是这里还有一个问题，如果我们既用配置项的形式设置了TomCat的端口号，同时又自定义了一个实现了EmbeddedServletContainerCustomizer接口的Bean，并且没有Order相关的设置，那么最终生效的会是哪个配置呢？答案是实现了EmbeddedServletContainerCustomizer接口的Spring Bean。在org.springframework.boot.context.embedded.EmbeddedServletContainerCustomizerBeanPostProcessor#postProcessBeforeInitialization(org.springframework.boot.context.embedded.ConfigurableEmbeddedServletContainer)中的方法的内容如下：
private void postProcessBeforeInitialization(
ConfigurableEmbeddedServletContainer bean) {
//getCustomizers() 从当前的Spirng容器中获取所有EmbeddedServletContainerCustomizer 类型的Bean
//getCustomizers() 中的Bean是进行过排序之后的 所以这里Order值大的会覆盖Order值小的设置
for (EmbeddedServletContainerCustomizer customizer : getCustomizers()) {
customizer.customize(bean);
}
}
private Collection getCustomizers() {
if (this.customizers == null) {
// Look up does not include the parent context
//从当前的Spring容器中获取EmbeddedServletContainerCustomizer 类型的Bean
this.customizers = new ArrayList(
this.beanFactory
.getBeansOfType(EmbeddedServletContainerCustomizer.class,
false, false)
.values());
//将获取到的Bean进行排序 排序是根据Order的值进行排序的 如果你的Bean没有进行过任何关于Order值的设置的话，那么你的Bean将位于最后的位置了
Collections.sort(this.customizers, AnnotationAwareOrderComparator.INSTANCE);
this.customizers = Collections.unmodifiableList(this.customizers);
}
return this.customizers;
} ------------------------------------------------ 我是低调的分隔线 ----------------------------------------------------
面向对象，面向卿；不负代码，不负心... ... 