Spring Boot 中的 Tomcat 是如何启动的?

【JAVA面试】SpringBoot如何启动的Tomcat Spring Boot通过引入Spring Boot Starter Web依赖和创建Spring Boot应用类,在应用启动过程中加载Tomcat并初始化Servlet容器,以提供对HTTP请求的处理能力。这种方式使得开发者可以方便地在Spring Boot应用程序中嵌入和配置Tomcat服务器,从而简化了Web应用程序的开发和部署过程。 阅读详情

我们知道 Spring Boot 给我们带来了一个全新的开发体验,让我们可以直接把 Web 程序打包成 jar 包直接启动,这得益于 Spring Boot 内置了容器,可以直接启动。

本文将以 Tomcat 为例,来看看 Spring Boot 是如何启动 Tomcat 的,同时也将展开学习下 Tomcat 的源码,了解 Tomcat 的设计。

从 Main 方法说起

用过 Spring Boot 的人都知道,首先要写一个 main 方法来启动:

@SpringBootApplication
public class TomcatdebugApplication {
 public static void main(String[] args) {
 SpringApplication.run(TomcatdebugApplication.class, args);
 }
}

我们直接点击run方法的源码,跟踪下来,发现最终的run方法是调用


ConfigurableApplicationContext方法,源码如下:

Spring Boot 中的 Tomcat 是如何启动的?

其实这个方法我们可以简单的总结下步骤为 > 1. 配置属性 > 2. 获取监听器,发布应用开始启动事件 > 3. 初始化输入参数 > 4. 配置环境,输出 banner > 5. 创建上下文 > 6. 预处理上下文 > 7. 刷新上下文 > 8. 再刷新上下文 > 9. 发布应用已经启动事件 > 10. 发布应用启动完成事件

其实上面这段代码,如果只要分析 Tomcat 内容的话,只需要关注两个内容即可,上下文是如何创建的,上下文是如何刷新的,分别对应的方法就是createApplicationContext() 和refreshContext(context),接下来我们来看看这两个方法做了什么。

protected ConfigurableApplicationContext createApplicationContext() {
		Class<!--?--> contextClass = this.applicationContextClass;
if (contextClass == null) {
try {
switch (this.webApplicationType) {
case SERVLET:
					contextClass = Class.forName(DEFAULT_SERVLET_WEB_CONTEXT_CLASS);
break;
case REACTIVE:
					contextClass = Class.forName(DEFAULT_REACTIVE_WEB_CONTEXT_CLASS);
break;
default:
					contextClass = Class.forName(DEFAULT_CONTEXT_CLASS);
				}
			}
catch (ClassNotFoundException ex) {
throw new IllegalStateException(
"Unable create a default ApplicationContext, " + "please specify an ApplicationContextClass",
						ex);
			}
		}
return (ConfigurableApplicationContext) BeanUtils.instantiateClass(contextClass);
	}

这里就是根据我们的webApplicationType来判断创建哪种类型的 Servlet,代码中分别对应着 Web 类型(SERVLET),响应式 Web 类型(REACTIVE),非 Web 类型(default),我们建立的是Web类型,所以肯定实例化
DEFAULT_SERVLET_WEB_CONTEXT_CLASS

指定的类,也就是


AnnotationConfigServletWebServerApplicationContext类,我们来用图来说明下这个类的关系。

Spring Boot 中的 Tomcat 是如何启动的?

通过这个类图我们可以知道,这个类继承的是
ServletWebServerApplicationContext,这就是我们真正的主角,而这个类最终是继承了AbstractApplicationContext,了解完创建上下文的情况后,我们再来看看刷新上下文,相关代码如下:

Spring Boot 中的 Tomcat 是如何启动的?

这里还是直接传递调用本类的refresh(context)方法,最后是强转成父类
AbstractApplicationContext调用其refresh()方法,该代码如下:

// 类:AbstractApplicationContext	
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()
				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();
			}
		}
	}

这里我们看到onRefresh()方法是调用其子类的实现,根据我们上文的分析,我们这里的子类是
ServletWebServerApplicationContext。

Spring Boot 中的 Tomcat 是如何启动的?

到这里,其实庐山真面目已经出来了,createWebServer()就是启动 Web 服务,但是还没有真正启动 Tomcat,既然webServer是通过ServletWebServerFactory来获取的,我们就来看看这个工厂的真面目。

Spring Boot 中的 Tomcat 是如何启动的?

走进 Tomcat 内部

根据上图我们发现,工厂类是一个接口,各个具体服务的实现是由各个子类来实现的,所以我们就去看看
TomcatServletWebServerFactory.getWebServer()的实现。

 @Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
		Tomcat tomcat = new 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);
return getTomcatWebServer(tomcat);
	}

根据上面的代码,我们发现其主要做了两件事情,第一件事就是把 Connnctor (我们称之为连接器)对象添加到 Tomcat 中,第二件事就是configureEngine,这连接器我们勉强能理解(不理解后面会述说),那这个Engine是什么呢?我们查看tomcat.getEngine()的源码:

 
public Engine getEngine() {
 Service service = getServer().findServices()[0];
 if (service.getContainer() != null) {
 return service.getContainer();
 }
 Engine engine = new StandardEngine();
 engine.setName( "Tomcat" );
 engine.setDefaultHost(hostname);
 engine.setRealm(createDefaultRealm());
 service.setContainer(engine);
 return engine;
 }

根据上面的源码,我们发现,原来这个 Engine 是容器,我们继续跟踪源码,找到Container接口

Spring Boot 中的 Tomcat 是如何启动的?

上图中,我们看到了4个子接口,分别是 Engine,Host,Context,Wrapper。我们从继承关系上可以知道他们都是容器,那么他们到底有啥区别呢?我看看他们的注释是怎么说的。

 
/**
 If used, an Engine is always the top level Container in a Catalina
 * hierarchy. Therefore, the implementation's <code>setParent()</code> method
 * should throw <code>IllegalArgumentException</code>.
 *
 * @author Craig R. McClanahan
 */
public interface Engine extends Container {
 //省略代码
}
/**
 * <p>
 * The parent Container attached to a Host is generally an Engine, but may
 * be some other implementation, or may be omitted if it is not necessary.
 * </p><p>
 * The child containers attached to a Host are generally implementations
 * of Context (representing an individual servlet context).
 *
 * @author Craig R. McClanahan
 */
public interface Host extends Container {
//省略代码
 
}
/*** </p><p>
 * The parent Container attached to a Context is generally a Host, but may
 * be some other implementation, or may be omitted if it is not necessary.
 * </p><p>
 * The child containers attached to a Context are generally implementations
 * of Wrapper (representing individual servlet definitions).
 * </p><p>
 *
 * @author Craig R. McClanahan
 */
public interface Context extends Container, ContextBind {
 //省略代码
}
/**</p><p>
 * The parent Container attached to a Wrapper will generally be an
 * implementation of Context, representing the servlet context (and
 * therefore the web application) within which this servlet executes.
 * </p><p>
 * Child Containers are not allowed on Wrapper implementations, so the
 * <code>addChild()</code> method should throw an
 * <code>IllegalArgumentException</code>.
 *
 * @author Craig R. McClanahan
 */
public interface Wrapper extends Container {
 //省略代码
}

上面的注释翻译过来就是,Engine是最高级别的容器,其子容器是Host,Host的子容器是Context,Wrapper是Context的子容器,所以这4个容器的关系就是父子关系,也就是Engine>Host>Context>Wrapper。我们再看看Tomcat类的源码:

Spring Boot 中的 Tomcat 是如何启动的?

阅读Tomcat的getServer()我们可以知道,Tomcat的最顶层是Server,Server 就是Tomcat的实例,一个Tomcat一个Server;通过getEngine()我们可以了解到 Server 下面是 Service,而且是多个,一个 Service 代表我们部署的一个应用,而且我们还可以知道,Engine容器,一个service只有一个;根据父子关系,我们看setHost()源码可以知道,host容器有多个;同理,我们发现addContext()源码下,Context也是多个;addServlet()表明Wrapper容器也是多个,而且这段代码也暗示了,其实Wrapper和Servlet是一层意思。另外我们根据setConnector源码可以知道,连接器(Connector)是设置在service下的,而且是可以设置多个连接器(Connector)。

根据上面分析,我们可以小结下:Tomcat 主要包含了2个核心组件,连接器(Connector)和容器(Container),用图表示如下:

Spring Boot 中的 Tomcat 是如何启动的?

一个Tomcat是一个Server,一个Server下有多个service,也就是我们部署的多个应用,一个应用下有多个连接器(Connector)和一个容器(Container),容器下有多个子容器,关系用图表示如下:

Spring Boot 中的 Tomcat 是如何启动的?

Engine下有多个Host子容器,Host下有多个Context子容器,Context下有多个Wrapper子容器。

总结

Spring Boot 的启动是通过new SpringApplication()实例来启动的,启动过程主要做如下几件事情:> 1. 配置属性 > 2. 获取监听器,发布应用开始启动事件 > 3. 初始化输入参数 > 4. 配置环境,输出banner > 5. 创建上下文 > 6. 预处理上下文 > 7. 刷新上下文 > 8. 再刷新上下文 > 9. 发布应用已经启动事件 > 10. 发布应用启动完成事件

而启动 Tomcat 就是在第7步中“刷新上下文”;Tomcat 的启动主要是初始化2个核心组件,连接器(Connector)和容器(Container),一个 Tomcat 实例就是一个 Server,一个 Server 包含多个 Service,也就是多个应用程序,每个 Service 包含多个连接器(Connetor)和一个容器(Container),而容器下又有多个子容器,按照父子关系分别为:Engine,Host,Context,Wrapper,其中除了 Engine 外,其余的容器都是可以有多个

Spring Boot是如何启动Tomcat的 在创建Spring容器过程中,会利⽤@ConditionalOnClass技术来判断当前classpath中是否存在Tomcat依赖,如果存在则会⽣成⼀个启动Tomcat的Bean。Spring容器创建完之后,就会获取启动Tomcat的Bean,并创建Tomcat对象,并绑定端⼝等,然后启动Tomcat。实现一键启动,无需手动部署 WAR 文件。动态选择服务器(Tomcat/Jetty/Undertow)。:默认 NIO 连接器,支持线程池参数调优。:Tomcat 作为库打包到应用中,启动 Tomcat。 阅读详情

相关推荐

Spring Boot启动过程(六):内嵌Tomcat中StandardHost、StandardContext和StandardWrapper的启动

看代码有助于线上出现预料之外的事的时候,不至于心慌。。。    StandardEngine[Tomcat].StandardHost[localhost]的启动与StandardEngine不在同一个线程中,它的start: // Start our child containers, if any Container children[] = f

tmchongye的专栏 4323

SpringBoot中内置的Tomcat如何启动的?

在springboot项目中,我们只需要引入spring-boot-starter-web依赖,启动服务成功,我们一个web服务就搭建好了,没有明显的看到tomcat。其实打开spring-boot-starter-web依赖,我们可以看到:依赖了tomcat。 1.进入Springboot启动类。我们加入Springboot最核心的注解@SpringBootApplication,源码如下图:重点看注解@EnableAutoConfiguration, 2.进入注解@EnableAutoCo.

孙振宁 8161

【SpringBoot系列】Spring Boot 中tomcat的启动

好久没写了,今天继续,虽然类似的文章在网上也能搜到,但是还是自己记录下,也是实际的去探索下,说一下自己的方法上面堆栈的第4个,也就是run:307 堆栈,看到如下代码这里可以看到根据不同的webApplicationType 会创建不同的web服务器这里的问题是webApplicationType 是怎么赋值的呐?直接搜索,可以看到构造函数的时候进行赋值的点进去看实现,是一个静态的函数,是根据当前路径下的类判断,返回是REACTIVE 还是Servlet。

我是香菜 1051

Spring是如何运行在tomcat服务中的?

1.Tomcat如何启动Spring容器的? 2.springboot内置的tomcat是如何启动的? 3.通过war包部署的springboot又是如何启动的?

学而不思则罔 3679

告别误唤醒!S32K3xx低功耗设计避坑指南:Fast Standby模式与WISR寄存器操作详解

本文深入解析了NXP S32K3xx系列MCU在低功耗设计中常见的误唤醒问题,并提供了基于Fast Standby模式的解决方案。文章重点剖析了DCMRWF5寄存器的配置方法、WISR/WISR_64唤醒中断状态寄存器的标志位处理策略,以及如何利用32KB Standby SRAM保存唤醒状态,从而帮助开发者构建稳定可靠的汽车电子低功耗系统。

weixin_29163857的博客 366

SAP 资产主数据屏幕增强:对比字段追加与子屏幕/页签 2 种方案优劣

本文深入对比了SAP资产主数据(AS01/AS03)屏幕增强的两种方案:字段追加与子屏幕/页签。从技术实现、业务适配、系统维护等维度分析各自优劣,提供方案选型决策树和混合方案实践建议,帮助企业在SAP实施中做出最优选择。

weixin_28559803的博客 285

SpringBoot项目中tomcat容器启动流程

SpringBoot项目中tomcat容器启动流程

lgb105的博客 1733

FPGA赋能:从加权灰度均值到快速收敛的自动曝光实战

本文深入探讨了FPGA在工业视觉自动曝光算法中的应用,重点介绍了加权灰度均值法的优化实现与快速收敛策略。通过硬件友好的算法改造和流水线架构设计,FPGA方案能在1帧内完成曝光调整,显著提升处理速度和能效比,适用于复杂光照条件下的工业检测场景。

weixin_29306317的博客 83

spring boot启动加载tomcat原理深度剖析

spring boot应用打包成Fat jar时,启动内嵌tomcat的原理;spring boot应用打包成WAR时,外部tomcat启动spring boot SpringApplication的原理;自动化配置Servlet/ServletFilter/ServletListener的原理

ac_dao_di的专栏 5793

Agentic RAG:RAG从静态到具有理解、推理、决策的Agentic RAG

RAG技术演进:从静态检索到智能代理 RAG(检索增强生成)技术经历了五个关键发展阶段:基础RAG(关键词检索)、高级RAG(语义理解)、模块化RAG(灵活架构)、图RAG(知识图谱)和最新的Agentic RAG(智能代理)。Agentic RAG通过引入自主AI代理,具备反思、规划、工具使用和多代理协作能力,实现了动态决策和自适应工作流。相比传统RAG的静态检索流程,Agentic RAG能处理复杂多步推理任务,通过自我改进机制提高输出质量,并支持多专业代理协作,显著提升了RAG系统在复杂场景下的表现。

2551

SoapUI 5.0 模拟WebService接口实战:从WSDL文件到Mock服务端完整流程

本文详细介绍了如何使用SoapUI 5.0模拟WebService接口,从解析WSDL文件到搭建完整的Mock服务端流程。通过实战案例和效率技巧,帮助开发者快速掌握接口模拟技术,提升开发与测试效率。

weixin_26833139的博客 409

Spring Boot 中 Tomcat 的启动流程

特性说明默认容器Spring Boot 默认使用嵌入式 Tomcat(启动入口→refresh()→→核心组件ConnectorServlet 初始化→→init()HTTP 监听→→ NIO 线程池启动性能优化使用 NIO、延迟加载、GZIP 压缩、APR/native 模式源码路径。

红血哥 1404

携程机票数据爬取实战:使用 Python 获取携程网机票信息

通过本篇博客,我们详细介绍了如何使用 Python 爬取携程网的机票信息,涉及了静态网页爬取(使用 Requests 和 BeautifulSoup)和动态网页爬取(使用 Selenium)两种方法。通过获取的数据,我们不仅能够进行票价分析,还可以构建更为复杂的预测模型或趋势分析工具。爬虫技术不仅能够帮助我们收集有价值的数据,还能够为商业决策提供数据支持。在实际应用中,我们可以结合更多的分析方法,如自然语言处理、图像处理等,进一步提升数据的价值。

2201_76125261的博客 1659

springboot启动后怎么访问_Tomcat在Spring Boot中是怎么启动的呢?

Spring Boot一个非常突出的优点就是不需要我们额外再部署Servlet容器,它内置了多种容器的支持。我们可以通过配置来指定我们需要的容器。本文以我们平时最常使用的容器Tomcat为列来介绍以下两个知识点:Spring Boot是怎么整合启动Tomcat容器的;在Spring Boot中,怎么进行Tomcat的深度配置。Spring Boot整合启动Tomcat的流程对于看源代码,每个人都有...

weixin_42515990的博客 1735

基于深度学习的番茄成熟度检测系统——YOLOv5、YOLOv8、YOLOv10及UI界面的实现

YOLO是一种快速且准确的目标检测模型,近年来,YOLOv5、YOLOv8和YOLOv10作为YOLO系列的重要版本,分别在速度、精度和效率上进行了优化。下面我们简要介绍这些模型。本文介绍了如何基于YOLOv5、YOLOv8和YOLOv10等深度学习模型,结合PyQt5设计一个番茄成熟度检测系统。通过训练模型、优化算法和设计用户友好的界面,我们能够构建一个高效且准确的番茄成熟度检测系统,广泛应用于农业自动化和智能化管理中。

YOLO 1002

对MixPad精灵(触屏语音开关)进行解剖分析

概述 最近有点忙,已经很久没有更新文章了,对不起各位网友啦~ 这次对ORVIBO的新产品:MixPad精灵款的来个剖析,希望对大家有所帮助! 首先,我买了一台对应的设备,直接去官网采购,价格吗还算OK,400多的价格。 拆箱的过程我就不写了,简单的上个图就行了。 一、拆包: 主屏板包装盒(顶部): 主屏板包装盒(底部): 后盖电源部分无内容,我就不拍了,给优快云空间省点存储位置。 二、设备剖析开始 接下来,我们开始对设备进行剖析,步骤如下: 1、拆掉主屏板后盖板,...

LeeKwen的专栏 3947

四,分析Spring Boot底层机制(Tomcat 启动分析+Spring容器初始化+Tomcat如何关联 Spring 容器) 以及个人编写启动 Tomcat

在这个最后的篇章中,我要表达我对每一位读者的感激之情。你们的关注和回复是我创作的动力源泉,我从你们身上吸取了无尽的灵感与勇气。我会将你们的鼓励留在心底,继续在其他的领域奋斗。

weixin_61635597的博客 2906

win10 跳过U8环境检测的IE WebControls.rar

win10 安装u8的时候 提示IE WebControls 不通过,这个工具可以欺骗u8的检查。 跳过U8环境检测的IE WebControls。提示导入失败后,重新检测通过。

Spring Boot 外置Tomcat启动原理

SPI机制装配SpringServletContainerInitializer // 注入WebApplicationInitializer @HandlesTypes(WebApplicationInitializer.class) public class SpringServletContainerInitializer implements ServletContainerIniti...

Forrest Gump的博客 537

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

迈瑞BS系列全自动生化分析仪LIS协议接口手册(内含HL7和ASTM)

迈瑞BS系列全自动生化分析仪LIS协议接口手册,内含HL7和ASTM)

Spring Boot 内嵌Tomcat启动原理

1、Tomcat的自动装配 WebServerFactory自动配置类:负责创建Tomcat、Netty、Jetty等 org.springframework.boot.autoconfigure.web.embedded.EmbeddedWebServerFactoryCustomizerAutoConfiguration @Configuration @ConditionalOnWebAppl...

Forrest Gump的博客 1205

假人有限元模型

假人模型,车辆碰撞假人有限元模型,适合做乘员安全的研究者利用

Spring Boot 应用使用tomcat启动实现及原理

综上所述,我们可以得出结论,在servlet容器(tomcat)启动时,会调用SPI的相关逻辑调用到spring提供的实现类SpringServletContainerInitializer在该类的实现方法onStartup时,会把该类上注解中WebApplicationInitializer 接口的实现类传递给该方法的参数(webAppInitializerClasses)

qq_40270466的博客 1750

Spring Boot内嵌Tomcat启动

之前在Spring Boot启动过程(二)提到过createEmbeddedServletContainer创建了内嵌的Servlet容器,我用的是默认的Tomcat。 private void createEmbeddedServletContainer() { EmbeddedServletContainer localContainer = this.embe...

u014368614的博客 1392

Spring Boot 内置 Tomcat 启动原理:彻底搞懂“自动启动”的魔法

本文深入解析了SpringBoot内置Tomcat的启动机制,从依赖引入到自动配置,再到生命周期同步。通过ServletWebServerFactoryAutoConfiguration自动创建TomcatServletWebServerFactory,在Spring容器刷新时触发createWebServer()方法,最终启动原生Tomcat实例。关键点在于TomcatStarter作为桥梁,将Spring组件动态注册到Tomcat的ServletContext中。文章还介绍了三种定制方式:配置文件、编程

油墨香^-^的博客 1495

Spring Boot揭秘:一个JAR包如何神奇地启动内嵌Tomcat?

Spring Boot可执行JAR包通过巧妙设计实现内嵌Tomcat的一键启动。其核心机制包括:1) 特殊的JAR结构通过JarLauncher启动;2) 分层类加载器加载应用和依赖;3) SpringApplication在刷新上下文时自动创建Tomcat实例;4) 条件化自动配置动态判断Web环境。整个过程体现了约定优于配置的理念,开发者只需关注main方法,框架自动处理容器集成、Servlet注册等复杂逻辑,实现从传统WAR部署到轻量JAR的范式转变。

张小洛的BOLG 1472

Spring Boot:内置tomcat启动和外部tomcat部署总结

下面举一些常用的例子。因为SpringBootServletInitializer需要依赖 javax.servlet,而tomcat-embed-jasper下面的tomcat-embed-core中就有这个javax.servlet,如果没用provided,最终打好的war里面会有servlet-api这个jar,这样就会跟tomcat本身的冲突了。典型的例子是servlet-api,编译和测试项目的时候需要该依赖,但在运行项目的时候,由于容器以及提供,就不需要Maven重复地引入一遍。

m0_61083409的博客 1237

Tomcat在Spring Boot中是怎么启动的?

Spring Boot一个非常突出的优点就是不需要我们额外再部署Servlet容器,它内置了多种容器的支持。我们可以通过配置来指定我们需要的容器。 本文以我们平时最常使用的容器Tomcat为列来介绍以下两个知识点: Spring Boot是怎么整合启动Tomcat容器的; 在Spring Boot中,怎么进行Tomcat的深度配置。 Spring Boot整合启动Tomcat的流程 对于看源代码,每个人都有自己的方法。我自己在看源代码的时候喜欢结合IDEA的Debug功能一起看。比如说现在我们要研究Sp

Java_Yhua的博客 240
上一篇: 微服务网关除了zuul、spring cloud gateway还有更出色的
下一篇: 为什么要读源代码,如何阅读源代码
Javaesandyou
博客等级 码龄5年 742粉丝 563原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值