本章我们来讲讲Spring Boot web项目两种部署方式，第一种是jar包部署；第二种是war包部署，本文将分别介绍两种方式的原理。
1 jar包部署
1.1 创建demo
首先创建Spring Boot项目,在pom.xml中引入WEB依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
启动类上加入springmvc注解
@SpringBootApplication
@RestController
public class SpringBootLearnDemo1Application {
public static void main(String[] args) {
SpringApplication.run(SpringBootLearnDemo1Application.class, args);
}
@RequestMapping("/hello")
public String hello() {
return "hello springboot";
}
}
好了以上就是一个简单的demo，然后我们开始启动项目。
打成jar包，在jar包目录下通过java -jar 启动项目
启动成功如下，可以看到端口为8080
访问地址：http://127.0.0.1:8080/hello结果如下
1.2 启动原理
为什么通过java -jar 方式可以启动我们Spring Boot web项目呢？
首先我们知道java -jar 方式启动执行jar包执行的是项目根目录下面的/META-INF/MANIFEST.MF文件中配置的主类(Main-Class)的main方法，现在打开jar找到MANIFEST.MF文件如下
可以看到该文件见中有两个配置Main-Class，Start-Class，这些配置都是在我们打包时通过我们在pom.xml文件中配置的插件spring-boot-maven-plugin配置的
现在我们打开配置的Main-Class，打开该类需要引入如下依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-loader</artifactId>
</dependency>
打开JarLauncher找到main方法
main方法中创建了JarLauncher对象，调用了launch方法。
进入launch方法
launch方法里获取了ClassLoader，且通过getMainClass方法获取了Spring Boot启动类。
进入getMainClass方法
可以看出该方法在获取MANIFEST.MF文件中配置的Start-Class，而前文我们已经知道Start-Class为com.jt.springbootlearndemo1.SpringBootLearnDemo1Applicati即是Spring Boot的启动类
返回launch方法中，该方法的最后一行调用了另一个launch重载方法
进入launch重载方法
该方法创建了一个MainMethodRunner对象，调用了其run方法
直接进入MainMethodRunner的run方法
该方法通过反射执行了Spring Boot启动类的main方法
我们知道web项目都是运行在web容器当中，而Spring Boot内置了web容器，如tomcat，那么Spring Boot启动类的main方法是如何启动tomcat？
进入启动类的main方法
可以看到调用了SpringApplication的静态run方法，一路跟进去发现调用了其另一个非静态run方法。
进入run方法
public ConfigurableApplicationContext run(String... args) {
StopWatch stopWatch = new StopWatch();
stopWatch.start();
/**
*定义了spring容器
*/
ConfigurableApplicationContext context = null;
Collection<SpringBootExceptionReporter> exceptionReporters = new ArrayList<>();
configureHeadlessProperty();
SpringApplicationRunListeners listeners = getRunListeners(args);
listeners.starting();
try {
ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);
configureIgnoreBeanInfo(environment);
Banner printedBanner = printBanner(environment);
/**
*创建spring容器AnnotationConfigServletWebServerApplicationContext
*/
context = createApplicationContext();
exceptionReporters = getSpringFactoriesInstances(SpringBootExceptionReporter.class,
new Class[] { ConfigurableApplicationContext.class }, context);
prepareContext(context, environment, listeners, applicationArguments, printedBanner);
/**
* 初始化容器
*/
refreshContext(context);
afterRefresh(context, applicationArguments);
stopWatch.stop();
if (this.logStartupInfo) {
new StartupInfoLogger(this.mainApplicationClass).logStarted(getApplicationLog(), stopWatch);
}
listeners.started(context);
callRunners(context, applicationArguments);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, listeners);
throw new IllegalStateException(ex);
}
try {
listeners.running(context);
}
catch (Throwable ex) {
handleRunFailure(context, ex, exceptionReporters, null);
throw new IllegalStateException(ex);
}
return context;
}
目前我们只看我注释的地方，即创建了一个SpringBoot实现的spring容器（AnnotationConfigServletWebServerApplicationContext），并初始化容器。
进入初始化容器的方法refreshContext
该方法又调用了refresh方法，一路refresh下去，最终调用了AbstractApplicationContext的refresh，如下
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.
/**
* Spring Boot实现了该方法创建了web容器
*/
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();
}
}
}
该方法为容器的初始化方法，加载了BeanDefinition,并实例化。Spring Boot实现了该方法调用的onRefresh创建了web容器。
进入onRefresh方法
调用了createWebServer方法
private void createWebServer() {
WebServer webServer = this.webServer;
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
/**
* 实例化了创建web容器的工厂类
*/
ServletWebServerFactory factory = getWebServerFactory();
/**
* 通过工程类创建web容器
*/
this.webServer = factory.getWebServer(getSelfInitializer());
getBeanFactory().registerSingleton("webServerGracefulShutdown",
new WebServerGracefulShutdownLifecycle(this.webServer));
getBeanFactory().registerSingleton("webServerStartStop",
new WebServerStartStopLifecycle(this, this.webServer));
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context", ex);
}
}
initPropertySources();
}
该类通过ServletWebServerFactory 工厂类的getWebServer方法创建了web容器。
进入getWebServer方法
@Override
public WebServer getWebServer(ServletContextInitializer... initializers) {
if (this.disableMBeanRegistry) {
Registry.disableRegistry();
}
Tomcat tomcat = new Tomcat();
File baseDir = (this.baseDirectory != null) ? this.baseDirectory : createTempDir("tomcat");
tomcat.setBaseDir(baseDir.getAbsolutePath());
Connector connector = new Connector(this.protocol);
connector.setThrowOnFailure(true);
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容器
*/
return getTomcatWebServer(tomcat);
}
在该方法中创建并启动了Tomcat容器；启动tomcat容器在最后一行调用了getTomcatWebServer方法，进入该方法
protected TomcatWebServer getTomcatWebServer(Tomcat tomcat) {
return new TomcatWebServer(tomcat, getPort() >= 0, getShutdown());
}
该方法中将tomcat封装成了TomcatWebServer，进入其构造方法
在该方法中最后一行调用initialize方法启动了容器，进入方法
private void initialize() throws WebServerException {
logger.info("Tomcat initialized with port(s): " + getPortsDescription(false));
synchronized (this.monitor) {
try {
addInstanceIdToEngineName();
Context context = findContext();
context.addLifecycleListener((event) -> {
if (context.equals(event.getSource()) && Lifecycle.START_EVENT.equals(event.getType())) {
// Remove service connectors so that protocol binding doesn't
// happen when the service is started.
removeServiceConnectors();
}
});
// Start the server to trigger initialization listeners
/**
* 启动tomcat容器
*/
this.tomcat.start();
// We can re-throw failure exception directly in the main thread
rethrowDeferredStartupExceptions();
try {
ContextBindings.bindClassLoader(context, context.getNamingToken(), getClass().getClassLoader());
}
catch (NamingException ex) {
// Naming is not enabled. Continue
}
// Unlike Jetty, all Tomcat threads are daemon threads. We create a
// blocking non-daemon to stop immediate shutdown
startDaemonAwaitThread();
}
catch (Exception ex) {
stopSilently();
destroySilently();
throw new WebServerException("Unable to start embedded Tomcat", ex);
}
}
}
该方法中通过 this.tomcat.start()启动了tomcat，以上就是jar包方式启动的原理。
2 war包部署
前面我们说了jar包部署，Spring Boot也给我们提供了war包部署方式。
2.1 创建demo
修改pom.xml文件，配置packaging为war包方式，显示指定spring-boot-starter-tomcat,并将scope属性配置为provided，表示打包的时候将不会将该依赖打进去。
创建一个WebApplicationInitializer接口的子类，不直接实现该接口Spring Boot已经帮我们实现了一个SpringBootServletInitializer，继承该类并重写configure方法，在SpringApplicationBuilder 中传入启动类。
public class MyServletInitializer extends SpringBootServletInitializer {
@Override
protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
return builder.sources(SpringBootLearnDemo1Application.class);
}
}
配置完毕，打成war部署到tomcat即可
2.2 启动原理
我们知道使用springmvc的时候我们需要在web.xml文件中配置DispatcherServlet，在初始化方法里spring容器启动，那使用springbooot打成war部署到tomcat是如何启动spring容器的呢？下面让我们一起来看看Spring Boot打成war包是如何启动spring容器的。
首先看我们新创建的类
该类继承了SpringBootServletInitializer，查看其类图
SpringBootServletInitializer实现了WebApplicationInitializer接口，我们知道该接口是spring利用servlet3.0特性做的一个扩展，在tomcat容器启动的时候会调其onStartup方法，下面进入onStartup方法
public void onStartup(ServletContext servletContext) throws ServletException {
// Logger initialization is deferred in case an ordered
// LogServletContextInitializer is being used
this.logger = LogFactory.getLog(getClass());
/**
* 这里创建了web容器
*/
WebApplicationContext rootApplicationContext = createRootApplicationContext(servletContext);
if (rootApplicationContext != null) {
servletContext.addListener(new SpringBootContextLoaderListener(rootApplicationContext, servletContext));
}
else {
this.logger.debug("No ContextLoaderListener registered, as createRootApplicationContext() did not "
+ "return an application context");
}
}
可以看到该方法中调用createRootApplicationContext方法创建了spring容器。
进入createRootApplicationContext方法
protected WebApplicationContext createRootApplicationContext(ServletContext servletContext) {
SpringApplicationBuilder builder = createSpringApplicationBuilder();
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(AnnotationConfigServletWebServerApplicationContext.class);
builder = configure(builder);
builder.listeners(new WebEnvironmentPropertySourceInitializer(servletContext));
/**
* 创建SpringApplication
*/
SpringApplication application = builder.build();
if (application.getAllSources().isEmpty()
&& MergedAnnotations.from(getClass(), SearchStrategy.TYPE_HIERARCHY).isPresent(Configuration.class)) {
application.addPrimarySources(Collections.singleton(getClass()));
}
Assert.state(!application.getAllSources().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.addPrimarySources(Collections.singleton(ErrorPageFilterConfiguration.class));
}
application.setRegisterShutdownHook(false);
return run(application);
}
该方法创建了一个SpringApplicationBuilder，见名知意，肯定是使用该类创建了一个SpringApplication，这个类大家是否有似曾相识的感觉，上文中通过jar包部署就是调用了该类的run方法启动，下面我们进入该方法的最后一行，调用了run方法。
果然在run方法里面调用SpringApplication的run方法，进入了和上文中jar包方式相同的逻辑。
但是这个逻辑不是会在spring容器初始化的时候，在onRefresh方法中启动内置的tomcat容器吗？
我们再次来看onRefresh方法
进入createWebServer方法
private void createWebServer() {
WebServer webServer = this.webServer;
/**
* 由于我们同tomcat以及启动所以servletContext不为空
* 所以不走内容容器的逻辑
*/
ServletContext servletContext = getServletContext();
if (webServer == null && servletContext == null) {
ServletWebServerFactory factory = getWebServerFactory();
this.webServer = factory.getWebServer(getSelfInitializer());
getBeanFactory().registerSingleton("webServerGracefulShutdown",
new WebServerGracefulShutdownLifecycle(this.webServer));
getBeanFactory().registerSingleton("webServerStartStop",
new WebServerStartStopLifecycle(this, this.webServer));
}
else if (servletContext != null) {
try {
getSelfInitializer().onStartup(servletContext);
}
catch (ServletException ex) {
throw new ApplicationContextException("Cannot initialize servlet context", ex);
}
}
initPropertySources();
}
该方法在创建Tomcat容器之前判断了ServletContext是否为空，由于tomcat已经先启动所以此处的ServletContext是不等于空的所以，不会走内置tomcat容器。以上就是war部署方式的原理。
3 总结
以上就是jar包和war包部署的启动原理，我们可以看出这是两个相反的逻辑，jar包部署是spring容器带动tomcat容器启动，而war包部署是tomcat容器带动spring容器启动。
4 其他启动方式
除了以上介绍的启动方式，还有：
1.不需要打包直接进入项目的pom.xml文件所在目录，maven插件启动
mvn spring-boot:run
2.进入jar或war目录, loader 启动
java org.springframework.boot.loader.JarLauncher
java org.springframework.boot.loader.WarLauncher
873
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
